goscript 0.1.4 → 0.2.0

package/compiler/semantic-model_test.go

@@ -242,6 +242,87 @@ func TestSemanticModelRecordsInterfaceAssertionAndNilFacts(t *testing.T) {
 	}
 }
 
+func TestSemanticModelRejectsInterfaceMethodSignatureMismatch(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/signaturemismatch\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package signaturemismatch",
+			"type Reader interface { Read() int }",
+			"type Impl struct{}",
+			"func (Impl) Read() string { return \"bad\" }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if hasInterfaceImplementation(model, "Impl", "Reader", false) {
+		t.Fatalf("unexpected Impl -> Reader implementation: %#v", model.interfaceImplementations)
+	}
+}
+
+func TestSemanticModelAcceptsPromotedInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/promoted\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package promoted",
+			"type Reader interface { Read() int }",
+			"type Base struct{}",
+			"func (Base) Read() int { return 1 }",
+			"type Impl struct { Base }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if !hasInterfaceImplementation(model, "Impl", "Reader", false) {
+		t.Fatalf("missing promoted Impl -> Reader implementation: %#v", model.interfaceImplementations)
+	}
+}
+
+func TestSemanticModelKeepsUnexportedInterfaceMethodsPackageScoped(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unexportediface\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type private interface { read() int }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package unexportediface",
+			"import _ \"example.test/unexportediface/dep\"",
+			"type Impl struct{}",
+			"func (Impl) read() int { return 1 }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	if hasInterfaceImplementation(model, "Impl", "private", false) {
+		t.Fatalf("unexpected cross-package unexported implementation: %#v", model.interfaceImplementations)
+	}
+}
+
 func TestSemanticModelColorsAsyncFunctionsAndOverrides(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/async\n\ngo 1.25.3\n",
@@ -356,7 +437,7 @@ func TestSemanticModelPropagatesAsyncToOverrideInterfaceMethods(t *testing.T) {
 		if implementation.typ != nil && implementation.typ.Obj().Name() == "asyncWriter" &&
 			implementation.iface != nil && implementation.iface.Obj().Pkg().Path() == "io" &&
 			implementation.iface.Obj().Name() == "Writer" &&
-			implementation.pointer && implementation.asyncMethods["Write"] {
+			implementation.pointer {
 			found = true
 			break
 		}

package/compiler/service.go

@@ -14,6 +14,7 @@ type CompileService struct {
 	emitterOwner  *TypeScriptEmitOwner
 	runtimeOwner  *RuntimeContractOwner
 	overrideOwner *OverrideRegistryOwner
+	parityOwner   *OverrideParityVerifier
 }
 
 // NewCompileService creates a compile service with every pipeline owner.
@@ -28,6 +29,7 @@ func NewCompileService(overrideDirs ...string) *CompileService {
 		emitterOwner:  NewTypeScriptEmitOwner(runtimeOwner),
 		runtimeOwner:  runtimeOwner,
 		overrideOwner: overrideOwner,
+		parityOwner:   NewOverrideParityVerifier(),
 	}
 }
 
@@ -96,6 +98,19 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
+	overrideFacts, factsDiagnostics := s.overrideOwner.Facts(ctx)
+	diagnostics = append(diagnostics, factsDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		result.Diagnostics = diagnostics
+		return result, NewCompileError(diagnostics)
+	}
+	parityDiagnostics := s.parityOwner.Verify(ctx, graph, overrideFacts)
+	diagnostics = append(diagnostics, parityDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		result.Diagnostics = diagnostics
+		return result, NewCompileError(diagnostics)
+	}
+
 	semanticModel, semanticDiagnostics := s.semanticOwner.Build(ctx, graph)
 	diagnostics = append(diagnostics, semanticDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
@@ -110,7 +125,11 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
-	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel)
+	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel, LoweringOptions{
+		SourceRoot:                protobufTypeScriptBindingRoot(req.Dir),
+		OutputPath:                req.OutputPath,
+		ProtobufTypeScriptBinding: req.ProtobufTypeScriptBinding,
+	})
 	diagnostics = append(diagnostics, loweringDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		result.Diagnostics = diagnostics

package/compiler/skeleton_test.go

@@ -911,6 +911,49 @@ func TestCompilePackagesAnnotatesNewPointerShortDecls(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAnnotatesNewArrayPointerShortDecls(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/newarrayptrdecl\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func use(*[32]byte) {}",
+			"func main() {",
+			"  buf := new([32]byte)",
+			"  use(buf)",
+			"  if true {",
+			"    buf = nil",
+			"  }",
+			"  use(buf)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "newarrayptrdecl", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"let buf: $.VarRef<Uint8Array> | null = $.varRef<Uint8Array>(new Uint8Array(32))",
+		"buf = null",
+		"use(buf)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesEmitsShadowedBuiltinCalls(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/shadowbuiltin\n\ngo 1.25.3\n",
@@ -1516,8 +1559,8 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 		"Counter.prototype.Set.call(pointer, 2)",
 		"Counter.prototype.Set.call(NewCounter(), 5)",
 		"let [, ok] = $.typeAssertTuple<Counter | $.VarRef<Counter> | null>(iface, { kind: $.TypeKind.Pointer, elemType: \"main.Counter\" })",
-		"\"Value\": { type: { kind: $.TypeKind.Basic, name: \"int\" }, tag: \"json:\\\"value\\\"\" }",
-		"\"ID\": { kind: $.TypeKind.Basic, name: \"int32\", typeName: \"main.ObjectID\" }",
+		"{ name: \"Value\", key: \"Value\", type: { kind: $.TypeKind.Basic, name: \"int\" }, tag: \"json:\\\"value\\\"\", index: [0], offset: 0, exported: true }",
+		"{ name: \"ID\", key: \"ID\", type: { kind: $.TypeKind.Basic, name: \"int32\", typeName: \"main.ObjectID\" }, index: [1], offset: 8, exported: true }",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -2346,9 +2389,11 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
 		"((__receiver) => () => __receiver.Inc())($.pointerValue<Counter>(counter))",
-		"$.namedFunction(greet, \"main.Greeter\")",
+		"$.namedFunction(greet, \"main.Greeter\", ({ kind: $.TypeKind.Function, name: \"main.Greeter\"",
+		"params: [{ kind: $.TypeKind.Basic, name: \"string\" }]",
+		"results: [{ kind: $.TypeKind.Basic, name: \"string\" }]",
 		"$.interfaceValue<any>(null, \"*struct{Name string}\")",
-		"elemType: { kind: $.TypeKind.Struct, methods: [], fields: {\"Name\": { kind: $.TypeKind.Basic, name: \"string\" }} }",
+		"elemType: { kind: $.TypeKind.Struct, methods: [], fields: [{ name: \"Name\", key: \"Name\", type: { kind: $.TypeKind.Basic, name: \"string\" }",
 		"let fn = __goscriptTuple",
 		"switch (true)",
 		"case $.typeAssert<Exclude<ReadCloser, null>>(__goscriptTypeSwitchValue, \"main.ReadCloser\").ok",
@@ -2612,9 +2657,9 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 		"$.mapSet(seen, 1, {})",
 		"$.genericZero(__typeArgs, \"T\", null)",
 		"$.callGenericMethod(__typeArgs, \"T\", \"String\", v)",
-		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }})",
-		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, zero)",
-		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, null)",
+		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)}, methodSignatures: [{ name: \"String\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }] }})",
+		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)}, methodSignatures: [{ name: \"String\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }] }}, zero)",
+		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)}, methodSignatures: [{ name: \"String\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }] }}, null)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -2761,7 +2806,7 @@ func TestCompilePackagesEmitsRecursiveFunctionTypeInfo(t *testing.T) {
 	text := string(content)
 	for _, want := range []string{
 		"export type Handler = ((_p0: ((_p0: Handler | null) => Handler | null | globalThis.Promise<Handler | null>) | null) => Handler | null | globalThis.Promise<Handler | null>) | null",
-		"\"Next\": ({ kind: $.TypeKind.Function, name: \"main.Handler\"",
+		"{ name: \"Next\", key: \"Next\", type: ({ kind: $.TypeKind.Function, name: \"main.Handler\"",
 		"params: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
 		"results: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
 	} {
@@ -4127,6 +4172,12 @@ func TestCompilePackagesLowersSwitchesAndFunctionValueCalls(t *testing.T) {
 			"  if value > 0 {",
 			"    goto Again",
 			"  }",
+			"Drive:",
+			"  window := value + 1",
+			"  if window < 0 {",
+			"    goto Drive",
+			"  }",
+			"  println(window)",
 			"  release := func() { println(\"release\") }",
 			"  rel := &release",
 			"  (*rel)()",
@@ -4163,6 +4214,9 @@ func TestCompilePackagesLowersSwitchesAndFunctionValueCalls(t *testing.T) {
 		"break Block",
 		"Again: while (true)",
 		"continue Again",
+		"Drive: while (true)",
+		"var window = value + 1",
+		"$.println(window)",
 		"($.pointerValue<(() => void) | null>(rel))!()",
 		"$.functionValue((): void => {\n\t\tusing __defer = new $.DisposableStack()",
 		"__defer.defer(() => { $.println(\"wrapped deferred\") })",

package/compiler/typescript-emitter.go

@@ -134,6 +134,7 @@ func (o *TypeScriptEmitOwner) EmitToMemory(
 
 func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *loweredFile) string {
 	var b strings.Builder
+	b.Grow(estimateLoweredFileSize(file))
 	if file.sourcePath != "" {
 		b.WriteString("// Generated file based on ")
 		b.WriteString(filepath.Base(file.sourcePath))
@@ -219,6 +220,104 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 	return b.String()
 }
 
+func estimateLoweredFileSize(file *loweredFile) int {
+	if file == nil {
+		return 0
+	}
+	size := 128 + len(file.imports)*96 + len(file.decls)*32
+	for _, imp := range file.imports {
+		size += len(imp.alias) + len(imp.source)
+	}
+	for _, decl := range file.decls {
+		size += len(decl.code)
+		if decl.function != nil {
+			size += estimateLoweredFunctionSize(decl.function)
+		}
+		if decl.structType != nil {
+			size += estimateLoweredStructSize(decl.structType)
+		}
+	}
+	return size
+}
+
+func estimateLoweredStructSize(structType *loweredStruct) int {
+	if structType == nil {
+		return 0
+	}
+	size := 256 + len(structType.name) + len(structType.typeName) + len(structType.fields)*128
+	for _, field := range structType.fields {
+		size += len(field.name) + len(field.runtimeName) + len(field.typ) + len(field.zero) + len(field.runtimeType) +
+			len(field.doc) + len(field.tag)
+	}
+	for idx := range structType.methods {
+		size += estimateLoweredFunctionSize(&structType.methods[idx])
+	}
+	return size
+}
+
+func estimateLoweredFunctionSize(fn *loweredFunction) int {
+	if fn == nil {
+		return 0
+	}
+	size := 192 + len(fn.name) + len(fn.result) + len(fn.receiverAlias) + len(fn.receiverType) + len(fn.receiverValue)
+	for _, typeParam := range fn.typeParams {
+		size += len(typeParam) + 2
+	}
+	for _, param := range fn.params {
+		size += len(param.name) + len(param.typ) + 4
+	}
+	for _, result := range fn.namedResults {
+		size += len(result.name) + len(result.typ) + len(result.zero) + len(result.returnExpr) + 16
+	}
+	size += estimateLoweredStmtsSize(fn.paramBindings)
+	size += estimateLoweredStmtsSize(fn.body)
+	return size
+}
+
+func estimateLoweredStmtsSize(stmts []loweredStmt) int {
+	size := len(stmts) * 24
+	for _, stmt := range stmts {
+		size += len(stmt.text) + len(stmt.leading)*16
+		for _, line := range stmt.leading {
+			size += len(line)
+		}
+		size += estimateLoweredStmtsSize(stmt.children)
+		size += estimateLoweredStmtsSize(stmt.elseBody)
+		if stmt.rangeFunc != nil {
+			size += len(stmt.rangeFunc.value) + len(stmt.rangeFunc.params)*16 + estimateLoweredStmtsSize(stmt.rangeFunc.body)
+		}
+		if stmt.switchStmt != nil {
+			size += len(stmt.switchStmt.value)
+			for _, switchCase := range stmt.switchStmt.cases {
+				size += len(switchCase.values)*16 + estimateLoweredStmtsSize(switchCase.body)
+				for _, value := range switchCase.values {
+					size += len(value)
+				}
+			}
+		}
+		if stmt.selectStmt != nil {
+			size += len(stmt.selectStmt.hasReturn) + len(stmt.selectStmt.value) + len(stmt.selectStmt.result) + len(stmt.selectStmt.resultType)
+			for _, selectCase := range stmt.selectStmt.cases {
+				size += len(selectCase.channel) + len(selectCase.value) + estimateLoweredStmtsSize(selectCase.prelude) +
+					estimateLoweredStmtsSize(selectCase.body)
+			}
+		}
+		if stmt.typeSwitch != nil {
+			size += len(stmt.typeSwitch.value) + len(stmt.typeSwitch.varName) + estimateLoweredStmtsSize(stmt.typeSwitch.defaultBody)
+			for _, switchCase := range stmt.typeSwitch.cases {
+				for _, typ := range switchCase.types {
+					size += len(typ)
+				}
+				for _, typ := range switchCase.tsTypes {
+					size += len(typ)
+				}
+				size += estimateLoweredStmtsSize(switchCase.body)
+			}
+		}
+	}
+	return size
+}
+
 func sortedStructDecls(decls []loweredDecl) []loweredDecl {
 	structs := make([]loweredDecl, 0)
 	names := make(map[string]bool)
@@ -421,29 +520,42 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		if idx != 0 {
 			b.WriteString(", ")
 		}
-		methodName := method.name
-		if method.runtimeName != "" {
-			methodName = method.runtimeName
-		}
-		b.WriteString("{ name: ")
-		b.WriteString(strconvQuote(methodName))
-		b.WriteString(", args: [], returns: [] }")
+		b.WriteString(runtimeMethodSignatureExpr(method))
 	}
 	b.WriteString("],\n\t\t")
 	b.WriteString(structType.name)
-	b.WriteString(",\n\t\t{")
+	b.WriteString(",\n\t\t[")
 	for idx, field := range structType.fields {
 		if idx != 0 {
 			b.WriteString(", ")
 		}
-		b.WriteString(strconvQuote(field.name))
-		b.WriteString(": ")
-		b.WriteString(runtimeStructFieldInfoExpr(field.runtimeType, field.runtimeName, field.tag))
-	}
-	b.WriteString("}\n\t)\n")
+		b.WriteString(runtimeStructFieldInfoExpr(
+			field.runtimeType,
+			field.name,
+			field.runtimeName,
+			field.tag,
+			field.pkgPath,
+			field.anonymous,
+			field.index,
+			field.offset,
+			field.exported,
+		))
+	}
+	b.WriteString("]\n\t)\n")
 	b.WriteString("}\n")
 }
 
+func runtimeMethodSignatureExpr(method loweredFunction) string {
+	if method.runtimeSignature != "" {
+		return method.runtimeSignature
+	}
+	methodName := method.name
+	if method.runtimeName != "" {
+		methodName = method.runtimeName
+	}
+	return "{ name: " + strconvQuote(methodName) + ", args: [], returns: [] }"
+}
+
 func writeLineComment(b *strings.Builder, indent string, comment string) {
 	comment = strings.TrimSpace(comment)
 	if comment == "" {
@@ -1158,6 +1270,9 @@ func renderIndex(pkg *loweredPackage) string {
 		if file.sideEffect {
 			lines = append(lines, "import \"./"+file.outputName+"\"")
 		}
+		if file.exportAll {
+			lines = append(lines, "export * from \"./"+file.outputName+"\"")
+		}
 		exports := slices.Clone(file.exports)
 		slices.Sort(exports)
 		if len(exports) != 0 {

package/dist/gs/builtin/slice.d.ts

@@ -1,4 +1,4 @@
-import { type VarRef } from './varRef.js';
+import { type OwnedPointerHandle, type VarRef } from './varRef.js';
 export declare class GoBinaryString extends String {
     readonly bytes: Uint8Array;
     constructor(bytes: Uint8Array);
@@ -119,6 +119,7 @@ export declare function index<T>(collection: GoStringValue | Slice<T> | T[], ind
  * indexRef returns an addressable reference to a slice or array element.
  */
 export declare function indexRef<T>(collection: Slice<T> | T[] | Uint8Array, index: number): VarRef<T>;
+export declare function sliceFromOwnedPointer<T>(pointer: OwnedPointerHandle<T>, length: number): Slice<T> | Uint8Array;
 /**
  * arrayPointerFromIndexRef turns &slice[i] into a pointer to an N-element array
  * view. This models unsafe conversions such as (*[64]byte)(unsafe.Pointer(&b[0]))

package/dist/gs/builtin/slice.js

@@ -1,4 +1,4 @@
-import { isVarRef, varRef } from './varRef.js';
+import { isOwnedPointerHandle, isVarRef, varRef, } from './varRef.js';
 export class GoBinaryString extends String {
     bytes;
     constructor(bytes) {
@@ -926,7 +926,7 @@ export function indexRef(collection, index) {
         if (index < 0 || index >= collection.length) {
             throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
         }
-        return {
+        const ref = {
             get value() {
                 return collection[index];
             },
@@ -938,13 +938,15 @@ export function indexRef(collection, index) {
             __goCollection: collection,
             __goIndex: index,
         };
+        ref.__goPointer = collectionPointer(ref, collection, index);
+        return ref;
     }
     if (isComplexSlice(collection)) {
         if (index < 0 || index >= collection.__meta__.length) {
             throw new Error(`runtime error: index out of range [${index}] with length ${collection.__meta__.length}`);
         }
         const backingIndex = collection.__meta__.offset + index;
-        return {
+        const ref = {
             get value() {
                 return collection.__meta__.backing[backingIndex];
             },
@@ -956,12 +958,14 @@ export function indexRef(collection, index) {
             __goCollection: collection,
             __goIndex: index,
         };
+        ref.__goPointer = collectionPointer(ref, collection, index);
+        return ref;
     }
     if (Array.isArray(collection)) {
         if (index < 0 || index >= collection.length) {
             throw new Error(`runtime error: index out of range [${index}] with length ${collection.length}`);
         }
-        return {
+        const ref = {
             get value() {
                 return collection[index];
             },
@@ -973,9 +977,30 @@ export function indexRef(collection, index) {
             __goCollection: collection,
             __goIndex: index,
         };
+        ref.__goPointer = collectionPointer(ref, collection, index);
+        return ref;
     }
     throw new Error('runtime error: index on unsupported type');
 }
+function collectionPointer(ref, collection, index) {
+    return {
+        __goOwnedPointer: true,
+        __goAddress: () => indexAddress(collection, index),
+        __goRef: () => ref,
+        __goSlice: (length) => {
+            if (length < 0) {
+                throw new Error('runtime error: unsafe slice length out of range');
+            }
+            return goSlice(collection, index, index + length, index + length);
+        },
+    };
+}
+export function sliceFromOwnedPointer(pointer, length) {
+    if (!isOwnedPointerHandle(pointer) || pointer.__goSlice === undefined) {
+        throw new Error('reflect.SliceAt requires a GoScript-owned pointer');
+    }
+    return pointer.__goSlice(length);
+}
 /**
  * arrayPointerFromIndexRef turns &slice[i] into a pointer to an N-element array
  * view. This models unsafe conversions such as (*[64]byte)(unsafe.Pointer(&b[0]))