diff --git a/convert/bench_test.go b/convert/bench_test.go index a9af462..8e34ccd 100644 --- a/convert/bench_test.go +++ b/convert/bench_test.go @@ -82,6 +82,41 @@ func BenchmarkToValueMap50(b *testing.B) { } } +func BenchmarkGoMapClear50(b *testing.B) { + seed := benchMap(50) + m := make(map[string]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if err := g.Clear(); err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkGoMapPopitem50(b *testing.B) { + g := convert.NewGoMap(benchMap(50)) + pop, err := g.Attr("popitem") + if err != nil { + b.Fatal(err) + } + thread := &starlark.Thread{Name: "benchmark"} + b.ResetTimer() + for i := 0; i < b.N; i++ { + v, err := starlark.Call(thread, pop, nil, nil) + if err != nil { + b.Fatal(err) + } + pair := v.(starlark.Tuple) + if err := g.SetKey(pair[0], pair[1]); err != nil { + b.Fatal(err) + } + } +} + func BenchmarkFromDict50(b *testing.B) { d := starlark.NewDict(50) for i := 0; i < 50; i++ { @@ -94,3 +129,329 @@ func BenchmarkFromDict50(b *testing.B) { _ = convert.FromDict(d) } } + +func BenchmarkMakeDict50(b *testing.B) { + m := benchMap(50) + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, err := convert.MakeDict(m); err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkMapArgumentConversion50(b *testing.B) { + m, err := convert.ToValue(benchMap(50)) + if err != nil { + b.Fatal(err) + } + fn := convert.MakeStarFn("accept", func(values map[string]int64) {}) + thread := &starlark.Thread{} + args := starlark.Tuple{m} + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, err := starlark.Call(thread, fn, args, nil); err != nil { + b.Fatal(err) + } + } +} + +// Additional merge-gate benchmarks share identical source in both checkouts. +// Fixtures are acyclic, normally representable values; regressions exercise +// the public wrappers rather than a mirror of their implementation. +var foundationValue starlark.Value +var foundationValues []starlark.Value +var foundationItems []starlark.Tuple +var foundationText string + +func BenchmarkFoundationMapScale(b *testing.B) { + for _, n := range []int{1, 1000} { + b.Run(fmt.Sprint(n), func(b *testing.B) { + m := benchMap(n) + g := convert.NewGoMap(m) + b.Run("Keys", func(b *testing.B) { + for i := 0; i < b.N; i++ { + foundationValues = g.Keys() + } + }) + b.Run("Items", func(b *testing.B) { + for i := 0; i < b.N; i++ { + foundationItems = g.Items() + } + }) + b.Run("Iterate", func(b *testing.B) { + for i := 0; i < b.N; i++ { + it := g.Iterate() + var v starlark.Value + for it.Next(&v) { + foundationValue = v + } + it.Done() + } + }) + b.Run("String", func(b *testing.B) { + for i := 0; i < b.N; i++ { + foundationText = g.String() + } + }) + b.Run("MakeDict", func(b *testing.B) { + for i := 0; i < b.N; i++ { + v, e := convert.MakeDict(m) + if e != nil { + b.Fatal(e) + } + foundationValue = v + } + }) + }) + } +} +func BenchmarkFoundationMapIterate50(b *testing.B) { + g := convert.NewGoMap(benchMap(50)) + b.ResetTimer() + for i := 0; i < b.N; i++ { + it := g.Iterate() + var v starlark.Value + for it.Next(&v) { + foundationValue = v + } + it.Done() + } +} +func BenchmarkFoundationMapReadWrite(b *testing.B) { + g := convert.NewGoMap(benchMap(50)) + hit := starlark.String("key0001") + miss := starlark.String("missing") + value := starlark.MakeInt(42) + b.Run("GetHit", func(b *testing.B) { + for i := 0; i < b.N; i++ { + v, ok, e := g.Get(hit) + if e != nil || !ok { + b.Fatal(e) + } + foundationValue = v + } + }) + b.Run("GetMiss", func(b *testing.B) { + for i := 0; i < b.N; i++ { + _, ok, e := g.Get(miss) + if e != nil || ok { + b.Fatal(e) + } + } + }) + b.Run("Set", func(b *testing.B) { + for i := 0; i < b.N; i++ { + if e := g.SetKey(hit, value); e != nil { + b.Fatal(e) + } + } + }) +} +func BenchmarkFoundationMapPointerKeys50(b *testing.B) { + m := make(map[*int]int, 50) + for i := 0; i < 50; i++ { + p := new(int) + *p = i + m[p] = i + } + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + foundationValues = g.Keys() + } +} +func BenchmarkFoundationMapPointerValues50(b *testing.B) { + m := make(map[string]*int, 50) + for k, v := range benchMap(50) { + p := new(int) + *p = v + m[k] = p + } + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + foundationItems = g.Items() + } +} +func BenchmarkFoundationMapStringReferences50(b *testing.B) { + m := make(map[string]interface{}, 50) + for k, v := range benchMap(50) { + m[k] = []int{v, v + 1} + } + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + foundationText = g.String() + } +} +func BenchmarkFoundationSliceMaterialize(b *testing.B) { + values := make([]int, 50) + ptrs := make([]*int, 50) + ifaces := make([]*interface{}, 50) + for i := range values { + values[i] = i + ptrs[i] = &values[i] + v := interface{}(i) + ifaces[i] = &v + } + for _, fixture := range []struct { + name string + value interface{} + }{{"Int", values}, {"IntPointer", ptrs}, {"InterfacePointer", ifaces}} { + b.Run(fixture.name, func(b *testing.B) { + g := convert.NewGoSlice(fixture.value) + b.Run("Index", func(b *testing.B) { + for i := 0; i < b.N; i++ { + foundationValue = g.Index(i % 50) + } + }) + b.Run("Iterate50", func(b *testing.B) { + for i := 0; i < b.N; i++ { + it := g.Iterate() + var v starlark.Value + for it.Next(&v) { + foundationValue = v + } + it.Done() + } + }) + }) + } +} +func BenchmarkFoundationMapClear1000(b *testing.B) { + seed := benchMap(1000) + m := make(map[string]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if e := g.Clear(); e != nil { + b.Fatal(e) + } + } +} + +// Normal Clear costs for key kinds that can contain NaN use only reflexive +// inputs, so baseline and candidate operations remain comparable. Refill is +// included identically in both legs, as in BenchmarkGoMapClear50. +func BenchmarkFoundationMapClearFloat50(b *testing.B) { + seed := make(map[float64]int, 50) + for i := 0; i < 50; i++ { + seed[float64(i)] = i + } + m := make(map[float64]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if err := g.Clear(); err != nil { + b.Fatal(err) + } + } +} +func BenchmarkFoundationMapClearInterface50(b *testing.B) { + seed := make(map[interface{}]int, 50) + for k, v := range benchMap(50) { + seed[k] = v + } + m := make(map[interface{}]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if err := g.Clear(); err != nil { + b.Fatal(err) + } + } +} + +// Existing public function-call benchmark, copied unchanged from extern_test.go. +type foo struct { + name string +} + +func (f *foo) Name() string { + return f.name +} + +var resultFuncCall starlark.StringDict +var result string + +func BenchmarkFuncCall(b *testing.B) { + fn := func(s string) { + result = s + } + + globals := map[string]interface{}{ + "fn": fn, + "foo": &foo{name: "bob"}, + } + dict, err := convert.MakeStringDict(globals) + if err != nil { + b.Fatal(err) + } + code := []byte(`fn(foo.Name())`) + // precompile + _, p, err := starlark.SourceProgram("foo.star", code, dict.Has) + if err != nil { + b.Fatal(err) + } + + for n := 0; n < b.N; n++ { + dict, err := convert.MakeStringDict(globals) + if err != nil { + b.Fatal(err) + } + resultFuncCall, err = p.Init(new(starlark.Thread), dict) + if err != nil { + b.Fatal(err) + } + } +} + +// Auxiliary composite-key Clear costs are reported separately from the38. +func BenchmarkFoundationMapClearArray50(b *testing.B) { + seed := make(map[[2]float64]int, 50) + for i := 0; i < 50; i++ { + seed[[2]float64{float64(i), float64(i + 1)}] = i + } + m := make(map[[2]float64]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if err := g.Clear(); err != nil { + b.Fatal(err) + } + } +} +func BenchmarkFoundationMapClearStruct50(b *testing.B) { + type key struct { + F float64 + N int + } + seed := make(map[key]int, 50) + for i := 0; i < 50; i++ { + seed[key{float64(i), i}] = i + } + m := make(map[key]int, len(seed)) + g := convert.NewGoMap(m) + b.ResetTimer() + for i := 0; i < b.N; i++ { + for k, v := range seed { + m[k] = v + } + if err := g.Clear(); err != nil { + b.Fatal(err) + } + } +} diff --git a/convert/common.go b/convert/common.go index 7273f8f..50dfe57 100644 --- a/convert/common.go +++ b/convert/common.go @@ -110,6 +110,35 @@ func sortedMapKeys(m reflect.Value) []reflect.Value { return keys } +// sortedMapEntries snapshots key/value pairs together, then applies the same +// key ordering as sortedMapKeys. Values must not be re-read with MapIndex: +// non-reflexive keys (NaN, including NaN inside structs/arrays/interfaces) +// cannot retrieve even their own entries. Tied keys have unspecified relative +// order, but each entry retains its original paired value and multiplicity. +func sortedMapEntries(m reflect.Value) sortableMapEntries { + entries := make(sortableMapEntries, 0, m.Len()) + iter := m.MapRange() + for iter.Next() { + entries = append(entries, sortableMapEntry{ + key: decorateKey(iter.Key()), + value: iter.Value(), + }) + } + sort.Sort(entries) + return entries +} + +type sortableMapEntry struct { + key sortableKey + value reflect.Value +} + +type sortableMapEntries []sortableMapEntry + +func (s sortableMapEntries) Len() int { return len(s) } +func (s sortableMapEntries) Less(i, j int) bool { return sortableKeyLess(s[i].key, s[j].key) } +func (s sortableMapEntries) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + // sortableKeys implements sort.Interface with concrete methods (the // reflect-based swapping of sort.Slice* is measurably slower here). type sortableKeys []sortableKey @@ -418,8 +447,9 @@ func hasRefCycle(v reflect.Value, visited map[uintptr]bool, depth int) bool { } switch v.Kind() { case reflect.Map: - for _, k := range v.MapKeys() { - if hasRefCycle(k, visited, depth+1) || hasRefCycle(v.MapIndex(k), visited, depth+1) { + iter := v.MapRange() + for iter.Next() { + if hasRefCycle(iter.Key(), visited, depth+1) || hasRefCycle(iter.Value(), visited, depth+1) { return true } } diff --git a/convert/conv.go b/convert/conv.go index c402b16..4ce9dd9 100644 --- a/convert/conv.go +++ b/convert/conv.go @@ -37,6 +37,10 @@ func (e *PanicError) Error() string { // // Existing starlark.Value objects pass through unchanged, except typed-nil // pointers become None. +// +// Collection elements without a direct Starlark representation remain opaque +// GoInterface values when accessed through no-error indexing/iteration APIs. +// Cyclic pointer/interface unwrapping also stops at an opaque GoInterface. func ToValue(v interface{}) (starlark.Value, error) { if val, ok := v.(starlark.Value); ok { return passThroughOrNone(val), nil @@ -73,6 +77,18 @@ func hasMethods(val reflect.Value) bool { return false } +// toValueOrOpaque is for collection APIs that cannot return a conversion +// error. Static unsupported types are still rejected at construction; values +// of accepted types that have no direct representation (nil scalar pointers, +// for example) retain their original Go value in an opaque wrapper. +func toValueOrOpaque(val reflect.Value, tagName string) (v starlark.Value) { + v, err := toValue(val, tagName) + if err != nil { + v = &GoInterface{v: val, tag: tagName} + } + return +} + func toValue(val reflect.Value, tagName string) (result starlark.Value, err error) { defer func() { if r := recover(); r != nil { @@ -177,6 +193,9 @@ func toValue(val reflect.Value, tagName string) (result starlark.Value, err erro if val.IsNil() { return starlark.None, nil } + if val.Kind() == reflect.Ptr { + return toInterfacePointerValue(val, tagName), nil + } if uv, err := toValue(val.Elem(), tagName); err == nil { return uv, nil } @@ -196,6 +215,40 @@ func toValue(val reflect.Value, tagName string) (result starlark.Value, err erro return nil, fmt.Errorf("type %T is not a supported starlark type", val.Interface()) } +// toInterfacePointerValue unwraps a pointer to an empty interface. Only +// pointer/interface chains can recur while collection wrapping remains lazy; +// keep their cycle state off the ordinary scalar conversion path. +func toInterfacePointerValue(val reflect.Value, tagName string) starlark.Value { + var seen map[uintptr]bool + for { + inner := val.Elem() + if inner.IsNil() { + return starlark.None + } + dynamic := inner.Elem() + if dynamic.Kind() == reflect.Ptr && !dynamic.IsNil() && + dynamic.Elem().Kind() == reflect.Interface && !hasMethods(dynamic) { + p := val.Pointer() + if seen[p] { + return &GoInterface{v: val, tag: tagName} + } + if seen == nil { + seen = make(map[uintptr]bool) + } + seen[p] = true + val = dynamic + continue + } + // Ordinary values, methods and Starlark values retain the common + // dispatch's precedence. A failed conversion belongs to this innermost + // interface slot, exactly as for recursive interface unwrapping. + if v, err := toValue(dynamic, tagName); err == nil { + return v + } + return &GoInterface{v: inner, tag: tagName} + } +} + // elemTypeCacheCap bounds elemTypeCheckCache. checkCollectionElemTypes is // run on every collection wrap; real hosts convert a small, fixed set of // declared collection types, and the cap is the ceiling that keeps @@ -211,11 +264,11 @@ func checkCollectionElemTypesCached(t reflect.Type) error { return elemTypeCheckCache.loadOrStore(t, checkCollectionElemTypes(t, nil)) } -// checkCollectionElemTypes verifies that the key and element types of a map, -// or the element type of a slice or array, are convertible by toValue, -// recursing through nested collection and pointer types. Without this -// pre-check, a collection like map[string]chan int converted fine and blew -// up with a panic only later, when items() or iteration touched a value of +// checkCollectionElemTypes rejects unsupported static key/element types, +// recursing through nested collection and pointer types. Accepted pointer +// values that toValue cannot represent use toValueOrOpaque in no-error APIs. +// Without this pre-check, a map[string]chan int converted fine and panicked +// only later, when items() or iteration touched a value of // the unsupported type. Struct types are not descended into: their fields // are reached through GoStruct.Attr, which reports a regular error. The // visited set guards against recursive Go types (e.g. type M map[string]M); @@ -423,6 +476,10 @@ func fromList(l *starlark.List, visited map[uintptr]bool) []interface{} { // MakeDict makes a Dict from the given map. The acceptable keys and values are the same as ToValue. // For nil input, it returns an empty Dict. It panics if the input is not a map. +// Entries keep their original paired values, including non-reflexive NaN keys. +// Keys tied under the documented map ordering have unspecified relative order. +// Multiple Go NaN keys that would merge into one Starlark key return an error: +// the fixed interpreter considers all NaN keys equal, unlike Go maps. func MakeDict(v interface{}) (starlark.Value, error) { return makeDictTag(reflect.ValueOf(v), emptyStr) } @@ -443,15 +500,24 @@ func makeDictTag(val reflect.Value, tagName string) (starlark.Value, error) { // iterate over the map and convert each key and value, in // deterministic key order: Starlark dicts preserve insertion order, // so the random order of MapKeys would be script-visible - for _, k := range sortedMapKeys(val) { - vk, err := toValue(k, tagName) + for _, entry := range sortedMapEntries(val) { + vk, err := toValue(entry.key.orig, tagName) if err != nil { return nil, err } - vv, err := toValue(val.MapIndex(k), tagName) + vv, err := toValue(entry.value, tagName) if err != nil { return nil, err } + // Go permits multiple NaN keys, even with identical bits. The + // fixed Starlark runtime compares NaN keys equal, so reject this + // representation conflict instead of silently overwriting a value. + if f, ok := vk.(starlark.Float); ok && math.IsNaN(float64(f)) { + // Float.Hash cannot fail, so this lookup cannot return an error. + if _, found, _ := dict.Get(vk); found { + return nil, fmt.Errorf("distinct Go NaN keys collide in a Starlark dict") + } + } // SetKey fails for keys that are unhashable on the Starlark // side; dropping the entry silently is data loss if err := dict.SetKey(vk, vv); err != nil { @@ -988,14 +1054,14 @@ func convertMap(val reflect.Value, argT reflect.Type) (reflect.Value, error) { argElem := argT.Elem() newMap := reflect.MakeMapWithSize(argT, val.Len()) - for _, key := range val.MapKeys() { - newKey, err := convertElemValue(key, argKey) + iter := val.MapRange() + for iter.Next() { + newKey, err := convertElemValue(iter.Key(), argKey) if err != nil { return reflect.Value{}, fmt.Errorf("map key conversion failed: %v", err) } - valElem := val.MapIndex(key) - newElem, err := convertElemValue(valElem, argElem) + newElem, err := convertElemValue(iter.Value(), argElem) if err != nil { return reflect.Value{}, fmt.Errorf("map value conversion failed: %v", err) } diff --git a/convert/conversion_test.go b/convert/conversion_test.go index 4e83b47..90fc215 100644 --- a/convert/conversion_test.go +++ b/convert/conversion_test.go @@ -4,9 +4,11 @@ import ( "errors" "fmt" "math/big" + "reflect" "strings" "testing" "time" + "unsafe" "github.com/1set/starlight" "github.com/1set/starlight/convert" @@ -22,6 +24,103 @@ import ( // 3. Empty-interface unwrapping and the opaque-wrapper fallback // 4. Type mapping edges: time.Duration, Int ladder, *time.Time // 5. Typed-nil handling; kwargs; NewStruct misuse +// 6. Pointer materialization compatibility (direct errors and precedence) + +type materializationNumber int + +func (v materializationNumber) Label() string { return "number" } + +func TestPointerMaterializationCompatibility(t *testing.T) { + n := 7 + p := &n + named := materializationNumber(7) + namedPtr := &named + var nilNamed *materializationNumber + var nilStruct *struct{ N int } + var iface interface{} = n + var nilIface interface{} + var errIface error = wrappedError{msg: "method"} + fn := func(x int) int { return x + 1 } + list := starlark.NewList(nil) + for _, tc := range []struct { + name string + in interface{} + want interface{} + }{ + {"scalar-pointer", p, starlark.MakeInt(n)}, + {"named-value", named, (*convert.GoInterface)(nil)}, + {"named-pointer", namedPtr, (*convert.GoInterface)(nil)}, + {"named-deep-pointer", &namedPtr, (*convert.GoInterface)(nil)}, + {"named-nil-pointer", nilNamed, (*convert.GoInterface)(nil)}, + {"nil-struct-pointer", nilStruct, (*convert.GoInterface)(nil)}, + {"struct-pointer", &struct{ N int }{1}, (*convert.GoStruct)(nil)}, + {"interface-pointer", &iface, starlark.MakeInt(n)}, + {"nil-interface-pointer", &nilIface, starlark.None}, + {"method-interface-pointer", &errIface, (*convert.GoInterface)(nil)}, + {"function-pointer", &fn, (*starlark.Builtin)(nil)}, + {"starlark-pointer", list, list}, + {"starlark-deep-pointer", &list, (*convert.GoInterface)(nil)}, + } { + t.Run(tc.name, func(t *testing.T) { + v, err := convert.ToValue(tc.in) + if err != nil { + t.Fatal(err) + } + if reflect.TypeOf(v) != reflect.TypeOf(tc.want) { + t.Fatalf("%T converted to %T, want %T", tc.in, v, tc.want) + } + if want, ok := tc.want.(starlark.Value); ok && !reflect.ValueOf(want).IsZero() && reflect.TypeOf(want).Comparable() && v != want { + t.Fatalf("%T changed value: got %v, want %v", tc.in, v, want) + } + }) + } + // Do not turn unsupported direct pointers into new native mappings. + var nilInt *int + var nilFunc *func() + var nilInterface *interface{} + var recursive recursivePointer + recursive = &recursive + for _, in := range []interface{}{nilInt, &p, nilFunc, nilInterface, recursive} { + if _, err := convert.ToValue(in); err == nil { + t.Errorf("direct %T must retain its conversion error", in) + } + } + // Function elements remain callable; pointer-to-function collections + // keep their existing static rejection, whether nil or non-nil. + evalOK(t, `x = fs[0](6) +assert.Eq(x, 7) +assert.Eq(n.Label(), "number")`, map[string]interface{}{"fs": []func(int) int{fn}, "n": namedPtr, "assert": &assert{t: t}}) + for _, in := range []interface{}{[]*func(int) int{nil}, []*func(int) int{&fn}, map[*func(int) int]int{&fn: 1}} { + if _, err := convert.ToValue(in); err == nil { + t.Errorf("%T must retain static rejection", in) + } + } +} + +// Cover every unsupported reflect.Kind, including through pointer layers. +// The no-error fallback must not relax the static collection pre-check. +func TestMaterializationUnsupportedKindsStayRejected(t *testing.T) { + for _, in := range []interface{}{make(chan int), complex64(1), complex128(1), uintptr(0), unsafe.Pointer(nil)} { + rv := reflect.ValueOf(in) + ptr := reflect.New(rv.Type()) + ptr.Elem().Set(rv) + for _, value := range []reflect.Value{rv, ptr} { + if _, err := convert.ToValue(value.Interface()); err == nil { + t.Errorf("direct %s must error", value.Type()) + } + s := reflect.MakeSlice(reflect.SliceOf(value.Type()), 1, 1) + s.Index(0).Set(value) + if _, err := convert.ToValue(s.Interface()); err == nil { + t.Errorf("static %s must error", s.Type()) + } + m := reflect.MakeMap(reflect.MapOf(reflect.TypeOf(""), value.Type())) + m.SetMapIndex(reflect.ValueOf("p"), value) + if _, err := convert.ToValue(m.Interface()); err == nil { + t.Errorf("static %s must error", m.Type()) + } + } + } +} // Regression tests for checked conversions: the three conversion entry // points trusted reflect.ConvertibleTo blindly, which silently corrupted diff --git a/convert/extern_test.go b/convert/extern_test.go index 456b82e..7ff66d1 100644 --- a/convert/extern_test.go +++ b/convert/extern_test.go @@ -6,8 +6,6 @@ import ( "testing" "github.com/1set/starlight" - "github.com/1set/starlight/convert" - "go.starlark.net/starlark" ) type ID int @@ -306,49 +304,6 @@ type Named interface { Name() string } -type foo struct { - name string -} - -func (f *foo) Name() string { - return f.name -} - -var resultFuncCall starlark.StringDict -var result string - -func BenchmarkFuncCall(b *testing.B) { - fn := func(s string) { - result = s - } - - globals := map[string]interface{}{ - "fn": fn, - "foo": &foo{name: "bob"}, - } - dict, err := convert.MakeStringDict(globals) - if err != nil { - b.Fatal(err) - } - code := []byte(`fn(foo.Name())`) - // precompile - _, p, err := starlark.SourceProgram("foo.star", code, dict.Has) - if err != nil { - b.Fatal(err) - } - - for n := 0; n < b.N; n++ { - dict, err := convert.MakeStringDict(globals) - if err != nil { - b.Fatal(err) - } - resultFuncCall, err = p.Init(new(starlark.Thread), dict) - if err != nil { - b.Fatal(err) - } - } -} - func TestInterfaceAssignment(t *testing.T) { var output string fn := func(n Named) { diff --git a/convert/keys_test.go b/convert/keys_test.go index 44166eb..dcd341b 100644 --- a/convert/keys_test.go +++ b/convert/keys_test.go @@ -2,7 +2,9 @@ package convert_test import ( "fmt" + "math" "reflect" + "sort" "strings" "testing" @@ -21,6 +23,134 @@ import ( // 3. TryFromDict / TryFromSet error variants // 4. Deterministic key order (sortedMapKeys: type rank, then value) // 5. Pointer and pointer-bearing keys sort address-free +// 6. Non-reflexive keys retain their paired values during materialization +// 7. Non-reflexive map mutation errors preserve host maps + +func callMapPopitem(t *testing.T, g *convert.GoMap) (starlark.Value, error) { + t.Helper() + pop, err := g.Attr("popitem") + if err != nil { + t.Fatal(err) + } + return starlark.Call(&starlark.Thread{Name: t.Name()}, pop, nil, nil) +} + +func TestGoMapNonReflexiveMutationErrors(t *testing.T) { + n := math.NaN() + for _, tc := range []struct { + name string + key interface{} + }{ + {"float32", float32(n)}, + {"float64", n}, + {"complex64", complex(float32(n), float32(0))}, + {"complex128", complex(0, n)}, + {"struct", struct{ f float64 }{n}}, + {"array", [1]float64{n}}, + {"interface-field", struct{ K interface{} }{n}}, + {"nested-complex", [1]struct{ K interface{} }{{complex(n, 0)}}}, + } { + t.Run(tc.name, func(t *testing.T) { + // Go already guarantees map keys (including dynamic interface + // keys) are comparable. Equality must still detect NaN nested + // inside composites; it must not depend on newer reflect APIs. + m := map[interface{}]int{tc.key: 7, "ordinary": 11} + alias := m + g := convert.NewGoMap(m) + if err := g.Clear(); err == nil || !strings.Contains(err.Error(), "non-reflexive") { + t.Fatalf("Clear: want explicit non-reflexive error, got %v", err) + } + if len(alias) != 2 || alias["ordinary"] != 11 { + t.Fatalf("Clear partially mutated the host map: %v", alias) + } + var total int + for _, v := range alias { + total += v + } + if total != 18 { + t.Fatalf("Clear changed a paired value: total=%d", total) + } + + // A single entry forces popitem to select the non-reflexive key. + m = map[interface{}]int{tc.key: 7} + g = convert.NewGoMap(m) + v, err := callMapPopitem(t, g) + if err == nil || !strings.Contains(err.Error(), "cannot delete") || v != nil { + t.Fatalf("popitem: want explicit deletion error and no pair, got (%v, %v)", v, err) + } + if len(m) != 1 { + t.Fatalf("popitem changed the map: %v", m) + } + for _, v := range m { + if v != 7 { + t.Fatalf("popitem changed value to %d", v) + } + } + }) + } + // In a mixed float map NaN sorts first, so popitem must reject it + // without deleting the ordinary entry either. + m := map[float64]int{n: 7, 1: 11} + if _, err := callMapPopitem(t, convert.NewGoMap(m)); err == nil || len(m) != 2 || m[1] != 11 { + t.Fatalf("mixed popitem must preserve all entries: map=%v error=%v", m, err) + } + for _, code := range []string{`m.clear()`, `m.popitem()`} { + m := map[float64]int{n: 7} + evalErr(t, code, map[string]interface{}{"m": m}, "cannot") + if len(m) != 1 { + t.Fatalf("%s mutated the host map", code) + } + } +} + +func TestGoMapMutationGuardsAndAlias(t *testing.T) { + for _, state := range []string{"iteration", "frozen", "frozen-and-iteration"} { + t.Run(state, func(t *testing.T) { + m := map[float64]int{math.NaN(): 7} + g := convert.NewGoMap(m) + want := "during iteration" + if state != "frozen" { + it := g.Iterate() + defer it.Done() + } + if state != "iteration" { + g.Freeze() + want = "frozen map" + } + if err := g.Clear(); err == nil || !strings.Contains(err.Error(), want) { + t.Fatalf("Clear precedence: want %s, got %v", want, err) + } + if _, err := callMapPopitem(t, g); err == nil || !strings.Contains(err.Error(), want) { + t.Fatalf("popitem precedence: want %s, got %v", want, err) + } + if len(m) != 1 { + t.Fatal("guard failure mutated the map") + } + }) + } + // A pointer to NaN is itself reflexive. Ordinary and composite keys, + // nil interface keys and infinities also keep their normal behavior. + n := math.NaN() + m := map[interface{}]int{nil: 1, &n: 2, math.Inf(1): 3, struct{ N int }{4}: 4, [1]int{5}: 5, complex(1, 2): 6} + alias := m + g := convert.NewGoMap(m) + if err := g.Clear(); err != nil || len(alias) != 0 { + t.Fatalf("ordinary Clear: map=%v error=%v", alias, err) + } + m["host"] = 7 + if g.Len() != 1 || alias["host"] != 7 { + t.Fatal("Clear replaced the host map instead of preserving aliases") + } + if v, err := callMapPopitem(t, g); err != nil || len(alias) != 0 || v.(starlark.Tuple)[1] != starlark.MakeInt(7) { + t.Fatalf("ordinary popitem: value=%v error=%v map=%v", v, err, alias) + } + // Empty and nil maps continue to clear successfully. + for _, empty := range []map[string]int{nil, {}} { + if err := convert.NewGoMap(empty).Clear(); err != nil { + t.Fatal(err) + } + } +} // Regression tests for unhashable dict/set keys: a Starlark value whose Go // form is not comparable (e.g. dict, list, set, or a tuple converted to @@ -611,3 +741,122 @@ func TestStringBearingCompositeKeyDeterministic(t *testing.T) { } } } + +// TestGoMapNaNEntriesPreserveValues covers non-reflexive keys: looking a +// ranged NaN key up again cannot recover the value stored with that entry. +// Equal-bit NaN keys may coexist; their documented sorting tie leaves relative +// order unspecified, but values and entry multiplicity must be retained. +func TestGoMapNaNEntriesPreserveValues(t *testing.T) { + n := math.NaN() + scalar := map[float64]int{} + scalar[n], scalar[n] = 7, 11 + dynamic := map[interface{}]int{} + dynamic[n], dynamic[n] = 7, 11 + composite := map[struct{ F float64 }]int{} + composite[struct{ F float64 }{n}], composite[struct{ F float64 }{n}] = 7, 11 + array := map[[1]float64]int{} + array[[1]float64{n}], array[[1]float64{n}] = 7, 11 + for _, tc := range []struct { + name string + value interface{} + }{ + {"scalar", scalar}, {"interface", dynamic}, {"struct", composite}, {"array", array}, + } { + t.Run(tc.name, func(t *testing.T) { + converted, err := convert.ToValue(tc.value) + if err != nil { + t.Fatal(err) + } + for _, g := range []*convert.GoMap{convert.NewGoMap(tc.value), converted.(*convert.GoMap)} { + items := g.Items() + if len(items) != 2 { + t.Fatalf("got %d entries, want two equal-bit NaN entries", len(items)) + } + values := make([]int, 0, len(items)) + for _, item := range items { + value, ok := item[1].(starlark.Int) + if !ok { + t.Fatalf("entry value became %s, want an integer", item[1]) + } + n, _ := value.Int64() + values = append(values, int(n)) + } + sort.Ints(values) + if !reflect.DeepEqual(values, []int{7, 11}) { + t.Fatalf("entry values=%v, want [7 11]", values) + } + } + }) + } +} + +// TestMakeDictNaNEntriesPreserveValues checks eager materialization. A single +// NaN key keeps its paired value; multiple Go NaN entries must be rejected +// because the fixed interpreter compares their converted NaN keys equal. +func TestMakeDictNaNEntriesPreserveValues(t *testing.T) { + for _, tc := range []struct { + name string + second float64 + }{ + {"identical bits", math.NaN()}, + {"different bits", math.Float64frombits(0x7ff8000000000002)}, + } { + t.Run(tc.name, func(t *testing.T) { + n := math.NaN() + m := map[float64]int{n: 7} + value, err := convert.MakeDict(m) + if err != nil { + t.Fatal(err) + } + items := value.(*starlark.Dict).Items() + if len(items) != 1 || items[0][1] != starlark.MakeInt(7) { + t.Fatalf("single NaN entry lost its value: %v", items) + } + m[tc.second] = 11 + if value, err := convert.MakeDict(m); err == nil || !strings.Contains(err.Error(), "NaN keys collide") || value != nil { + t.Fatalf("want explicit NaN collision, got value=%v error=%v", value, err) + } + }) + } +} + +func TestGoMapNaNValuesScriptAndArgument(t *testing.T) { + n := math.NaN() + m := map[float64]int{} + m[n], m[n] = 7, 11 + called := false + globals := map[string]interface{}{ + "m": m, + "accept": func(values map[float64]int64) int64 { + called = true + if len(values) != 2 { + t.Errorf("typed argument has %d entries, want 2", len(values)) + } + var total int64 + for _, v := range values { + total += v + } + return total + }, + } + out, err := starlight.Eval([]byte("values=m.values()\nitems=m.items()\ntotal=accept(m)"), globals, nil) + if err != nil { + t.Fatal(err) + } + if !called || out["total"] != int64(18) { + t.Fatalf("typed conversion lost values: called=%v total=%v", called, out["total"]) + } + values := out["values"].([]interface{}) + got := make([]int, 0, len(values)) + for _, v := range values { + n, ok := v.(int64) + if !ok { + t.Fatalf("script value became %T(%v)", v, v) + } + got = append(got, int(n)) + } + sort.Ints(got) + if !reflect.DeepEqual(got, []int{7, 11}) { + t.Fatalf("script values=%v, want [7 11]", got) + } +} diff --git a/convert/map.go b/convert/map.go index dcd0e5b..1ae0c60 100644 --- a/convert/map.go +++ b/convert/map.go @@ -132,6 +132,10 @@ func (g *GoMap) Hash() (uint32, error) { return 0, errors.New("starlight_map is not hashable") } +// Clear deletes all entries in place, preserving aliases of the host map. +// If any key is non-reflexive (for example, it contains NaN), Clear returns +// an error without changing the map: such keys cannot be deleted by lookup +// on the supported Go 1.19 floor. func (g *GoMap) Clear() error { if g.frozen { return fmt.Errorf("cannot clear frozen map") @@ -139,7 +143,17 @@ func (g *GoMap) Clear() error { if atomic.LoadInt32(&g.numIt) > 0 { return fmt.Errorf("cannot clear map during iteration") } - for _, k := range g.v.MapKeys() { + keys := g.v.MapKeys() + for _, k := range keys { + // Every stored Go map key is comparable, including the dynamic + // value of an interface key. Equality detects NaN even in nested + // structs/arrays/interfaces/complex values, without newer APIs. + key := k.Interface() + if key != key { + return fmt.Errorf("cannot clear map with non-reflexive key") + } + } + for _, k := range keys { g.v.SetMapIndex(k, reflect.Value{}) } return nil @@ -173,32 +187,28 @@ func (g *GoMap) delete(key reflect.Value) (v starlark.Value, found bool, err err return ret, true, nil } +// Items returns a key-sorted snapshot, preserving values without a direct +// Starlark representation as opaque GoInterface values. Every key keeps its +// original paired value, including non-reflexive NaN keys; no entries are +// dropped. Keys tied under the documented ordering have unspecified relative +// order. func (g *GoMap) Items() []starlark.Tuple { tuples := make([]starlark.Tuple, 0, g.v.Len()) - var err error - for _, k := range sortedMapKeys(g.v) { + for _, entry := range sortedMapEntries(g.v) { tuple := make(starlark.Tuple, 2) - tuple[0], err = toValue(k, g.tag) - if err != nil { - panic(err) - } - tuple[1], err = toValue(g.v.MapIndex(k), g.tag) - if err != nil { - panic(err) - } + tuple[0] = toValueOrOpaque(entry.key.orig, g.tag) + tuple[1] = toValueOrOpaque(entry.value, g.tag) tuples = append(tuples, tuple) } return tuples } +// Keys returns keys in deterministic order, using opaque GoInterface values +// for keys without a direct Starlark representation. func (g *GoMap) Keys() []starlark.Value { keys := make([]starlark.Value, 0, g.v.Len()) for _, k := range sortedMapKeys(g.v) { - key, err := toValue(k, g.tag) - if err != nil { - panic(err) - } - keys = append(keys, key) + keys = append(keys, toValueOrOpaque(k, g.tag)) } return keys } @@ -268,11 +278,7 @@ type mapIterator struct { func (it *mapIterator) Next(p *starlark.Value) bool { if it.i < len(it.keys) { - v, err := toValue(it.keys[it.i], it.g.tag) - if err != nil { - panic(err) - } - *p = v + *p = toValueOrOpaque(it.keys[it.i], it.g.tag) it.i++ return true } @@ -349,7 +355,8 @@ func dict_pop(fnname string, g *GoMap, args starlark.Tuple, _ []starlark.Tuple) // Note: the spec's popitem removes the last-inserted item (LIFO), but a Go // map has no insertion order to honor. To stay deterministic this pops the // smallest key under the same ordering Keys()/Items() use (type rank, then -// value), not the last-inserted one. +// value), not the last-inserted one. A selected non-reflexive key (e.g. NaN) +// cannot be retrieved/deleted; popitem reports an error without changing it. func dict_popitem(fnname string, g *GoMap, args starlark.Tuple, _ []starlark.Tuple) (starlark.Value, error) { if len(args) > 0 { return nil, fmt.Errorf("%s: wanted 0 args, got %d", fnname, len(args)) @@ -368,10 +375,13 @@ func dict_popitem(fnname string, g *GoMap, args starlark.Tuple, _ []starlark.Tup return nil, fmt.Errorf("popitem: empty dict") } k := keys[0] - v, _, err := g.delete(k) + v, found, err := g.delete(k) if err != nil { return nil, err } + if !found { + return nil, fmt.Errorf("popitem: cannot delete selected map key") + } key, err := toValue(k, g.tag) if err != nil { return nil, err diff --git a/convert/robustness_test.go b/convert/robustness_test.go index 1d5de22..857f74e 100644 --- a/convert/robustness_test.go +++ b/convert/robustness_test.go @@ -1,11 +1,18 @@ package convert_test import ( + "context" "fmt" + "math" + "os" + "os/exec" + "reflect" + "runtime/debug" "sort" "strings" "sync" "testing" + "time" "github.com/1set/starlight" "github.com/1set/starlight/convert" @@ -22,6 +29,301 @@ import ( // 3. Bridge contracts (kwargs, error convention, MakeDict key, pointer // methods, dir()) // 4. Freeze semantics, conversion concurrency, and reference cycles +// 5. Accepted pointer elements: opaque materialization and interface cycles + +// Accepted pointer elements may have no direct Starlark representation. The +// no-error collection APIs must preserve them as opaque values, rather than +// panic or broaden the direct ToValue conversion contract. +func TestCollectionPointerMaterialization(t *testing.T) { + n := 7 + p := &n + var nilInt *int + for _, tc := range []struct { + name string + value interface{} + slice interface{} + m interface{} + keys interface{} + }{ + {"nil", nilInt, []*int{nil}, map[string]*int{"p": nil}, map[*int]string{nil: "p"}}, + {"deep", &p, []**int{&p}, map[string]**int{"p": &p}, map[**int]string{&p: "p"}}, + } { + t.Run(tc.name, func(t *testing.T) { + check := func(v starlark.Value) { + t.Helper() + g, ok := v.(*convert.GoInterface) + if !ok || g.Value().Interface() != tc.value { + t.Fatalf("got %T, want opaque original %T", v, tc.value) + } + _ = g.String() + g.Freeze() + if _, err := g.Hash(); err == nil { + t.Fatal("opaque pointer must remain unhashable") + } + } + for _, direct := range []bool{false, true} { + var s *convert.GoSlice + var m, keys *convert.GoMap + if direct { + s = convert.NewGoSlice(tc.slice) + m = convert.NewGoMap(tc.m) + keys = convert.NewGoMap(tc.keys) + } else { + sv, err := convert.ToValue(tc.slice) + if err != nil { + t.Fatal(err) + } + mv, err := convert.ToValue(tc.m) + if err != nil { + t.Fatal(err) + } + kv, err := convert.ToValue(tc.keys) + if err != nil { + t.Fatal(err) + } + s, m, keys = sv.(*convert.GoSlice), mv.(*convert.GoMap), kv.(*convert.GoMap) + } + check(s.Index(0)) + check(m.Items()[0][1]) + check(keys.Items()[0][0]) + check(keys.Keys()[0]) + for _, it := range []starlark.Iterator{s.Iterate(), keys.Iterate()} { + var v starlark.Value + if !it.Next(&v) { + t.Fatal("missing pointer element") + } + check(v) + if it.Next(&v) { + t.Fatal("extra pointer element") + } + it.Done() + } + // Error-returning APIs retain their regular conversion errors. + if _, _, err := m.Get(starlark.String("p")); err == nil { + t.Fatal("Get must preserve the direct conversion error") + } + } + evalOK(t, `a = l[0] +b = [v for v in l] +c = m.items() +d = m.values() +e = k.keys() +f = [v for v in k]`, map[string]interface{}{"l": tc.slice, "m": tc.m, "k": tc.keys}) + }) + } +} + +type recursivePointer *recursivePointer + +// Probe cyclic conversion in a bounded subprocess before repeating the same +// public fixture in the parent for coverage. A failed child stops the parent +// before it reaches the dangerous path. +func TestCollectionPointerCycles(t *testing.T) { + if os.Getenv("STARLIGHT_POINTER_CYCLE_CHILD") != "1" { + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestCollectionPointerCycles$", "-test.v") + cmd.Env = append(os.Environ(), "STARLIGHT_POINTER_CYCLE_CHILD=1") + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("bounded pointer-cycle process: %v (%v)\n%s", err, ctx.Err(), out) + } + } else { + // Only the isolated probe changes the process-wide stack limit. + debug.SetMaxStack(256 << 10) + } + var self interface{} + self = &self + var left, right interface{} + left, right = &right, &left + var recursive recursivePointer + recursive = &recursive + var entry, middle, tail interface{} + entry, middle, tail = &middle, &tail, &middle + // Preserve the exact repeated-node identity, including a non-cyclic + // prefix before a two-node loop. These assertions run only after the + // bounded child fixture above has returned successfully. + for _, tc := range []struct{ input, repeated interface{} }{ + {&self, &self}, {&left, &left}, {&entry, &middle}, + } { + v, err := convert.ToValue(tc.input) + if err != nil { + t.Fatal(err) + } + g, ok := v.(*convert.GoInterface) + if !ok || g.Value().Interface() != tc.repeated || convert.FromValue(g) != tc.repeated { + t.Fatalf("cycle identity: got %T, want repeated node %p", v, tc.repeated) + } + } + for _, p := range []interface{}{&self, &left, &entry, recursive} { + // Recursive pointer types remain unsupported directly; mixed + // pointer/interface cycles use the existing interface fallback. + if _, err := convert.ToValue(p); err != nil && reflect.TypeOf(p) != reflect.TypeOf(recursive) { + t.Fatal(err) + } + for _, input := range []interface{}{[]interface{}{p}, map[string]interface{}{"p": p}} { + v, err := convert.ToValue(input) + if err != nil { + t.Fatal(err) + } + var got starlark.Value + switch v := v.(type) { + case *convert.GoSlice: + got = v.Index(0) + it := v.Iterate() + if !it.Next(&got) { + t.Fatal("missing cyclic pointer") + } + it.Done() + case *convert.GoMap: + got = v.Items()[0][1] + } + if _, ok := got.(*convert.GoInterface); !ok { + t.Fatalf("cyclic %T: got %T, want opaque value", p, got) + } + _ = got.String() + } + } + // These types are statically accepted too, without an interface slot + // around the pointer element. + for _, input := range []interface{}{[]*interface{}{&self}, []recursivePointer{recursive}, map[string]*interface{}{"p": &left}, map[string]recursivePointer{"p": recursive}} { + v, err := convert.ToValue(input) + if err != nil { + t.Fatal(err) + } + switch v := v.(type) { + case *convert.GoSlice: + _ = v.Index(0) + case *convert.GoMap: + _ = v.Items() + } + } +} + +// Acyclic pointer-to-interface values retain their ordinary conversion, +// including scalars, nil, and pointers. Both direct and no-error collection +// APIs must produce the same values. +func TestCollectionPointerInterfaceValues(t *testing.T) { + n := 7 + var empty interface{} + scalar := interface{}(n) + pointer := interface{}(&n) + var nilInt *int + nilPointer := interface{}(nilInt) + for _, tc := range []struct { + name string + input *interface{} + want starlark.Value + }{ + {"scalar", &scalar, starlark.MakeInt(7)}, + {"pointer", &pointer, starlark.MakeInt(7)}, + {"nil-interface", &empty, starlark.None}, + } { + t.Run(tc.name, func(t *testing.T) { + v, err := convert.ToValue(tc.input) + if err != nil || v != tc.want { + t.Fatalf("direct: value=%v err=%v", v, err) + } + if got := convert.NewGoSlice([]*interface{}{tc.input}).Index(0); got != tc.want { + t.Fatalf("Index: value=%v", got) + } + m := convert.NewGoMap(map[string]*interface{}{"value": tc.input}) + if got := m.Items()[0][1]; got != tc.want { + t.Fatalf("Items: value=%v", got) + } + }) + } + // An unsupported nil scalar pointer behind an interface remains opaque, + // just as before the cycle detector was introduced. + v, err := convert.ToValue(&nilPointer) + if err != nil { + t.Fatal(err) + } + if _, ok := v.(*convert.GoInterface); !ok { + t.Fatalf("nil scalar: got %T", v) + } + // A failed dynamic conversion preserves the innermost interface slot, + // rather than the entry pointer, and FromValue keeps its host value. + ch := make(chan int) + unsupported := interface{}(ch) + middle := interface{}(&unsupported) + entry := interface{}(&middle) + v, err = convert.ToValue(&entry) + if err != nil { + t.Fatal(err) + } + g, ok := v.(*convert.GoInterface) + if !ok || g.Value().Kind() != reflect.Interface || !g.Value().CanAddr() || + g.Value().Addr().Interface() != &unsupported || convert.FromValue(g) != ch { + t.Fatalf("unsupported dynamic identity: got %T", v) + } + // Index and Iterator preserve fallback identity and element order, + // including consecutive failures and a successful element between them. + other := 8 + first, second := &n, &other + for _, tc := range []struct { + input interface{} + want []interface{} + }{ + {[]*int{nil, &n, nil}, []interface{}{nilInt, starlark.MakeInt(7), nilInt}}, + {[]**int{&first, &second, nil}, []interface{}{&first, &second, (**int)(nil)}}, + {[]interface{}{ch, 7, ch}, []interface{}{ch, starlark.MakeInt(7), ch}}, + } { + slice := convert.NewGoSlice(tc.input) + check := func(index int, got starlark.Value) { + t.Helper() + if want, ok := tc.want[index].(starlark.Value); ok { + if got != want { + t.Fatalf("element %d: got %v, want %v", index, got, want) + } + } else if g, ok := got.(*convert.GoInterface); !ok || convert.FromValue(g) != tc.want[index] { + t.Fatalf("element %d: lost opaque identity (%T)", index, got) + } + } + for i := range tc.want { + check(i, slice.Index(i)) + } + it := slice.Iterate() + for i := range tc.want { + var got starlark.Value + if !it.Next(&got) { + t.Fatalf("missing element %d", i) + } + check(i, got) + } + var extra starlark.Value + if it.Next(&extra) { + t.Fatal("extra iterator element") + } + it.Done() + } + // Method-bearing interface pointers stop at the usual GoInterface; + // Starlark values and typed-nil Starlark pointers retain precedence. + var method error = wrappedError{msg: "method"} + methodBox := interface{}(&method) + methodEntry := interface{}(&methodBox) + v, err = convert.ToValue(&methodEntry) + if err != nil { + t.Fatal(err) + } + if g, ok := v.(*convert.GoInterface); !ok || g.Value().Interface() != &method { + t.Fatalf("method interface precedence: got %T", v) + } + list := starlark.NewList(nil) + var nilList *starlark.List + for _, tc := range []struct { + input interface{} + want starlark.Value + }{ + {list, list}, {nilList, starlark.None}, + } { + box := tc.input + outer := interface{}(&box) + got, err := convert.ToValue(&outer) + if err != nil || got != tc.want { + t.Fatalf("Starlark precedence: value=%v err=%v", got, err) + } + } +} // Regression tests for the four script-reachable panics: // 1. strided slicing (l[::2]) passed the element type to MakeSlice and @@ -797,3 +1099,31 @@ func TestDeepNestingNoStackOverflow(t *testing.T) { t.Fatalf("expected to walk %d levels, got %d", depth, n) } } + +// TestGoMapNaNKeyCycleString keeps the fatal-stack regression isolated. A +// self-reference stored behind a NaN key must be found without re-looking up +// that non-reflexive key. A small child stack and an external watchdog bound +// failures without risking the parent test process. +func TestGoMapNaNKeyCycleString(t *testing.T) { + const childEnv = "STARLIGHT_TEST_NAN_KEY_CYCLE" + if os.Getenv(childEnv) != "1" { + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestGoMapNaNKeyCycleString$", "-test.v") + cmd.Env = append(os.Environ(), childEnv+"=1") + if output, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("NaN-key cycle subprocess failed (deadline: %v): %v\n%s", ctx.Err(), err, output) + } + return + } + debug.SetMaxStack(256 * 1024) + m := map[float64]interface{}{} + m[math.NaN()] = m + value, err := convert.ToValue(m) + if err != nil { + t.Fatal(err) + } + if got := value.String(); !strings.HasPrefix(got, "