Stack traces with line numbers

Errors now show the source position of every call site in the trace:

    Error: inner exploded with x=42
      at inner (6:12)
      at middle (10:12)
      at outer (13:1)

Previously: just function names. The (line:col) suffix reveals which
specific call dispatched into each frame — what most languages give
you and what was the next debugging bottleneck after stack traces
themselves landed in Phase 3.

Architecture: position info is attached only to Expression::Call (one
new field, `pos: Pos`). Other expressions inherit their frame's call
site for error context — same coverage every mainstream interpreter
provides at this level. Pos moved from parser.rs to ast.rs and
re-exported, so AST nodes can carry positions without depending on
parser internals.

Tree-walk path: invoke_user_function gained an _at variant that takes
the call site; call_function_at threads pos from Expression::Call
through dispatch. The frame stack is now Vec<(String, Pos)>.

VM path: CompiledFunction carries a parallel Vec<Pos> of op_positions
(same length as ops, padded with Pos::unknown). Op layout is
unchanged — keeps the optimizer / inline-cache / disasm machinery
intact. The compiler's emit_at(op, pos) records the position on
emission. Op::Call dispatch consults op_positions[ip-1] and stashes
it on the Vm via a `next_call_site` side-channel; run_function reads
it on entry, immediately resets so child frames don't inherit.

Synthesized calls (heal-pass safe_divide rewrites, parser-generated
arr_new in the `[N]name` shorthand, the special-cased res()/fold()
keyword forms) carry Pos::unknown() and render with no suffix —
keeps trace lines clean when the call wasn't user-written.

42/42 functional examples produce identical output under tree-walk
and VM. 92/92 unit tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-core/src/ast.rs

@@ -1,5 +1,32 @@
 // src/ast.rs - Abstract syntax tree definitions
 
