goscript 0.2.1 → 0.2.3

package/compiler/protobuf-ts-binding.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 )
 
@@ -16,6 +17,13 @@ type protobufTypeScriptBinding struct {
 	hasOneof     bool
 }
 
+type protobufTypeScriptBindingOneofCase struct {
+	groupLocalName string
+	caseLocalName  string
+	branchCtor     string
+	valueCtor      string
+}
+
 func protobufTypeScriptBindings(semPkg *semanticPackage, options LoweringOptions) (map[string]protobufTypeScriptBinding, []Diagnostic) {
 	if semPkg == nil || semPkg.source == nil || !options.ProtobufTypeScriptBinding {
 		return nil, nil
@@ -194,7 +202,7 @@ func protobufTypeScriptBindingExportedConsts(tsPath string) map[string]bool {
 		return nil
 	}
 	exports := make(map[string]bool)
-	for _, line := range strings.Split(string(data), "\n") {
+	for line := range strings.SplitSeq(string(data), "\n") {
 		line = strings.TrimSpace(line)
 		if !strings.HasPrefix(line, "export const ") {
 			continue
@@ -291,6 +299,7 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		source:     binding.importSource,
 		sideEffect: true,
 	})
+	oneofCases := protobufTypeScriptBindingOneofCases(file)
 	var setupDecls []loweredDecl
 	for _, decl := range file.decls {
 		if decl.structType == nil {
@@ -306,7 +315,7 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		if !ok {
 			continue
 		}
-		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName)
+		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName, oneofCases[decl.structType.name])
 		if setup.code != "" {
 			setupDecls = append(setupDecls, setup)
 		}
@@ -314,6 +323,102 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 	file.decls = append(file.decls, setupDecls...)
 }
 
+func protobufTypeScriptBindingOneofCases(file *loweredFile) map[string][]protobufTypeScriptBindingOneofCase {
+	parentByName := make(map[string]*loweredStruct)
+	for _, decl := range file.decls {
+		if decl.structType != nil {
+			parentByName[decl.structType.name] = decl.structType
+		}
+	}
+	out := make(map[string][]protobufTypeScriptBindingOneofCase)
+	for _, decl := range file.decls {
+		branch := decl.structType
+		if branch == nil || !strings.Contains(branch.name, "_") {
+			continue
+		}
+		parent := protobufTypeScriptBindingOneofParent(branch.name, parentByName)
+		if parent == nil {
+			continue
+		}
+		groups := protobufTypeScriptBindingOneofGroups(parent)
+		if len(groups) == 0 {
+			continue
+		}
+		groupLocalName := protobufTypeScriptBindingOneofCaseGroup(branch, parent, groups)
+		if groupLocalName == "" {
+			continue
+		}
+		for _, field := range branch.fields {
+			if !strings.Contains(field.tag, "oneof") {
+				continue
+			}
+			out[parent.name] = append(out[parent.name], protobufTypeScriptBindingOneofCase{
+				groupLocalName: groupLocalName,
+				caseLocalName:  protobufTypeScriptBindingFieldLocalName(field),
+				branchCtor:     branch.name,
+				valueCtor:      protobufTypeScriptBindingFieldCtor(field),
+			})
+		}
+	}
+	for parentName := range out {
+		slices.SortFunc(out[parentName], func(left, right protobufTypeScriptBindingOneofCase) int {
+			if left.groupLocalName != right.groupLocalName {
+				return strings.Compare(left.groupLocalName, right.groupLocalName)
+			}
+			return strings.Compare(left.caseLocalName, right.caseLocalName)
+		})
+	}
+	return out
+}
+
+func protobufTypeScriptBindingOneofParent(branchName string, parents map[string]*loweredStruct) *loweredStruct {
+	var parent *loweredStruct
+	for name, candidate := range parents {
+		if name == branchName || !strings.HasPrefix(branchName, name+"_") {
+			continue
+		}
+		if parent == nil || len(name) > len(parent.name) {
+			parent = candidate
+		}
+	}
+	return parent
+}
+
+func protobufTypeScriptBindingOneofGroups(parent *loweredStruct) map[string]string {
+	groups := make(map[string]string)
+	for _, field := range parent.fields {
+		if !strings.Contains(field.tag, "protobuf_oneof") {
+			continue
+		}
+		localName := protobufTypeScriptBindingTagValue(field.tag, "protobuf_oneof:\"")
+		if localName == "" {
+			groups[field.name] = protobufTypeScriptBindingFieldLocalName(field)
+			continue
+		}
+		groups[field.name] = protobufTypeScriptBindingProtoCamel(localName)
+	}
+	return groups
+}
+
+func protobufTypeScriptBindingOneofCaseGroup(branch, parent *loweredStruct, groups map[string]string) string {
+	if len(groups) == 1 {
+		for _, localName := range groups {
+			return localName
+		}
+	}
+	prefix := "is" + parent.name + "_"
+	for _, method := range branch.methods {
+		groupName, ok := strings.CutPrefix(method.name, prefix)
+		if !ok {
+			continue
+		}
+		if localName := groups[groupName]; localName != "" {
+			return localName
+		}
+	}
+	return ""
+}
+
 func protobufTypeScriptBindingSyntheticMapEntry(name string) bool {
 	return strings.Contains(name, "_") && strings.HasSuffix(name, "Entry")
 }
@@ -466,23 +571,66 @@ func protobufBindingParam(method *loweredFunction, idx int, fallback string) str
 	return method.params[idx].name
 }
 
-func protobufTypeScriptBindingStructSetupDecl(structType *loweredStruct, importAlias, messageName string) loweredDecl {
+func protobufTypeScriptBindingStructSetupDecl(structType *loweredStruct, importAlias, messageName string, oneofCases []protobufTypeScriptBindingOneofCase) loweredDecl {
 	if structType == nil {
 		return loweredDecl{}
 	}
 	if messageName == "" {
 		messageName = structType.name
 	}
-	entries := make([]string, 0, len(structType.fields))
+	fieldEntries := make(map[string]string)
 	for _, field := range structType.fields {
 		ctor := protobufTypeScriptBindingFieldCtor(field)
 		if ctor == "" {
 			continue
 		}
-		entries = append(entries, strconvQuote(protobufTypeScriptBindingFieldLocalName(field))+": "+ctor)
+		fieldEntries[protobufTypeScriptBindingFieldLocalName(field)] = ctor
+	}
+	for _, oneofCase := range oneofCases {
+		if oneofCase.valueCtor != "" {
+			fieldEntries[oneofCase.caseLocalName] = oneofCase.valueCtor
+		}
+	}
+	fieldNames := make([]string, 0, len(fieldEntries))
+	for name := range fieldEntries {
+		fieldNames = append(fieldNames, name)
+	}
+	slices.Sort(fieldNames)
+	entries := make([]string, 0, len(fieldNames))
+	for _, name := range fieldNames {
+		entries = append(entries, strconvQuote(name)+": "+fieldEntries[name])
+	}
+	code := "(" + structType.name + " as any).__protobufTypeScriptMessage = " + importAlias + "." + messageName + ";\n" +
+		"(" + structType.name + " as any).__protobufTypeScriptFields = {" + strings.Join(entries, ", ") + "};"
+	if len(oneofCases) != 0 {
+		code += "\n(" + structType.name + " as any).__protobufTypeScriptOneofFields = " + protobufTypeScriptBindingOneofFieldsLiteral(oneofCases) + ";"
+	}
+	return loweredDecl{code: code}
+}
+
+func protobufTypeScriptBindingOneofFieldsLiteral(oneofCases []protobufTypeScriptBindingOneofCase) string {
+	groups := make(map[string][]protobufTypeScriptBindingOneofCase)
+	for _, oneofCase := range oneofCases {
+		groups[oneofCase.groupLocalName] = append(groups[oneofCase.groupLocalName], oneofCase)
+	}
+	groupNames := make([]string, 0, len(groups))
+	for name := range groups {
+		groupNames = append(groupNames, name)
+	}
+	slices.Sort(groupNames)
+	entries := make([]string, 0, len(groupNames))
+	for _, groupName := range groupNames {
+		cases := groups[groupName]
+		slices.SortFunc(cases, func(left, right protobufTypeScriptBindingOneofCase) int {
+			return strings.Compare(left.caseLocalName, right.caseLocalName)
+		})
+		caseEntries := make([]string, 0, len(cases))
+		for _, oneofCase := range cases {
+			caseEntries = append(caseEntries, strconvQuote(oneofCase.caseLocalName)+": "+oneofCase.branchCtor)
+		}
+		entries = append(entries, strconvQuote(groupName)+": {"+strings.Join(caseEntries, ", ")+"}")
 	}
-	return loweredDecl{code: "(" + structType.name + " as any).__protobufTypeScriptMessage = " + importAlias + "." + messageName + ";\n" +
-		"(" + structType.name + " as any).__protobufTypeScriptFields = {" + strings.Join(entries, ", ") + "};"}
+	return "{" + strings.Join(entries, ", ") + "}"
 }
 
 func protobufTypeScriptBindingFieldLocalName(field loweredStructField) string {

package/compiler/protobuf-ts-binding_test.go

@@ -80,6 +80,115 @@ func NewFoo() Foo {
 	}
 }
 
+func TestProtobufTypeScriptBindingRewritesGeneratedMethodsToBoundHelpers(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", `module example.test/protobufbindingmethods
+
+go 1.25
+
+require github.com/aperturerobotics/protobuf-go-lite v0.0.0
+
+replace github.com/aperturerobotics/protobuf-go-lite => ./protobuf-go-lite
+`)
+	writeTestFile(t, dir, "protobuf-go-lite/go.mod", `module github.com/aperturerobotics/protobuf-go-lite
+
+go 1.25
+`)
+	writeTestFile(t, dir, "protobuf-go-lite/protobuf-go-lite.go", `package protobuf_go_lite
+
+type CloneMessage interface {
+	CloneMessageVT() CloneMessage
+}
+`)
+	writeTestFile(t, dir, "foo.pb.go", `package protobufbindingmethods
+
+import protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
+
+type Foo struct {
+	Name string
+}
+
+func (x *Foo) CloneMessageVT() protobuf_go_lite.CloneMessage {
+	println("inline CloneMessageVT marker")
+	return x.CloneVT()
+}
+
+func (x *Foo) CloneVT() *Foo {
+	println("inline CloneVT marker")
+	return &Foo{Name: x.Name}
+}
+
+func (x *Foo) EqualVT(other *Foo) bool {
+	println("inline EqualVT marker")
+	return other != nil && x.Name == other.Name
+}
+
+func (x *Foo) MarshalVT() ([]byte, error) {
+	println("inline MarshalVT marker")
+	return []byte(x.Name), nil
+}
+
+func (x *Foo) MarshalToSizedBufferVT(data []byte) (int, error) {
+	println("inline MarshalToSizedBufferVT marker")
+	return copy(data, x.Name), nil
+}
+
+func (x *Foo) SizeVT() int {
+	println("inline SizeVT marker")
+	return len(x.Name)
+}
+
+func (x *Foo) UnmarshalVT(data []byte) error {
+	println("inline UnmarshalVT marker")
+	x.Name = string(data)
+	return nil
+}
+
+func (x *Foo) Reset() {
+	println("inline Reset marker")
+	*x = Foo{}
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  name?: string
+}
+export const Foo = {} 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", "protobufbindingmethods", "foo.pb.ts"))
+	wantSnippets := []string{
+		`$.interfaceValue<protobuf_go_lite.CloneMessage | null>(protobuf_go_lite.CloneBoundMessage(Foo, this) as any, "*protobufbindingmethods.Foo")`,
+		`return protobuf_go_lite.CloneBoundMessage(Foo, this) as any`,
+		`protobuf_go_lite.EqualBoundMessage(Foo, this, other)`,
+		`protobuf_go_lite.MarshalBoundMessageVT(Foo, this)`,
+		`protobuf_go_lite.MarshalBoundMessageToSizedBufferVT(Foo, this, data)`,
+		`protobuf_go_lite.SizeBoundMessageVT(Foo, this)`,
+		`protobuf_go_lite.UnmarshalBoundMessageVT(Foo, this, data)`,
+		`$.assignStruct($.pointerValue<Foo>(this), $.markAsStructValue(new Foo()))`,
+	}
+	for _, snippet := range wantSnippets {
+		if !strings.Contains(binding, snippet) {
+			t.Fatalf("binding file should rewrite generated methods through %q, got:\n%s", snippet, binding)
+		}
+	}
+	if strings.Contains(binding, "inline ") {
+		t.Fatalf("binding file should not preserve inline generated method bodies, got:\n%s", binding)
+	}
+}
+
 func TestProtobufTypeScriptBindingEmitsMetadataForPreservedOneofFiles(t *testing.T) {
 	dir := t.TempDir()
 	writeTestFile(t, dir, "go.mod", "module example.test/oneofpb\n\ngo 1.25\n")
@@ -95,7 +204,11 @@ func TestProtobufTypeScriptBindingEmitsMetadataForPreservedOneofFiles(t *testing
 		"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")
+		"func (*Wrapper_StringValue) isWrapper_Choice() {}\n\n"+
+		"type Wrapper_InnerValue struct {\n"+
+		"\tInnerValue *Inner `protobuf:\"bytes,3,opt,name=inner_value,json=innerValue,proto3,oneof\"`\n"+
+		"}\n\n"+
+		"func (*Wrapper_InnerValue) isWrapper_Choice() {}\n")
 	writeTestFile(t, dir, "foo.pb.ts", `export interface Inner {
   name?: string
 }
@@ -122,7 +235,8 @@ export const Wrapper = {} as any
 	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};`) {
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptFields = {"inner": Inner, "innerValue": Inner};`) ||
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptOneofFields = {"choice": {"innerValue": Wrapper_InnerValue, "stringValue": Wrapper_StringValue}};`) {
 		t.Fatalf("oneof-preserved protobuf file should still expose TypeScript metadata, got:\n%s", binding)
 	}
 	if strings.Contains(binding, `__protobuf_ts.Wrapper_StringValue`) {

package/compiler/runtime-contract.go

@@ -88,6 +88,7 @@ const (
 	RuntimeHelperSliceToArray                 RuntimeHelper = "slice.sliceToArray"
 	RuntimeHelperSliceToArrayPointer          RuntimeHelper = "slice.sliceToArrayPointer"
 	RuntimeHelperAppend                       RuntimeHelper = "slice.append"
+	RuntimeHelperAppendSlice                  RuntimeHelper = "slice.appendSlice"
 	RuntimeHelperCopy                         RuntimeHelper = "slice.copy"
 	RuntimeHelperAsArray                      RuntimeHelper = "slice.asArray"
 	RuntimeHelperStringToRunes                RuntimeHelper = "slice.stringToRunes"
@@ -318,6 +319,7 @@ func runtimeHelperContracts() []RuntimeHelperContract {
 		runtimeHelper(RuntimeHelperSliceToArray, "sliceToArray", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperSliceToArrayPointer, "sliceToArrayPointer", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperAppend, "append", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperAppendSlice, "appendSlice", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperCopy, "copy", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperAsArray, "asArray", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperStringToRunes, "stringToRunes", RuntimeHelperCategorySlice),

package/compiler/runtime-contract_test.go

@@ -24,6 +24,7 @@ func TestRuntimeContractOwnsBuiltinImportAndHelpers(t *testing.T) {
 		RuntimeHelperPointerValue:             RuntimeHelperCategoryValue,
 		RuntimeHelperMakeSlice:                RuntimeHelperCategorySlice,
 		RuntimeHelperAppend:                   RuntimeHelperCategorySlice,
+		RuntimeHelperAppendSlice:              RuntimeHelperCategorySlice,
 		RuntimeHelperIndexAddress:             RuntimeHelperCategorySlice,
 		RuntimeHelperIndexByteAddress:         RuntimeHelperCategorySlice,
 		RuntimeHelperUnsafePointerRef:         RuntimeHelperCategorySlice,

package/compiler/semantic-model.go

@@ -769,6 +769,9 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				if callUsesFunctionIdentifier(pkg, typed.Fun) {
 					markFunctionAsync(semFn, "function-identifier-call")
 				}
+				if callUsesInterfaceMethod(pkg, typed.Fun) {
+					markFunctionAsync(semFn, "interface-method-call")
+				}
 				if overrideFacts.IsMethodAsync(overrideCallPackage(pkg, typed.Fun), overrideCallMethod(pkg, typed.Fun)) {
 					markFunctionAsync(semFn, "override")
 				}
@@ -815,6 +818,9 @@ func recordImmediateFuncLitAsyncFacts(
 			if callUsesFunctionIdentifier(pkg, typed.Fun) {
 				markFunctionAsync(semFn, "async-function-literal-call")
 			}
+			if callUsesInterfaceMethod(pkg, typed.Fun) {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
 			if called != nil {
 				calledFn := semanticFunctionFor(model, called)
 				if calledFn != nil && calledFn.async {
@@ -1156,6 +1162,10 @@ func exprMayNeedAwait(model *SemanticModel, pkg *packages.Package, expr ast.Expr
 				needsAwait = true
 				return false
 			}
+			if callUsesInterfaceMethod(pkg, typed.Fun) {
+				needsAwait = true
+				return false
+			}
 			if called := calledFunction(pkg, typed.Fun); called != nil {
 				semFn := semanticFunctionFor(model, called)
 				if semFn != nil && semFn.async {
@@ -1672,6 +1682,9 @@ func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 		}
 		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
 			implMethod := graphEntry.implMethods[methodName]
+			if isSyncErrorMethodFunc(ifaceMethod) || isSyncErrorMethodFunc(implMethod) {
+				continue
+			}
 			implFn := semanticFunctionFor(model, implMethod)
 			if implFn != nil && implFn.async {
 				model.markInterfaceMethodAsync(ifaceMethod)
@@ -1697,6 +1710,9 @@ func (o *SemanticModelOwner) applyAnonymousInterfaceAsyncMethods(
 		}
 		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
 			implMethod := graphEntry.implMethods[methodName]
+			if isSyncErrorMethodFunc(ifaceMethod) || isSyncErrorMethodFunc(implMethod) {
+				continue
+			}
 			if model.functionAsync(implMethod) {
 				model.markInterfaceMethodAsync(ifaceMethod)
 			}

package/compiler/semantic-model_test.go

@@ -604,6 +604,44 @@ func TestSemanticModelMarksFunctionIdentifierCallAsync(t *testing.T) {
 	}
 }
 
+func TestSemanticModelMarksInterfaceMethodCallAsync(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/interfacecall\n\ngo 1.25.3\n",
+		"iface/controller.go": strings.Join([]string{
+			"package iface",
+			"import \"context\"",
+			"type Controller interface {",
+			"  Execute(context.Context) error",
+			"}",
+			"",
+		}, "\n"),
+		"controller.go": strings.Join([]string{
+			"package interfacecall",
+			"import (",
+			"  \"context\"",
+			"  \"example.test/interfacecall/iface\"",
+			")",
+			"func Run(ctx context.Context, c iface.Controller) error {",
+			"  return c.Execute(ctx)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{".", "./iface"},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+	run := requireDefinedFunc(t, graph, "example.test/interfacecall", "Run")
+	semFn := model.functions[run]
+	if semFn == nil || !semFn.async {
+		t.Fatalf("expected Run to be async after calling interface method, got %#v", semFn)
+	}
+}
+
 func buildSemanticModel(t *testing.T, graph *PackageGraph) *SemanticModel {
 	t.Helper()