feat(native): report reference extraction errors natively

crates/sqlbuild-python/src/bindings/_helpers/sqltext/sql_references.rs

@@ -3,16 +3,23 @@
 use pyo3::prelude::{Bound, PyModule, PyModuleMethods, PyResult};
 use pyo3::{pyclass, pymethods};
 use sqlbuild_sqltext::sql_references::main::extract_sql_references::extract_sql_references;
-use sqlbuild_sqltext::sql_references::models::{ReferenceExtraction, SqlReference};
+use sqlbuild_sqltext::sql_references::models::{
+    InvalidReferenceCall, ReferenceExtraction, SqlReference,
+};
 use sqlbuild_sqltext::sql_scan::models::LexicalSyntax;
 
 use crate::bindings::_helpers::boundary::panics::compiler_guard;
 use crate::bindings::_helpers::sqltext::lexical_syntax::LexicalSyntaxInput;
 
 /// `(kind, name, package, call_argument_count)` for one reference.
 type ReferenceRow = (&'static str, String, Option<String>, Option<usize>);
-/// The references, or Python's error message; `None` defers the text to Python.
-type ExtractionRow = Option<(Option<Vec<ReferenceRow>>, Option<String>)>;
+/// `(kind, call, start, message, help, corrected_call)` for one rejected call.
+type InvalidCallRow = (&'static str, String, usize, String, String, String);
+/// The references and rejected calls, or Python's error and its start; `None` defers.
+type ExtractionRow = Option<(
+    Option<(Vec<ReferenceRow>, Vec<InvalidCallRow>)>,
+    Option<(String, usize)>,
+)>;
 
 /// Extracts references under one adapter's lexical rules, read once per syntax.
 #[pyclass(module = "sqlbuild._native", frozen)]
@@ -29,15 +36,23 @@ impl SqlReferenceScanner {
         }
     }
 
-    /// Return `(references, None)`, `(None, message)` when Python raises, or `None` to defer.
+    /// Return `((references, rejected calls), None)`, `(None, (message, start))`, or `None`.
     fn extract(&self, sql: &str) -> PyResult<ExtractionRow> {
         compiler_guard(|| {
             Ok(match extract_sql_references(sql, &self.syntax) {
-                ReferenceExtraction::Extracted(references) => Some((
-                    Some(references.into_iter().map(reference_row).collect()),
+                ReferenceExtraction::Extracted(scan) => Some((
+                    Some((
+                        scan.references.into_iter().map(reference_row).collect(),
+                        scan.invalid_calls
+                            .into_iter()
+                            .map(invalid_call_row)
+                            .collect(),
+                    )),
                     None,
                 )),
-                ReferenceExtraction::Failed(message) => Some((None, Some(message))),
+                ReferenceExtraction::Failed(failure) => {
+                    Some((None, Some((failure.message, failure.start))))
+                }
                 ReferenceExtraction::Deferred => None,
             })
         })
@@ -53,6 +68,17 @@ fn reference_row(reference: SqlReference) -> ReferenceRow {
     )
 }
 
+fn invalid_call_row(call: InvalidReferenceCall) -> InvalidCallRow {
+    (
+        call.kind,
+        call.call,
+        call.start,
+        call.message,
+        call.help,
+        call.corrected_call,
+    )
+}
+
 pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_class::<SqlReferenceScanner>()?;
     Ok(())