From b7c0f45ccfc0eb1b6ff5c73b3e5580f543ea916c Mon Sep 17 00:00:00 2001 From: Kevin Tang <73975146+vt128@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:12:25 +0800 Subject: [PATCH] [fix] preserve accepted pointer materialization (SLT-21) --- convert/bench_test.go | 361 +++++++++++++++++++++++++++++++++++++ convert/conv.go | 63 ++++++- convert/conversion_test.go | 99 ++++++++++ convert/extern_test.go | 45 ----- convert/map.go | 27 +-- convert/robustness_test.go | 301 +++++++++++++++++++++++++++++++ convert/slice.go | 7 +- 7 files changed, 831 insertions(+), 72 deletions(-) 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/conv.go b/convert/conv.go index c402b16..7a28fe9 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); 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/map.go b/convert/map.go index dcd0e5b..7f7fe81 100644 --- a/convert/map.go +++ b/convert/map.go @@ -173,32 +173,25 @@ func (g *GoMap) delete(key reflect.Value) (v starlark.Value, found bool, err err return ret, true, nil } +// Items returns key/value pairs, preserving values without a direct Starlark +// representation as opaque GoInterface values. func (g *GoMap) Items() []starlark.Tuple { tuples := make([]starlark.Tuple, 0, g.v.Len()) - var err error for _, k := range sortedMapKeys(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(k, g.tag) + tuple[1] = toValueOrOpaque(g.v.MapIndex(k), 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 +261,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 } diff --git a/convert/robustness_test.go b/convert/robustness_test.go index 1d5de22..9b5546b 100644 --- a/convert/robustness_test.go +++ b/convert/robustness_test.go @@ -1,11 +1,17 @@ package convert_test import ( + "context" "fmt" + "os" + "os/exec" + "reflect" + "runtime/debug" "sort" "strings" "sync" "testing" + "time" "github.com/1set/starlight" "github.com/1set/starlight/convert" @@ -22,6 +28,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 diff --git a/convert/slice.go b/convert/slice.go index d9cc396..9e4ec89 100644 --- a/convert/slice.go +++ b/convert/slice.go @@ -104,11 +104,12 @@ func (g *GoSlice) Clear() error { return nil } -// Index implements starlark.Indexable. +// Index implements starlark.Indexable. Elements without a direct Starlark +// representation are returned as opaque GoInterface values. func (g *GoSlice) Index(i int) starlark.Value { v, err := toValue(g.v.Index(i), g.tag) if err != nil { - panic(err) + return &GoInterface{v: g.v.Index(i), tag: g.tag} } return v } @@ -218,7 +219,7 @@ func (it *sliceIterator) Next(p *starlark.Value) bool { if it.i < it.g.v.Len() { v, err := toValue(it.g.v.Index(it.i), it.g.tag) if err != nil { - panic(err) + v = &GoInterface{v: it.g.v.Index(it.i), tag: it.g.tag} } *p = v it.i++