goscript 0.2.2 → 0.2.3

package/compiler/protobuf-ts-binding_test.go

@@ -204,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
 }
@@ -231,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()