revert: remove RadValue span tracking (perf fix)

The Span *Span field added to RadValue in 1a04b3c caused a
15-19% regression on loop-heavy benchmarks. Each newRadValue()
call heap-allocated a 64-byte Span, and the struct grew from
16 to 24 bytes - 50% more data copied by value everywhere.

The span tracking was infrastructure for future "assigned
here" error context, but it's never read in production code.
Errors at the usage site with actual types are sufficient -
Python/Ruby/JS don't track assignment locations either.

Removes Span field, HasSpan/GetSpan/WithSpan methods,
spanFromNode helper, and associated tests.

Author: amterp

core/testing/diagnostic_test.go

@@ -225,30 +225,3 @@ func TestNewDiagnosticFromCheckNilCode(t *testing.T) {
 	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,11 +20,6 @@ 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 {
@@ -56,22 +51,6 @@ 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:
@@ -474,67 +453,48 @@ 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, Span: span}
+		return RadValue{Val: coerced}
 	case string:
-		return RadValue{Val: NewRadString(coerced), Span: span}
+		return RadValue{Val: NewRadString(coerced)}
 	case int:
-		return RadValue{Val: int64(coerced), Span: span}
+		return RadValue{Val: int64(coerced)}
 	case int64, float64, bool:
-		return RadValue{Val: coerced, Span: span}
+		return RadValue{Val: coerced}
 	case *RadList:
-		return RadValue{Val: coerced, Span: span}
+		return RadValue{Val: coerced}
 	case RadList:
-		return RadValue{Val: &coerced, Span: span}
+		return RadValue{Val: &coerced}
 	case *RadMap:
-		return RadValue{Val: coerced, Span: span}
+		return RadValue{Val: coerced}
 	case RadMap:
-		return RadValue{Val: &coerced, Span: span}
+		return RadValue{Val: &coerced}
 	case RadFn:
-		return RadValue{Val: coerced, Span: span}
+		return RadValue{Val: coerced}
 	case *RadError:
-		return RadValue{Val: coerced, Span: span}
+		return RadValue{Val: coerced}
 	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, Span: span}
+		return RadValue{Val: radMap}
 	case []interface{}:
 		list := NewRadListFromGeneric(i, node, coerced)
-		return RadValue{Val: list, Span: span}
+		return RadValue{Val: list}
 	case []string:
 		list := NewRadListFromGeneric(i, node, coerced)
-		return RadValue{Val: list, Span: span}
+		return RadValue{Val: list}
 	case RadNull, nil:
-		return RadValue{Val: RAD_NULL, Span: span}
+		return RadValue{Val: RAD_NULL}
 	default:
 		if i != nil && node != nil {
 			i.emitErrorf(rl.ErrTypeMismatch, node, "Unsupported value type: %s", TypeAsString(coerced))