goscript 0.2.0 → 0.2.1

package/compiler/lowering_bench_test.go

@@ -88,6 +88,7 @@ func BenchmarkLoweringFile(b *testing.B) {
 			fixture.lazyPackageVarsByPkg,
 			make(runtimeMethodSetCache),
 			false,
+			"",
 		); diagnosticsHaveErrors(diagnostics) {
 			b.Fatal(diagnostics)
 		}

package/compiler/lowering_internal_test.go

@@ -0,0 +1,18 @@
+package compiler
+
+import "testing"
+
+func TestIntegerBitHelpersHandleNilTypes(t *testing.T) {
+	if bits, ok := unsignedIntegerBits(nil); ok || bits != 0 {
+		t.Fatalf("unsignedIntegerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if bits, ok := signedIntegerBits(nil); ok || bits != 0 {
+		t.Fatalf("signedIntegerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if bits, ok := integerBits(nil); ok || bits != 0 {
+		t.Fatalf("integerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if isRuntimeWideIntegerType(nil) {
+		t.Fatalf("isRuntimeWideIntegerType(nil) = true; want false")
+	}
+}

package/compiler/protobuf-ts-binding.go

@@ -66,7 +66,7 @@ func protobufTypeScriptBindings(semPkg *semanticPackage, options LoweringOptions
 			sourcePath:   sourcePath,
 			outputName:   strings.TrimSuffix(filepath.Base(sourcePath), ".go") + ".ts",
 			importSource: importSource,
-			messageNames: protobufTypeScriptBindingMessageNames(syntax),
+			messageNames: protobufTypeScriptBindingMessageNames(syntax, tsPath),
 			hasOneof:     protobufTypeScriptBindingHasOneof(syntax),
 		}
 	}
@@ -158,11 +158,12 @@ func protobufTypeScriptBindingHasOneof(file *ast.File) bool {
 	return false
 }
 
-func protobufTypeScriptBindingMessageNames(file *ast.File) map[string]string {
+func protobufTypeScriptBindingMessageNames(file *ast.File, tsPath string) map[string]string {
 	names := make(map[string]string)
 	if file == nil {
 		return names
 	}
+	exportedTSMessages := protobufTypeScriptBindingExportedConsts(tsPath)
 	for _, decl := range file.Decls {
 		genDecl, ok := decl.(*ast.GenDecl)
 		if !ok {
@@ -177,12 +178,46 @@ func protobufTypeScriptBindingMessageNames(file *ast.File) map[string]string {
 				continue
 			}
 			name := typeSpec.Name.Name
-			names[name] = protobufTypeScriptBindingSafeIdentifier(name)
+			safeName := protobufTypeScriptBindingSafeIdentifier(name)
+			if len(exportedTSMessages) != 0 && !exportedTSMessages[safeName] {
+				continue
+			}
+			names[name] = safeName
 		}
 	}
 	return names
 }
 
+func protobufTypeScriptBindingExportedConsts(tsPath string) map[string]bool {
+	data, err := os.ReadFile(tsPath)
+	if err != nil {
+		return nil
+	}
+	exports := make(map[string]bool)
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "export const ") {
+			continue
+		}
+		rest := strings.TrimPrefix(line, "export const ")
+		end := 0
+		for end < len(rest) && protobufTypeScriptBindingIdentifierByte(rest[end]) {
+			end++
+		}
+		if end != 0 {
+			exports[rest[:end]] = true
+		}
+	}
+	return exports
+}
+
+func protobufTypeScriptBindingIdentifierByte(ch byte) bool {
+	return ch == '_' || ch == '$' ||
+		ch >= '0' && ch <= '9' ||
+		ch >= 'A' && ch <= 'Z' ||
+		ch >= 'a' && ch <= 'z'
+}
+
 func protobufTypeScriptBindingSafeIdentifier(name string) string {
 	switch name {
 	case "break",
@@ -250,9 +285,6 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		return
 	}
 	file.outputName = binding.outputName
-	if binding.hasOneof {
-		return
-	}
 	const importAlias = "__protobuf_ts"
 	file.imports = append(file.imports, loweredImport{
 		alias:      importAlias,
@@ -267,8 +299,14 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		if protobufTypeScriptBindingSyntheticMapEntry(decl.structType.name) {
 			continue
 		}
-		rewriteProtobufTypeScriptBindingStruct(decl.structType)
-		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, binding.messageNames[decl.structType.name])
+		if !binding.hasOneof {
+			rewriteProtobufTypeScriptBindingStruct(decl.structType, binding.sourcePath)
+		}
+		messageName, ok := binding.messageNames[decl.structType.name]
+		if !ok {
+			continue
+		}
+		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName)
 		if setup.code != "" {
 			setupDecls = append(setupDecls, setup)
 		}
@@ -322,12 +360,18 @@ func protobufSRPCHasGoScriptReplacement(sourcePath string) bool {
 	return err == nil
 }
 
-func rewriteProtobufTypeScriptBindingStruct(structType *loweredStruct) {
+func rewriteProtobufTypeScriptBindingStruct(structType *loweredStruct, bindingSourcePath string) {
 	if structType == nil {
 		return
 	}
 	for idx := range structType.methods {
 		method := &structType.methods[idx]
+		if method.sourcePath != bindingSourcePath {
+			continue
+		}
+		if structType.protobufPreserveJSON && protobufTypeScriptBindingJSONMethodName(method.name) {
+			continue
+		}
 		body := protobufTypeScriptBindingMethodBody(structType, method)
 		if body == "" {
 			continue
@@ -383,6 +427,15 @@ func protobufTypeScriptBindingMethodBody(structType *loweredStruct, method *lowe
 	}
 }
 
+func protobufTypeScriptBindingJSONMethodName(name string) bool {
+	switch name {
+	case "MarshalJSON", "MarshalProtoJSON", "UnmarshalJSON", "UnmarshalProtoJSON":
+		return true
+	default:
+		return false
+	}
+}
+
 func protobufTypeScriptBindingReplacesMethodName(name string) bool {
 	switch name {
 	case "CloneMessageVT",
@@ -448,11 +501,11 @@ func protobufTypeScriptBindingFieldLocalName(field loweredStructField) string {
 }
 
 func protobufTypeScriptBindingTagValue(tag, key string) string {
-	idx := strings.Index(tag, key)
-	if idx < 0 {
+	_, after, ok := strings.Cut(tag, key)
+	if !ok {
 		return ""
 	}
-	rest := tag[idx+len(key):]
+	rest := after
 	end := len(rest)
 	for idx, ch := range rest {
 		if ch == ',' || ch == '"' || ch == '`' || ch == ' ' {

package/compiler/protobuf-ts-binding_test.go

@@ -80,6 +80,236 @@ func NewFoo() Foo {
 	}
 }
 
+func TestProtobufTypeScriptBindingEmitsMetadataForPreservedOneofFiles(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/oneofpb\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", "package oneofpb\n\n"+
+		"type Inner struct {\n"+
+		"\tName string `protobuf:\"bytes,1,opt,name=name,proto3\" json:\"name,omitempty\"`\n"+
+		"}\n\n"+
+		"type Wrapper struct {\n"+
+		"\tInner *Inner `protobuf:\"bytes,1,opt,name=inner,proto3\" json:\"inner,omitempty\"`\n"+
+		"\tChoice isWrapper_Choice `protobuf_oneof:\"choice\"`\n"+
+		"}\n\n"+
+		"type isWrapper_Choice interface { isWrapper_Choice() }\n\n"+
+		"type Wrapper_StringValue struct {\n"+
+		"\tStringValue string `protobuf:\"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof\"`\n"+
+		"}\n\n"+
+		"func (*Wrapper_StringValue) isWrapper_Choice() {}\n")
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Inner {
+  name?: string
+}
+export const Inner = {} as any
+export interface Wrapper {
+  inner?: Inner
+}
+export const Wrapper = {} as any
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "oneofpb", "foo.pb.ts"))
+	if !strings.Contains(binding, `import * as __protobuf_ts`) ||
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptMessage = __protobuf_ts.Wrapper;`) ||
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptFields = {"inner": Inner};`) {
+		t.Fatalf("oneof-preserved protobuf file should still expose TypeScript metadata, got:\n%s", binding)
+	}
+	if strings.Contains(binding, `__protobuf_ts.Wrapper_StringValue`) {
+		t.Fatalf("oneof wrapper structs should not reference missing TypeScript exports, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesCustomJSONMethods(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/custompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", `package custompbjson
+
+type Foo struct {
+	Config []byte
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  config?: Uint8Array
+}
+export const Foo = {} as any
+`)
+	writeTestFile(t, dir, "foo-json.go", `package custompbjson
+
+func (x *Foo) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "custompbjson", "foo.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Foo`) {
+		t.Fatalf("custom JSON method should not be replaced by generic protobuf helper, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `.Config = b`) {
+		t.Fatalf("custom JSON method body should be preserved, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesJSONGraphWithCustomNestedMessage(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/nestedcustompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", `package nestedcustompbjson
+
+type Foo struct {
+	Items []*Item
+}
+
+type Item struct {
+	Config []byte
+}
+
+func generatedFooJSONMarker(x *Foo) error {
+	return nil
+}
+
+func (x *Foo) UnmarshalJSON(b []byte) error {
+	return generatedFooJSONMarker(x)
+}
+
+func (x *Foo) UnmarshalProtoJSON(s any) {
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  items?: Item[]
+}
+export const Foo = {} as any
+export interface Item {
+  config?: Uint8Array
+}
+export const Item = {} as any
+`)
+	writeTestFile(t, dir, "item-json.go", `package nestedcustompbjson
+
+func (x *Item) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "nestedcustompbjson", "foo.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Foo`) {
+		t.Fatalf("outer message with nested custom JSON should keep generated JSON body, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `generatedFooJSONMarker`) {
+		t.Fatalf("outer generated JSON body should be preserved, got:\n%s", binding)
+	}
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Item`) {
+		t.Fatalf("nested custom JSON method should not be replaced, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `.Config = b`) {
+		t.Fatalf("nested custom JSON method body should be preserved, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesJSONGraphWithImportedCustomNestedMessage(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/importedcustompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "inner/inner.pb.go", `package inner
+
+type Inner struct {
+	Config []byte
+}
+`)
+	writeTestFile(t, dir, "inner/inner.pb.ts", `export interface Inner {
+  config?: Uint8Array
+}
+export const Inner = {} as any
+`)
+	writeTestFile(t, dir, "inner/inner-json.go", `package inner
+
+func (x *Inner) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+	writeTestFile(t, dir, "outer.pb.go", `package importedcustompbjson
+
+import "example.test/importedcustompbjson/inner"
+
+type Outer struct {
+	Inner *inner.Inner
+}
+
+func generatedOuterJSONMarker(x *Outer) error {
+	return nil
+}
+
+func (x *Outer) UnmarshalJSON(b []byte) error {
+	return generatedOuterJSONMarker(x)
+}
+`)
+	writeTestFile(t, dir, "outer.pb.ts", `import type { Inner } from './inner/inner.pb.js'
+
+export interface Outer {
+  inner?: Inner
+}
+export const Outer = {} as any
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "importedcustompbjson", "outer.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Outer`) {
+		t.Fatalf("outer message with imported nested custom JSON should keep generated JSON body, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `generatedOuterJSONMarker`) {
+		t.Fatalf("outer generated JSON body should be preserved, got:\n%s", binding)
+	}
+}
+
 func TestProtobufTypeScriptBindingReportsMissingSibling(t *testing.T) {
 	dir := t.TempDir()
 	writeTestFile(t, dir, "go.mod", "module example.test/missingpbts\n\ngo 1.25\n")

package/compiler/runtime-contract.go

@@ -105,6 +105,8 @@ const (
 	RuntimeHelperSliceStringOrBytes           RuntimeHelper = "slice.sliceStringOrBytes"
 	RuntimeHelperIndexRef                     RuntimeHelper = "slice.indexRef"
 	RuntimeHelperIndexAddress                 RuntimeHelper = "slice.indexAddress"
+	RuntimeHelperIndexByteAddress             RuntimeHelper = "slice.indexByteAddress"
+	RuntimeHelperUnsafePointerRef             RuntimeHelper = "slice.unsafePointerRef"
 
 	RuntimeHelperMakeMap        RuntimeHelper = "map.makeMap"
 	RuntimeHelperMapGet         RuntimeHelper = "map.mapGet"
@@ -333,6 +335,8 @@ func runtimeHelperContracts() []RuntimeHelperContract {
 		runtimeHelper(RuntimeHelperSliceStringOrBytes, "sliceStringOrBytes", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexRef, "indexRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexAddress, "indexAddress", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperIndexByteAddress, "indexByteAddress", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperUnsafePointerRef, "unsafePointerRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperMakeMap, "makeMap", RuntimeHelperCategoryMap),
 		runtimeHelper(RuntimeHelperMapGet, "mapGet", RuntimeHelperCategoryMap),
 		runtimeHelper(RuntimeHelperMapSet, "mapSet", RuntimeHelperCategoryMap),

package/compiler/runtime-contract_test.go

@@ -25,6 +25,8 @@ func TestRuntimeContractOwnsBuiltinImportAndHelpers(t *testing.T) {
 		RuntimeHelperMakeSlice:                RuntimeHelperCategorySlice,
 		RuntimeHelperAppend:                   RuntimeHelperCategorySlice,
 		RuntimeHelperIndexAddress:             RuntimeHelperCategorySlice,
+		RuntimeHelperIndexByteAddress:         RuntimeHelperCategorySlice,
+		RuntimeHelperUnsafePointerRef:         RuntimeHelperCategorySlice,
 		RuntimeHelperMakeMap:                  RuntimeHelperCategoryMap,
 		RuntimeHelperMapGet:                   RuntimeHelperCategoryMap,
 		RuntimeHelperNewError:                 RuntimeHelperCategoryError,

package/compiler/service.go

@@ -127,6 +127,7 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 
 	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel, LoweringOptions{
 		SourceRoot:                protobufTypeScriptBindingRoot(req.Dir),
+		DisplayRoot:               req.Dir,
 		OutputPath:                req.OutputPath,
 		ProtobufTypeScriptBinding: req.ProtobufTypeScriptBinding,
 	})

package/compiler/skeleton_test.go

@@ -1496,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",
@@ -2388,6 +2435,7 @@ 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\", ({ kind: $.TypeKind.Function, name: \"main.Greeter\"",
 		"params: [{ kind: $.TypeKind.Basic, name: \"string\" }]",
@@ -4353,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"),
@@ -4377,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/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)
+	}
 }