goscript 0.2.2 → 0.2.4

package/compiler/override-registry_test.go

@@ -488,6 +488,181 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsIOFSStatOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofsstat\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) error {",
+			"  _, err := fs.Stat(fsys, \"pkg\")",
+			"  return err",
+			"}",
+			"func main() { _ = Use(memFS{}) }",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "iofsstat", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Stat caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "await fs.Stat(") {
+		t.Fatalf("io/fs Stat override call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsIOFSLstatOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofslstat\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) error {",
+			"  _, err := fs.Lstat(fsys, \"pkg\")",
+			"  return err",
+			"}",
+			"func main() { _ = Use(memFS{}) }",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "iofslstat", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Lstat caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "await fs.Lstat(") {
+		t.Fatalf("io/fs Lstat override call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsIOFSSubOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iofssub\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"io/fs\"",
+			"type memFS struct{}",
+			"func (memFS) Open(name string) (fs.File, error) { return nil, fs.ErrNotExist }",
+			"func Use(fsys fs.FS) (fs.FS, error) {",
+			"  return fs.Sub(fsys, \"pkg\")",
+			"}",
+			"func main() { _, _ = Use(memFS{}) }",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "iofssub", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use(") {
+		t.Fatalf("fs.Sub caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await fs.Sub(") {
+		t.Fatalf("io/fs Sub override call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsAsyncSlicesSortFuncComparator(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/slicesasyncsort\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"slices\"",
+			"type Comparator interface { Less(a, b int) bool }",
+			"func Use(c Comparator, values []int) {",
+			"  slices.SortFunc(values, func(a, b int) int {",
+			"    if c.Less(a, b) {",
+			"      return -1",
+			"    }",
+			"    if c.Less(b, a) {",
+			"      return 1",
+			"    }",
+			"    return 0",
+			"  })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "slicesasyncsort", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use") {
+		t.Fatalf("caller was not marked async for slices.SortFunc:\n%s", text)
+	}
+	if !strings.Contains(text, "await slices.SortFunc") {
+		t.Fatalf("slices.SortFunc call was not awaited:\n%s", text)
+	}
+	if !strings.Contains(text, "$.functionValue(async") {
+		t.Fatalf("SortFunc comparator was not lowered as async:\n%s", text)
+	}
+}
+
 func TestCompilePackagesAwaitsReflectValueCall(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/reflectcallasync\n\ngo 1.25.3\n",

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
@@ -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

@@ -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()