+/// Source position. 1-indexed for human-friendly error reports.
+/// Lives in ast.rs (rather than parser.rs) so AST nodes can carry
+/// positions without depending on parser internals.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Pos {
+    pub line: u32,
+    pub col: u32,
+}
+
+impl Pos {
+    /// Sentinel for synthesized AST nodes that don't trace back to
+    /// a real source location (e.g. nodes created by the heal pass).
+    pub fn unknown() -> Self {
+        Pos { line: 0, col: 0 }
+    }
+}
+
+impl std::fmt::Display for Pos {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.line == 0 {
+            write!(f, "<unknown>")
+        } else {
+            write!(f, "{}:{}", self.line, self.col)
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum Statement {
     Print(Expression),
@@ -170,10 +197,13 @@ pub enum Expression {
     Shl(Box<Expression>, Box<Expression>),
     Shr(Box<Expression>, Box<Expression>),
 
-    // Function call
+    // Function call. `pos` is the source position of the callee
+    // identifier — used for stack-trace line numbers. Synthesized
+    // calls (e.g. from the heal pass) use Pos::unknown().
     Call {
         name: String,
         args: Vec<Expression>,
+        pos: Pos,
     },
 
     // Harmonic operations

omnimcode-core/src/bytecode.rs

@@ -199,6 +199,15 @@ pub struct CompiledFunction {
     /// borrow (typical for monomorphic ICs). Cell<u8> is Copy + Clone so
     /// the surrounding struct stays cleanly cloneable.
     pub call_cache: Vec<std::cell::Cell<u8>>,
+    /// Source position of each op (for stack-trace line numbers).
+    /// Same length as `ops`; entries default to Pos::unknown() for
+    /// ops that don't trace back to user source (e.g. compiler-
+    /// synthesized arr_new initializers, fall-through nulls). The
+    /// VM consults this when pushing a call frame so VM-thrown
+    /// errors get the same "(line:col)" suffix the tree-walk side
+    /// produces. Cell<()> would suffice but Pos is Copy so a plain
+    /// Vec works.
+    pub op_positions: Vec<crate::ast::Pos>,
 }
 
 /// A compiled module / program.
@@ -226,6 +235,7 @@ impl Default for Module {
                 ops: Vec::new(),
                 constants: Vec::new(),
                 call_cache: Vec::new(),
+                op_positions: Vec::new(),
             },
             functions: std::collections::HashMap::new(),
             lambda_asts: Vec::new(),

omnimcode-core/src/compiler.rs

@@ -48,6 +48,10 @@ pub struct Compiler {
     /// existing call_first_class_function dispatches by name through
     /// the interpreter (tree-walk), not through module.functions.
     pending_lambda_asts: Vec<(String, Vec<String>, Vec<Statement>)>,
+    /// Source position attached to each emitted op, indexed by op
+    /// position. Built up alongside `ops`; finish() resizes to match
+    /// the final op count, padding any missing tail with Pos::unknown().
+    op_positions: Vec<crate::ast::Pos>,
 }
 
 impl Compiler {
@@ -61,6 +65,7 @@ impl Compiler {
             fn_return_types: std::collections::HashMap::new(),
             pending_lambdas: Vec::new(),
             pending_lambda_asts: Vec::new(),
+            op_positions: Vec::new(),
         }
     }
 
@@ -74,6 +79,7 @@ impl Compiler {
             fn_return_types: std::collections::HashMap::new(),
             pending_lambdas: Vec::new(),
             pending_lambda_asts: Vec::new(),
+            op_positions: Vec::new(),
         }
     }
 
@@ -210,8 +216,17 @@ impl Compiler {
     }
 
     fn emit(&mut self, op: Op) -> usize {
+        self.emit_at(op, crate::ast::Pos::unknown())
+    }
+
+    /// Emit an op with an attached source position. Used by Op::Call
+    /// emission so VM-thrown errors can point back at the call site
+    /// in the original source.
+    fn emit_at(&mut self, op: Op, pos: crate::ast::Pos) -> usize {
         let idx = self.ops.len();
         self.ops.push(op);
+        // Keep op_positions in lockstep so the VM can index either.
+        self.op_positions.push(pos);
         idx
     }
 
@@ -396,7 +411,11 @@ impl Compiler {
                 self.compile_expr(e)?;
                 self.emit(Op::Fold1);
             }
-            Expression::Call { name, args } => {
+            Expression::Call { name, args, pos } => {
+                // Capture the call-site position for the bytecode emit
+                // so VM-thrown errors can show the same "(line:col)" the
+                // tree-walk side does. Stored on Op::Call directly.
+                let _site_pos = *pos;
                 // Mutating built-ins must be specialized so the VM doesn't
                 // route them through vm_call_builtin's synthetic-arg shim
                 // (which would otherwise lose the mutation — the shim
@@ -512,7 +531,9 @@ impl Compiler {
                 for arg in args {
                     self.compile_expr(arg)?;
                 }
-                self.emit(Op::Call(name.clone(), args.len()));
+                // emit_at attaches the call-site pos so VM-thrown
+                // errors surface a line number in stack traces.
+                self.emit_at(Op::Call(name.clone(), args.len()), _site_pos);
             }
             Expression::Safe(inner) => {
                 // H.5 host-level: lower `safe <expr>` to the matching
@@ -533,13 +554,13 @@ impl Compiler {
                         self.compile_expr(r)?;
                         self.emit(Op::Call("safe_divide".to_string(), 2));
                     }
-                    Expression::Call { name, args } if name == "arr_get" && args.len() == 2 => {
+                    Expression::Call { name, args, .. } if name == "arr_get" && args.len() == 2 => {
                         for arg in args {
                             self.compile_expr(arg)?;
                         }
                         self.emit(Op::Call("safe_arr_get".to_string(), 2));
                     }
-                    Expression::Call { name, args } if name == "arr_set" && args.len() == 3 => {
+                    Expression::Call { name, args, .. } if name == "arr_set" && args.len() == 3 => {
                         // H.5.2: bare-VAR first arg → emit SafeArrSetNamed
                         // so the mutation propagates back through VM scope.
                         // Non-VAR shapes (e.g. nested array) fall through
@@ -910,6 +931,14 @@ impl Compiler {
             // Pre-size the inline call cache to match the op count. All slots
             // start uncached (0); the VM fills them in on first execution.
             call_cache: (0..n).map(|_| std::cell::Cell::new(0u8)).collect(),
+            // Pad op_positions to match. Compiler appends the correct
+            // pos at every emit site that knows it (Op::Call); other
+            // ops get Pos::unknown() and never appear in traces.
+            op_positions: {
+                let mut v = self.op_positions;
+                v.resize(n, crate::ast::Pos::unknown());
+                v
+            },
         }
     }
 }

omnimcode-core/src/formatter.rs

@@ -302,7 +302,7 @@ fn format_expr(expr: &Expression, out: &mut String) {
         }
         Expression::Shl(l, r) => format_binop(l, "<<", r, out),
         Expression::Shr(l, r) => format_binop(l, ">>", r, out),
-        Expression::Call { name, args } => {
+        Expression::Call { name, args, .. } => {
             out.push_str(name);
             out.push('(');
             for (i, a) in args.iter().enumerate() {

omnimcode-core/src/interpreter.rs

@@ -35,12 +35,12 @@ pub struct Interpreter {
     /// reason as test_failures: a plain OMC global wouldn't propagate
     /// to nested assertion calls.
     test_current_name: std::cell::RefCell<String>,
-    /// Names of currently-executing user functions, innermost-last.
-    /// Pushed at the entry of invoke_user_function, popped on exit
-    /// (success OR failure). Used to render call traces on errors —
-    /// future work will also attach source line numbers via per-op
-    /// metadata in CompiledFunction.
-    call_stack: Vec<String>,
+    /// (Function name, call-site position) for currently-executing
+    /// user functions, innermost-last. The position is the line of
+    /// the SITE where this fn was called from — that's what the user
+    /// sees in stack traces. The fn's own internal line numbers don't
+    /// belong here; they'd need per-statement position tracking.
+    call_stack: Vec<(String, crate::ast::Pos)>,
 }
 
 impl Interpreter {
@@ -394,11 +394,12 @@ impl Interpreter {
                     return Expression::Call {
                         name: "safe_divide".to_string(),
                         args: vec![l, r],
+                        pos: crate::ast::Pos::unknown(),
                     };
                 }
                 Expression::Div(Box::new(l), Box::new(r))
             }
-            Expression::Call { name, args } => {
+            Expression::Call { name, args, pos } => {
                 // Typo check at call site. Prefer user-defined fns
                 // (arities.keys()) over builtins as tiebreaker — a typo
                 // is more likely meant for a user fn than a builtin.
@@ -436,7 +437,11 @@ impl Interpreter {
                         healed_args.truncate(expected);
                     }
                 }
-                Expression::Call { name: healed_name, args: healed_args }
+                // Preserve the original source position through the
+                // heal pass — we don't reposition synthesized call
+                // nodes, but we DO keep the original pos so traces
+                // still point at the user's code.
+                Expression::Call { name: healed_name, args: healed_args, pos }
             }
             // Recursive walk for the rest of the structural expressions.
             Expression::Add(l, r) => Expression::Add(
@@ -966,8 +971,8 @@ impl Interpreter {
                 let rv = self.eval_expr(r)?.to_int();
                 Ok(Value::HInt(HInt::new(lv.wrapping_shr((rv & 63) as u32))))
             }
-            Expression::Call { name, args } => {
-                self.call_function(name, args)
+            Expression::Call { name, args, pos } => {
+                self.call_function_at(name, args, *pos)
             }
             Expression::Resonance(e) => {
                 // Match the call_function("res", ...) path: return HFloat resonance score.
@@ -1009,10 +1014,10 @@ impl Interpreter {
                         let args = vec![(**l).clone(), (**r).clone()];
                         self.call_function("safe_divide", &args)
                     }
-                    Expression::Call { name, args } if name == "arr_get" && args.len() == 2 => {
+                    Expression::Call { name, args, .. } if name == "arr_get" && args.len() == 2 => {
                         self.call_function("safe_arr_get", args)
                     }
-                    Expression::Call { name, args } if name == "arr_set" && args.len() == 3 => {
+                    Expression::Call { name, args, .. } if name == "arr_set" && args.len() == 3 => {
                         self.call_function("safe_arr_set", args)
                     }
                     _ => self.eval_expr(inner),
@@ -1171,6 +1176,22 @@ impl Interpreter {
         result
     }
 
+    /// Position-tagged variant — the call site's source position
+    /// becomes the line attached to the new stack frame.
+    fn call_function_at(
+        &mut self,
+        name: &str,
+        args: &[Expression],
+        pos: crate::ast::Pos,
+    ) -> Result<Value, String> {
+        if let Some((params, body)) = self.functions.get(name).cloned() {
+            return self.invoke_user_function_at(name, &params, &body, args, pos);
+        }
+        // Module-qualified calls and builtins don't push frames, so
+        // pos doesn't matter — fall through to the unpositioned path.
+        self.call_function(name, args)
+    }
+
     fn call_function(&mut self, name: &str, args: &[Expression]) -> Result<Value, String> {
         // Aliased imports register functions as literal "module.fname"
         // keys in self.functions. Check that BEFORE the dot-split below,
@@ -3347,6 +3368,19 @@ impl Interpreter {
         params: &[String],
         body: &[Statement],
         args: &[Expression],
+    ) -> Result<Value, String> {
+        // Convenience for call sites we haven't position-tagged yet
+        // (HOFs, reflective dispatch, module imports).
+        self.invoke_user_function_at(name, params, body, args, crate::ast::Pos::unknown())
+    }
+
+    fn invoke_user_function_at(
+        &mut self,
+        name: &str,
+        params: &[String],
+        body: &[Statement],
+        args: &[Expression],
+        call_site: crate::ast::Pos,
     ) -> Result<Value, String> {
         let mut eval_args = Vec::new();
         for arg in args {
@@ -3370,7 +3404,7 @@ impl Interpreter {
         // Push a call-stack frame so error messages can show
         // who-called-whom. The frame is popped in BOTH the success
         // and error paths so the trace doesn't leak across calls.
-        self.call_stack.push(name.to_string());
+        self.call_stack.push((name.to_string(), call_site));
 
         let mut exec_err: Option<String> = None;
         for stmt in body {
@@ -3387,11 +3421,15 @@ impl Interpreter {
         self.locals.pop();
 
         if let Some(e) = exec_err {
-            // Append our own frame and rethrow. Each invoke_user_function
-            // up the stack does the same, so the final message lists
-            // every frame innermost-first. Mirrors VM run_function's
-            // error-path formatting.
-            return Err(format!("{}\n  at {}", e, display_frame_name(name)));
+            // Append our own frame + the call site and rethrow.
+            // Each invoke_user_function up the stack does the same,
+            // so the final message lists every frame innermost-first.
+            return Err(format!(
+                "{}\n  at {}{}",
+                e,
+                display_frame_name(name),
+                format_call_site(call_site),
+            ));
         }
 
         let result = self.return_value.take().unwrap_or(Value::Null);
@@ -3506,11 +3544,11 @@ impl Interpreter {
         self.return_value.take()
     }
 
-    /// Push a call-stack frame (function name only for now). The VM
-    /// calls this at the entry of run_function so error traces work
-    /// for VM-dispatched calls too, not just tree-walk.
-    pub fn push_call_frame(&mut self, name: &str) {
-        self.call_stack.push(name.to_string());
+    /// Push a call-stack frame. The VM calls this at the entry of
+    /// run_function so error traces work for VM-dispatched calls too.
+    /// Pass Pos::unknown() if the call site isn't tracked.
+    pub fn push_call_frame(&mut self, name: &str, call_site: crate::ast::Pos) {
+        self.call_stack.push((name.to_string(), call_site));
     }
 
     /// REPL-facing: evaluate a single expression in the current
@@ -3535,8 +3573,12 @@ impl Interpreter {
             return msg.to_string();
         }
         let mut out = msg.to_string();
-        for fname in self.call_stack.iter().rev() {
-            out.push_str(&format!("\n  at {}", display_frame_name(fname)));
+        for (fname, pos) in self.call_stack.iter().rev() {
+            out.push_str(&format!(
+                "\n  at {}{}",
+                display_frame_name(fname),
+                format_call_site(*pos),
+            ));
         }
         out
     }
@@ -3864,6 +3906,18 @@ pub fn display_frame_name(name: &str) -> &str {
     }
 }
 
+/// Render a call-site position as the `(line:col)` suffix shown
+/// after the frame name in stack traces. Returns the empty string
+/// for synthesized frames (Pos::unknown) so traces stay clean
+/// when the call wasn't position-tagged.
+pub fn format_call_site(p: crate::ast::Pos) -> String {
+    if p.line == 0 {
+        String::new()
+    } else {
+        format!(" ({})", p)
+    }
+}
+
 /// Test whether `pattern` accepts `value`. On success, appends any
 /// `Pattern::Bind(name)` matches into `bindings` (ordered) so the
 /// caller can install them in the arm's scope.