feat: add call stack tracking and stack traces

Rad function calls now track a call stack separate from
Go's, enabling user-facing stack traces in error messages.
Each CallFrame records:
- Function name (or "<anonymous>" for lambdas)
- Call site span (where the function was called)
- Definition site span (where the function is defined)

The stack is pushed on entry and popped on exit. When a
runtime error occurs inside nested functions, users see
the full Rad call chain:

  = stack:
    at inner (script.rad:6:5)
    in outer (script.rad:8:1)

Also refactors internal panic handling to produce friendlier
"This is a bug in Rad" messages with a GitHub issue link,
rather than exposing raw Go stack traces.

Author: amterp

core/diagnostic.go

@@ -91,12 +91,13 @@ func NewSecondaryLabel(span Span, message string) Label {
 
 // Diagnostic represents a single diagnostic message with optional multi-span context.
 type Diagnostic struct {
-	Severity Severity
-	Code     rl.Error  // From rts/rl/errors.go
-	Message  string    // One-line summary
-	Labels   []Label   // Primary + secondary spans
-	Hints    []string  // "= help: ..." lines
-	Source   string    // Complete source for rendering
+	Severity  Severity
+	Code      rl.Error    // From rts/rl/errors.go
+	Message   string      // One-line summary
+	Labels    []Label     // Primary + secondary spans
+	Hints     []string    // "= help: ..." lines
+	Source    string      // Complete source for rendering
+	CallStack []CallFrame // Rad call stack at time of error (most recent first)
 }
 
 // NewDiagnostic creates a diagnostic with a single primary label.
@@ -139,6 +140,12 @@ func (d Diagnostic) WithSecondaryLabel(span Span, message string) Diagnostic {
 	return d
 }
 
+// WithCallStack attaches a call stack to the diagnostic and returns the modified diagnostic.
+func (d Diagnostic) WithCallStack(stack []CallFrame) Diagnostic {
+	d.CallStack = stack
+	return d
+}
+
 // PrimarySpan returns the first primary span, or nil if none exists.
 func (d Diagnostic) PrimarySpan() *Span {
 	for _, label := range d.Labels {

core/diagnostic_render.go

@@ -27,6 +27,7 @@ func NewDiagnosticRenderer(w io.Writer) *DiagnosticRenderer {
 func (r *DiagnosticRenderer) Render(d Diagnostic) {
 	r.renderHeader(d)
 	r.renderLabels(d)
+	r.renderCallStack(d)
 	r.renderHints(d)
 	r.renderInfoLine(d)
 	fmt.Fprintln(r.writer)
@@ -292,6 +293,37 @@ func (r *DiagnosticRenderer) renderInfoLine(d Diagnostic) {
 	}
 }
 
+// renderCallStack renders the call stack if present.
+func (r *DiagnosticRenderer) renderCallStack(d Diagnostic) {
+	if len(d.CallStack) == 0 {
+		return
+	}
+
+	fmt.Fprintf(r.writer, "   %s\n", r.cyan("= stack:"))
+	for i, frame := range d.CallStack {
+		indent := "     "
+		prefix := "in"
+		if i == 0 {
+			prefix = "at"
+		}
+
+		// Format location
+		location := ""
+		if frame.CallSite != nil {
+			location = fmt.Sprintf("%s:%d:%d",
+				frame.CallSite.File,
+				frame.CallSite.StartLine(),
+				frame.CallSite.StartColumn())
+		}
+
+		if location != "" {
+			fmt.Fprintf(r.writer, "%s%s %s (%s)\n", indent, prefix, r.blue(frame.FunctionName), location)
+		} else {
+			fmt.Fprintf(r.writer, "%s%s %s\n", indent, prefix, r.blue(frame.FunctionName))
+		}
+	}
+}
+
 // Color helper methods
 func (r *DiagnosticRenderer) red(s string) string {
 	if !r.useColor {

core/interpreter.go

@@ -66,6 +66,14 @@ type InterpreterInput struct {
 	InvokedCommand *ScriptCommand
 }
 
+// CallFrame represents a function call in the Rad call stack.
+// Used for providing stack traces in error messages.
+type CallFrame struct {
+	FunctionName string   // Name of the function (or "<anonymous>" for lambdas)
+	CallSite     *Span    // Where the function was called from
+	DefSite      *Span    // Where the function is defined
+}
+
 type Interpreter struct {
 	sd             *ScriptData
 	invokedCommand *ScriptCommand
@@ -76,6 +84,9 @@ type Interpreter struct {
 	forWhileLoopLevel int
 	// Used to track current delimiter, currently for correct delimiter escaping handling
 	delimiterStack *com.Stack[Delimiter]
+
+	// Call stack for Rad function calls (not Go stack)
+	callStack []CallFrame
 }
 
 func NewInterpreter(input InterpreterInput) *Interpreter {
@@ -933,6 +944,10 @@ func (i *Interpreter) getOnlyChild(node *ts.Node) *ts.Node {
 // emitDiagnostic renders a diagnostic and exits with error code 1.
 // This is the new error reporting method that replaces errorf/errorDetailsf.
 func (i *Interpreter) emitDiagnostic(d Diagnostic) {
+	// Automatically attach call stack if not already present
+	if len(d.CallStack) == 0 && len(i.callStack) > 0 {
+		d = d.WithCallStack(i.CallStack())
+	}
 	renderer := NewDiagnosticRenderer(RIo.StdErr)
 	renderer.Render(d)
 	RExit.Exit(1)
@@ -970,6 +985,32 @@ func (i *Interpreter) emitErrorWithSecondary(code rl.Error, primaryNode *ts.Node
 	i.emitDiagnostic(diag)
 }
 
+// pushCallFrame pushes a new frame onto the call stack.
+func (i *Interpreter) pushCallFrame(name string, callSite, defSite *Span) {
+	i.callStack = append(i.callStack, CallFrame{
+		FunctionName: name,
+		CallSite:     callSite,
+		DefSite:      defSite,
+	})
+}
+
+// popCallFrame removes the top frame from the call stack.
+func (i *Interpreter) popCallFrame() {
+	if len(i.callStack) > 0 {
+		i.callStack = i.callStack[:len(i.callStack)-1]
+	}
+}
+
+// CallStack returns a copy of the current call stack (most recent first).
+func (i *Interpreter) CallStack() []CallFrame {
+	result := make([]CallFrame, len(i.callStack))
+	// Reverse so most recent is first
+	for idx, frame := range i.callStack {
+		result[len(i.callStack)-1-idx] = frame
+	}
+	return result
+}
+
 // emitUndefinedVariableError emits an error for an undefined variable with
 // "did you mean?" suggestions for similar variable names.
 func (i *Interpreter) emitUndefinedVariableError(node *ts.Node, name string) {
@@ -1296,6 +1337,11 @@ func (i *Interpreter) GetSrc() string {
 	return i.sd.Src
 }
 
+// GetScriptName returns the name/path of the current script.
+func (i *Interpreter) GetScriptName() string {
+	return i.sd.ScriptName
+}
+
 func (i *Interpreter) GetSrcForNode(node *ts.Node) string {
 	return i.GetSrc()[node.StartByte():node.EndByte()]
 }
@@ -1343,35 +1389,56 @@ func (i *Interpreter) getAssignLeftNodes(node *ts.Node) []ts.Node {
 // fallbackNode is used for error reporting when the panic is not a RadPanic.
 // msgArgs are optional context values to include in the error message before the panic value.
 func (i *Interpreter) handlePanicRecovery(r interface{}, fallbackNode *ts.Node, msgArgs ...interface{}) {
-	if r != nil {
-		radPanic, ok := r.(*RadPanic)
-		if ok {
-			err := radPanic.Err()
-			msg := err.Msg().Plain()
-			code := rl.ErrGenericRuntime
-			if !com.IsBlank(string(err.Code)) {
-				code = err.Code
-			}
-			// Use err.Node if available, otherwise fall back to fallbackNode
-			node := err.Node
-			if node == nil {
-				node = fallbackNode
-			}
-			i.emitError(code, node, msg)
+	if r == nil {
+		return
+	}
+
+	// RadPanic is expected - it's how Rad propagates user-facing errors
+	if radPanic, ok := r.(*RadPanic); ok {
+		err := radPanic.Err()
+		msg := err.Msg().Plain()
+		code := rl.ErrGenericRuntime
+		if !com.IsBlank(string(err.Code)) {
+			code = err.Code
 		}
-		if !IsTest {
-			// Build error message with panic details
-			var msgBuilder strings.Builder
-			msgBuilder.WriteString("Bug: Panic:")
-			for _, arg := range msgArgs {
-				msgBuilder.WriteString(fmt.Sprintf(" %v", arg))
-			}
-			msgBuilder.WriteString(fmt.Sprintf(" %v\n%s", r, debug.Stack()))
-			i.emitError(rl.ErrInternalBug, fallbackNode, msgBuilder.String())
+		// Use err.Node if available, otherwise fall back to fallbackNode
+		node := err.Node
+		if node == nil {
+			node = fallbackNode
 		}
+		i.emitError(code, node, msg)
+		return
+	}
+
+	// Non-RadPanic means an internal bug - this shouldn't happen
+	// Skip in tests since test framework may use panics for control flow (e.g., exit simulation)
+	if !IsTest {
+		i.emitInternalBug(r, fallbackNode, msgArgs...)
 	}
 }
 
+// emitInternalBug reports an internal Rad bug to the user.
+// This should only be called for unexpected panics that are NOT RadPanic.
+func (i *Interpreter) emitInternalBug(panicValue interface{}, fallbackNode *ts.Node, msgArgs ...interface{}) {
+	var msgBuilder strings.Builder
+	msgBuilder.WriteString("This is a bug in Rad. Please report it at:\n")
+	msgBuilder.WriteString("  https://github.com/amterp/rad/issues\n\n")
+
+	msgBuilder.WriteString("Panic: ")
+	for _, arg := range msgArgs {
+		msgBuilder.WriteString(fmt.Sprintf("%v ", arg))
+	}
+	msgBuilder.WriteString(fmt.Sprintf("%v\n\n", panicValue))
+
+	if !IsTest {
+		// Include Go stack trace for debugging (skip in tests for deterministic output)
+		msgBuilder.WriteString("Go stack trace:\n")
+		msgBuilder.WriteString(string(debug.Stack()))
+	}
+
+	i.emitError(rl.ErrInternalBug, fallbackNode, msgBuilder.String())
+}
+
 // withCatch wraps body execution with panic catching. If catchNode is nil, just executes body.
 // On RadPanic, calls onErr callback to handle the error (assign variables, run catch block, etc.).
 // Propagates control flow (return/break/continue/yield) from the catch block.

core/testing/misc_test.go

@@ -412,3 +412,31 @@ print(completely_different_name)
 		t.Errorf("Expected no suggestion for very different variable name")
 	}
 }
+
+func Test_Misc_StackTraceShownInNestedFunctionError(t *testing.T) {
+	script := `
+fn inner():
+    x = undefined_var
+
+fn outer():
+    inner()
+
+outer()
+`
+	setupAndRunCode(t, script, "--color=never")
+	// Get the error output before it gets reset
+	output := stdErrBuffer.String()
+	t.Logf("Full error output:\n%s", output)
+	// Verify basic error
+	if !strings.Contains(output, "RAD20028") {
+		t.Errorf("Expected RAD20028 in output")
+	}
+	if !strings.Contains(output, "undefined_var") {
+		t.Errorf("Expected 'undefined_var' in output")
+	}
+	// Stack trace should show nested function calls
+	if !strings.Contains(output, "= stack:") {
+		t.Errorf("Expected '= stack:' in error output for nested function error")
+	}
+	assertExitCode(t, 1)
+}

core/type_fn.go

@@ -209,6 +209,23 @@ func (fn RadFn) Execute(f FuncInvocation) (out RadValue) {
 
 		// todo this should be more shared between the two branches?
 		if fn.BuiltInFunc == nil {
+			// Push call frame for user-defined functions
+			var callSite, defSite *Span
+			if f.callNode != nil {
+				cs := NewSpanFromNode(f.callNode, i.GetScriptName())
+				callSite = &cs
+			}
+			if fn.ReprNode != nil {
+				ds := NewSpanFromNode(fn.ReprNode, i.GetScriptName())
+				defSite = &ds
+			}
+			fnName := fn.Name()
+			if fnName == "" {
+				fnName = "<anonymous>"
+			}
+			i.pushCallFrame(fnName, callSite, defSite)
+			defer i.popCallFrame()
+
 			res := i.runBlock(fn.Stmts)
 			typeCheck(i, typing.ReturnT, f.callNode, res.Val)
 			if fn.IsBlock {