Change NativeFunction error type from String to VmError

NativeFunction.func now returns Result<Value, VmError> instead of
Result<Value, String>. VmError carries an optional span so errors from
HOF callbacks (e.g. a failing lambda inside map) preserve the inner
span rather than collapsing to the call site. The VM fills in the
call-site span only when the error arrives without one.

Also extracts VmError into ndc_vm/src/error.rs to break the circular
dependency between value.rs and vm.rs, and removes the now-unused
attach_vm_native_hof helper.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

Author: timfennis

ndc_bin/src/diagnostic.rs

@@ -77,7 +77,7 @@ impl From<InterpreterError> for NdcReport {
             },
             InterpreterError::Vm(err) => Self {
                 message: err.message.clone(),
-                span: Some(span_to_source_span(err.span)),
+                span: err.span.map(span_to_source_span),
                 label: "related to this",
                 help: None,
             },

ndc_interpreter/src/environment.rs

@@ -132,6 +132,7 @@ impl Environment {
         root.global_functions.push(new_function.clone());
     }
 
+
     #[must_use]
     pub fn get(&self, var: ResolvedVar) -> Value {
         match var {

ndc_interpreter/src/function.rs

@@ -91,6 +91,11 @@ impl Function {
         }
     }
 
+    /// Attaches or replaces the VmNative body on this function.
+    pub fn set_vm_native(&mut self, native: Rc<VmNativeFunction>) {
+        self.vm_native = Some(native);
+    }
+
     pub fn vm_native(&self) -> Option<Rc<VmNativeFunction>> {
         self.vm_native.clone()
     }
@@ -349,7 +354,7 @@ impl FunctionBody {
                                 .iter()
                                 .map(|a| crate::vm_bridge::interp_to_vm(a.clone()))
                                 .collect();
-                            let result = (native.func)(&vm_args).map_err(|e| {
+                            let result = (native.func)(&vm_args, &[]).map_err(|e| {
                                 FunctionCarrier::IntoEvaluationError(Box::new(anyhow::anyhow!(e)))
                             })?;
                             return Ok(crate::vm_bridge::vm_to_interp(&result));

ndc_interpreter/src/vm_bridge.rs

@@ -6,6 +6,7 @@ use std::rc::Rc;
 
 use ndc_core::int::Int;
 use ndc_core::num::Number;
+use ndc_vm::VmError;
 use ndc_vm::VmIterator;
 use ndc_vm::value::{
     Function as VmFunction, NativeFunction, Object as VmObject, OrdValue, Value as VmValue,
@@ -82,7 +83,7 @@ fn wrap_function(
 ) -> VmValue {
     let name = func.name().to_string();
     let static_type = func.static_type();
-    let native = move |args: &[VmValue]| -> Result<VmValue, String> {
+    let native = move |args: &[VmValue], _globals: &[VmValue]| -> Result<VmValue, VmError> {
         let globals = Rc::new(globals_cell.borrow().clone());
         // Convert VM args to interpreter args, preserving Rc identity for heap/deque
         // values that appear more than once (so pointer-equality comparisons like `h == h` work).
@@ -112,8 +113,10 @@ fn wrap_function(
                 }
                 Ok(interp_to_vm(result))
             }
-            Err(FunctionCarrier::IntoEvaluationError(e)) => return Err(e.to_string()),
-            Err(e) => return Err(e.to_string()),
+            Err(FunctionCarrier::IntoEvaluationError(e)) => {
+                return Err(VmError::native(e.to_string()));
+            }
+            Err(e) => return Err(VmError::native(e.to_string())),
         }
     };
     VmValue::Object(Rc::new(VmObject::Function(VmFunction::Native(Rc::new(
@@ -363,12 +366,12 @@ fn interp_to_vm_for_inverted_bridge(value: &InterpValue) -> VmValue {
         let callback = Rc::new(NativeFunction {
             name,
             static_type,
-            func: Box::new(move |vm_args: &[VmValue]| {
+            func: Box::new(move |vm_args: &[VmValue], _globals: &[VmValue]| {
                 let mut interp_args: Vec<InterpValue> = vm_args.iter().map(vm_to_interp).collect();
                 let dummy_env = Rc::new(RefCell::new(Environment::new(Box::new(Vec::<u8>::new()))));
                 f.call(&mut interp_args, &dummy_env)
                     .map(|v| interp_to_vm(v))
-                    .map_err(|e| e.to_string())
+                    .map_err(|e| VmError::native(e.to_string()))
             }),
         });
         return VmValue::Object(Rc::new(VmObject::Function(VmFunction::Native(callback))));
@@ -408,8 +411,8 @@ pub(crate) fn call_vm_native(
     let vm_args: Vec<VmValue> = args.iter().map(interp_to_vm_for_inverted_bridge).collect();
 
     // 2. Call the vm_native closure
-    let vm_result = (native.func)(&vm_args)
-        .map_err(|e| FunctionCarrier::IntoEvaluationError(Box::new(anyhow::anyhow!(e))))?;
+    let vm_result = (native.func)(&vm_args, &[])
+        .map_err(|e| FunctionCarrier::IntoEvaluationError(Box::new(anyhow::anyhow!(e.message))))?;
 
     // 3. Sync mutations back (vm → interp direction).
     //    Strings do NOT need syncing — interp_to_vm_for_inverted_bridge shares the
@@ -440,7 +443,7 @@ fn vm_to_interp_callable(value: &VmValue, globals: Rc<Vec<VmValue>>) -> InterpVa
                     let vm_args: Vec<VmValue> =
                         args.iter().map(|a| interp_to_vm(a.clone())).collect();
                     let result = Vm::call_function(f.clone(), vm_args, (*globals).clone())
-                        .map_err(|e| anyhow::anyhow!(e))?;
+                        .map_err(|e| anyhow::anyhow!(e.message))?;
                     Ok(vm_to_interp(&result))
                 });
             let data: Rc<dyn std::any::Any> = Rc::new(VmFunctionWrapper {

ndc_macros/src/function.rs

@@ -512,13 +512,13 @@ fn try_generate_vm_native(
                     parameters: Some(vec![#(#param_types.clone()),*]),
                     return_type: Box::new(#return_static_type),
                 },
-                func: Box::new(|args| match args {
+                func: Box::new(|args, _globals| match args {
                     [#(#raw_args),*] => {
                         #(#extracts)*
                         let result = #inner_ident(#(#passes),*);
                         #return_code
                     }
-                    _ => Err(format!("expected {} arguments, got {}", #n, args.len())),
+                    _ => Err(ndc_vm::error::VmError::native(format!("expected {} arguments, got {}", #n, args.len()))),
                 }),
             });
     };
@@ -806,6 +806,43 @@ fn create_temp_variable(
             }];
         }
 
+        // &VmCallable — only used in VmNative functions (HOF path).
+        // Dead-code stub for the interpreter wrapper: extract function from InterpValue,
+        // convert to VmValue, then construct a VmCallable with empty globals.
+        // This code path is unreachable at runtime since VmNative bodies bypass the wrapper.
+        if path_ends_with(ty, "VmCallable") {
+            let tmp_ident = syn::Ident::new(
+                &format!("tmp_{argument_var_name}"),
+                argument_var_name.span(),
+            );
+            return vec![Argument {
+                param_type: quote! {
+                    ndc_interpreter::function::StaticType::Function {
+                        parameters: None,
+                        return_type: Box::new(ndc_interpreter::function::StaticType::Any),
+                    }
+                },
+                param_name: quote! { #original_name },
+                argument: quote! { #argument_var_name },
+                initialize_code: quote! {
+                    // Dead-code stub: VmCallable params only appear in functions with
+                    // FunctionBody::VmNative, so this interpreter wrapper is never called.
+                    let #tmp_ident =
+                        ndc_interpreter::vm_bridge::interp_to_vm(#argument_var_name.clone());
+                    let #argument_var_name = if let ndc_vm::value::Value::Object(obj) = &#tmp_ident {
+                        if let ndc_vm::value::Object::Function(f) = obj.as_ref() {
+                            ndc_vm::vm::VmCallable { function: f.clone(), globals: &[] }
+                        } else {
+                            panic!("VmCallable stub: expected Function variant");
+                        }
+                    } else {
+                        panic!("VmCallable stub: expected function object");
+                    };
+                    let #argument_var_name = &#argument_var_name;
+                },
+            }];
+        }
+
         // The pattern is Callable
         if path_ends_with(ty, "Callable") {
             let temp_var = syn::Ident::new(&format!("temp_{argument_var_name}"), identifier.span());