feat: add source span tracking to RadValue

Values now track their origin location in source code, enabling
"assigned here" context in error messages:

- Added Span *Span field to RadValue struct
- Modified newRadValue() to create and attach spans from tree-sitter
  nodes when available
- Added spanFromNode() helper that extracts location from nodes
- Added HasSpan(), GetSpan(), WithSpan() helper methods

Span is nil for intermediate computations (e.g., a + b results) to
avoid unnecessary memory overhead. Only values from direct source
expressions (literals, assignments, function parameters) track spans.

When a RadValue already has a span and passes through newRadValue(),
the existing span is preserved to maintain the original definition
location.

Author: amterp

core/testing/diagnostic_test.go

@@ -224,3 +224,31 @@ func TestNewDiagnosticFromCheckNilCode(t *testing.T) {
 	coreDiag := core.NewDiagnosticFromCheck(checkDiag, "test.rad")
 	assert.Equal(t, rl.ErrGenericRuntime, coreDiag.Code)
 }
+
+// Tests for RadValue span tracking
+
+func TestRadValueHasSpan(t *testing.T) {
+	// Value without span
+	val := core.RadValue{Val: int64(42)}
+	assert.False(t, val.HasSpan())
+	assert.Nil(t, val.GetSpan())
+
+	// Value with span
+	span := &core.Span{File: "test.rad", StartRow: 5}
+	valWithSpan := val.WithSpan(span)
+	assert.True(t, valWithSpan.HasSpan())
+	assert.Equal(t, "test.rad", valWithSpan.GetSpan().File)
+	assert.Equal(t, 5, valWithSpan.GetSpan().StartRow)
+}
+
+func TestRadValueWithSpan(t *testing.T) {
+	span := &core.Span{File: "test.rad", StartRow: 10, StartCol: 5}
+	val := core.RadValue{Val: "hello"}
+
+	// WithSpan returns a copy with the span
+	result := val.WithSpan(span)
+	assert.Equal(t, span, result.Span)
+
+	// Original is also modified (value semantics - copy)
+	// This is expected behavior for Go structs
+}

core/type_rad_value.go

@@ -20,6 +20,11 @@ type RadValue struct {
 	// nulls are RadNull
 	// errors are *RadError
 	Val interface{}
+
+	// Span tracks where this value originated in source code.
+	// Used for "assigned here" context in error messages.
+	// nil for intermediate computations (e.g., a + b).
+	Span *Span
 }
 
 func (v RadValue) Type() rl.RadType {
@@ -51,6 +56,22 @@ func (v RadValue) IsNull() bool {
 	return v.Val == RAD_NULL
 }
 
+// HasSpan returns true if this value has source location information.
+func (v RadValue) HasSpan() bool {
+	return v.Span != nil
+}
+
+// GetSpan returns the source location span, or nil if not available.
+func (v RadValue) GetSpan() *Span {
+	return v.Span
+}
+
+// WithSpan returns a copy of this value with the given span attached.
+func (v RadValue) WithSpan(span *Span) RadValue {
+	v.Span = span
+	return v
+}
+
 func (v RadValue) Index(i *Interpreter, idxNode *ts.Node) RadValue {
 	switch coerced := v.Val.(type) {
 	case RadString:
@@ -453,48 +474,67 @@ func (v RadValue) ToCompatSubject(i *Interpreter) (out rl.TypingCompatVal) {
 	return
 }
 
+// spanFromNode creates a Span from a tree-sitter node for value tracking.
+// Returns nil if the node is nil (intermediate computations don't have spans).
+func spanFromNode(i *Interpreter, node *ts.Node) *Span {
+	if node == nil {
+		return nil
+	}
+	file := ""
+	if i != nil {
+		file = i.sd.ScriptName
+	}
+	span := NewSpanFromNode(node, file)
+	return &span
+}
+
 func newRadValue(i *Interpreter, node *ts.Node, value interface{}) RadValue {
+	span := spanFromNode(i, node)
 	switch coerced := value.(type) {
 	case RadValue:
+		// Preserve existing span if the value already has one
+		if coerced.Span == nil {
+			coerced.Span = span
+		}
 		return coerced
 	case []RadValue: // todo risky to have this? might cover up issues
 		list := NewRadList()
 		list.Values = coerced
 		return newRadValue(i, node, list)
 	case RadString:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case string:
-		return RadValue{Val: NewRadString(coerced)}
+		return RadValue{Val: NewRadString(coerced), Span: span}
 	case int:
-		return RadValue{Val: int64(coerced)}
+		return RadValue{Val: int64(coerced), Span: span}
 	case int64, float64, bool:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case *RadList:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case RadList:
-		return RadValue{Val: &coerced}
+		return RadValue{Val: &coerced, Span: span}
 	case *RadMap:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case RadMap:
-		return RadValue{Val: &coerced}
+		return RadValue{Val: &coerced, Span: span}
 	case RadFn:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case *RadError:
-		return RadValue{Val: coerced}
+		return RadValue{Val: coerced, Span: span}
 	case map[string]interface{}:
 		radMap := NewRadMap()
 		for key, val := range coerced {
 			radMap.Set(newRadValue(i, node, key), newRadValue(i, node, val))
 		}
-		return RadValue{Val: radMap}
+		return RadValue{Val: radMap, Span: span}
 	case []interface{}:
 		list := NewRadListFromGeneric(i, node, coerced)
-		return RadValue{Val: list}
+		return RadValue{Val: list, Span: span}
 	case []string:
 		list := NewRadListFromGeneric(i, node, coerced)
-		return RadValue{Val: list}
+		return RadValue{Val: list, Span: span}
 	case RadNull, nil:
-		return RadValue{Val: RAD_NULL}
+		return RadValue{Val: RAD_NULL, Span: span}
 	default:
 		if i != nil && node != nil {
 			i.errorf(node, "Unsupported value type: %s", TypeAsString(coerced))