goscript 0.1.4 → 0.2.1

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,12 @@ 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),
+		DisplayRoot:               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",
@@ -1453,6 +1496,53 @@ func TestCompilePackagesEmitsIndexAddressRefs(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersUnsafeBytePointerArithmetic(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unsafeaddr\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"unsafe\"",
+			"func Set(bits []uint64, idx uint64, mask []uint8) uint8 {",
+			"  ptr := unsafe.Pointer(uintptr(unsafe.Pointer(&bits[idx>>6])) + uintptr((idx%64)>>3))",
+			"  *(*uint8)(ptr) |= mask[idx%8]",
+			"  return *(*uint8)(ptr)",
+			"}",
+			"func CopyBlock(dst []byte, words *[16]uint32) {",
+			"  *(*[64]byte)(unsafe.Pointer(&dst[0])) = *(*[64]byte)(unsafe.Pointer(&words[0]))",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	_, err = comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "unsafeaddr", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.indexByteAddress(bits!, $.uint64Shr(idx, 6), 8)") {
+		t.Fatalf("missing byte-addressed unsafe pointer root:\n%s", text)
+	}
+	if !strings.Contains(text, "$.unsafePointerRef<number>(ptr).value =") {
+		t.Fatalf("missing unsafe pointer storage ref:\n%s", text)
+	}
+	if !strings.Contains(text, "return $.uint($.unsafePointerRef<number>(ptr).value, 8)") {
+		t.Fatalf("missing unsafe pointer value ref:\n%s", text)
+	}
+	if !strings.Contains(text, "$.arrayPointerFromIndexRef<number>($.indexRef($.pointerValue<number[]>(words), 0), 64, 4, 1)") {
+		t.Fatalf("missing byte-view array pointer conversion:\n%s", text)
+	}
+}
+
 func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/structs\n\ngo 1.25.3\n",
@@ -1516,8 +1606,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)
@@ -2345,10 +2435,13 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 		"Read(): string",
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
+		"{ name: \"Close\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }]\n);",
 		"((__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 +2705,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 +2854,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 +4220,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 +4262,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\") })",
@@ -4299,10 +4401,15 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 		"main.go": strings.Join([]string{
 			"package main",
 			"var value = 1",
+			"var wide uint64 = 1",
+			"var signed int64 = 1",
+			"func invert(crc uint64) uint64 {",
+			"  return ^crc",
+			"}",
 			"func main() {",
 			"  mask := 7",
 			"  mask &^= 3",
-			"  println(^value, value &^ 3, mask, 0700)",
+			"  println(^value, ^wide, ^signed, invert(wide), value &^ 3, mask, 0700)",
 			"}",
 			"",
 		}, "\n"),
@@ -4323,8 +4430,9 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
+		"return $.uint($.uint64Xor(crc, -1n), 64)",
 		"mask = mask & ~((3))",
-		"$.println(~value, value & ~(3), mask, 0o700)",
+		"$.println($.int64Xor(value, -1n), $.uint($.uint64Xor(wide, -1n), 64), $.int($.int64Xor(signed, -1n)), $.uint(invert($.uint(wide, 64)), 64), value & ~(3), mask, 0o700)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)

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/compiler/wasm/compile_test.go

@@ -49,7 +49,8 @@ func TestCompileSourceReportsParseErrors(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected compile error")
 	}
-	requireCompileDiagnostic(t, err, "goscript/wasm:parse")
+	diag := requireCompileDiagnostic(t, err, "goscript/wasm:parse")
+	requireDiagnosticPosition(t, diag, "main.go", 2, 12)
 }
 
 func TestCompileSourceReportsUnsupportedImports(t *testing.T) {
@@ -57,10 +58,27 @@ func TestCompileSourceReportsUnsupportedImports(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected compile error")
 	}
-	requireCompileDiagnostic(t, err, "goscript/wasm:imports-unsupported")
+	diag := requireCompileDiagnostic(t, err, "goscript/wasm:imports-unsupported")
+	requireDiagnosticPosition(t, diag, "main.go", 3, 8)
 }
 
-func requireCompileDiagnostic(t *testing.T, err error, code string) {
+func TestCompileSourceReportsTypecheckPositions(t *testing.T) {
+	_, err := CompileSource(strings.Join([]string{
+		"package main",
+		"",
+		"func main() {",
+		"    missing()",
+		"}",
+		"",
+	}, "\n"), "main")
+	if err == nil {
+		t.Fatal("expected compile error")
+	}
+	diag := requireCompileDiagnostic(t, err, "goscript/wasm:typecheck")
+	requireDiagnosticPosition(t, diag, "main.go", 4, 5)
+}
+
+func requireCompileDiagnostic(t *testing.T, err error, code string) compiler.Diagnostic {
 	t.Helper()
 
 	var compileErr *compiler.CompileError
@@ -72,8 +90,23 @@ func requireCompileDiagnostic(t *testing.T, err error, code string) {
 			if diag.Severity != compiler.DiagnosticSeverityError {
 				t.Fatalf("expected error severity, got %s", diag.Severity)
 			}
-			return
+			return diag
 		}
 	}
 	t.Fatalf("missing diagnostic %q in %#v", code, compileErr.Diagnostics)
+	return compiler.Diagnostic{}
+}
+
+func requireDiagnosticPosition(t *testing.T, diag compiler.Diagnostic, displayFile string, line int, column int) {
+	t.Helper()
+
+	if diag.Position == nil {
+		t.Fatalf("expected position in %#v", diag)
+	}
+	if diag.Position.DisplayFile != displayFile {
+		t.Fatalf("DisplayFile = %q, want %q", diag.Position.DisplayFile, displayFile)
+	}
+	if diag.Position.Line != line || diag.Position.Column != column {
+		t.Fatalf("position = %d:%d, want %d:%d", diag.Position.Line, diag.Position.Column, line, column)
+	}
 }