goscript 0.2.1 → 0.2.3

package/compiler/gotest/runner.go

@@ -141,6 +141,10 @@ func (r *Runner) runPackageTools(
 	if len(indexes) == 0 {
 		return
 	}
+	if phase := materializeRuntimeModuleShims(req, outputRoots); phase.Failed() {
+		markRuntimeFailures(result, indexes, OwnerTestRunner, phase.Error)
+		return
+	}
 	if len(indexes) == 1 {
 		r.runPackageTypeCheckAndRuntime(ctx, req, workspace, result, outputRoots, indexes[0])
 		return
@@ -286,6 +290,100 @@ func (r *Runner) runPackageRuntimes(
 	r.runPackageRuntimesIndividually(ctx, req, workspace, result, outputRoots, indexes)
 }
 
+func materializeRuntimeModuleShims(req *normalizedRequest, outputRoots []string) tsworkspace.Result {
+	if req.RuntimeBackend != RuntimeBackendBun {
+		return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace}
+	}
+	seen := make(map[string]bool)
+	shimRoots := runtimeModuleShimRoots(req, outputRoots)
+	for _, outputRoot := range outputRoots {
+		if outputRoot == "" {
+			continue
+		}
+		root := filepath.Join(outputRoot, "@goscript")
+		if _, err := os.Stat(root); err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace, Error: errors.Wrap(err, "stat GoScript runtime output root").Error()}
+		}
+		err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if entry.IsDir() || filepath.Ext(path) != ".ts" {
+				return nil
+			}
+			rel, err := filepath.Rel(root, path)
+			if err != nil {
+				return err
+			}
+			shimRel := filepath.Join("node_modules", "@goscript", strings.TrimSuffix(rel, ".ts")+".js")
+			for _, shimRoot := range shimRoots {
+				shimPath := filepath.Join(shimRoot, shimRel)
+				seenKey := shimPath
+				if seen[seenKey] {
+					continue
+				}
+				seen[seenKey] = true
+				shimDir := filepath.Dir(shimPath)
+				importPath, err := filepath.Rel(shimDir, path)
+				if err != nil {
+					return err
+				}
+				importPath = filepath.ToSlash(importPath)
+				if !strings.HasPrefix(importPath, ".") {
+					importPath = "./" + importPath
+				}
+				if err := writeRuntimeModuleShim(shimPath, "export * from "+strconv.Quote(importPath)+"\n"); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+		if err != nil {
+			return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace, Error: errors.Wrap(err, "materialize GoScript runtime module shims").Error()}
+		}
+	}
+	return tsworkspace.Result{Phase: tsworkspace.PhaseWorkspace}
+}
+
+func runtimeModuleShimRoots(req *normalizedRequest, outputRoots []string) []string {
+	seen := make(map[string]bool)
+	var roots []string
+	for _, root := range append([]string{req.WorkDir}, outputRoots...) {
+		if root == "" {
+			continue
+		}
+		clean := filepath.Clean(root)
+		if seen[clean] {
+			continue
+		}
+		seen[clean] = true
+		roots = append(roots, clean)
+	}
+	return roots
+}
+
+func writeRuntimeModuleShim(path string, data string) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	return os.WriteFile(path, []byte(data), 0o644)
+}
+
+func markRuntimeFailures(result *Result, indexes []int, owner Owner, message string) {
+	for _, idx := range indexes {
+		if idx < 0 || idx >= len(result.Packages) {
+			continue
+		}
+		result.Packages[idx].Action = ActionFail
+		result.Packages[idx].Owner = owner
+		result.Packages[idx].Phases.Runtime = PhaseStatusFail
+		result.Packages[idx].Error = message
+	}
+}
+
 func (r *Runner) runPackageRuntimesIndividually(
 	ctx context.Context,
 	req *normalizedRequest,

package/compiler/gotest/runner_test.go

@@ -1629,6 +1629,51 @@ func TestRenderRuntimeTypeScriptProjectDisablesEmit(t *testing.T) {
 	}
 }
 
+func TestMaterializeRuntimeModuleShimsReexportsGeneratedTypeScript(t *testing.T) {
+	workDir := t.TempDir()
+	outputRoot := filepath.Join(workDir, "output")
+	for _, name := range []string{
+		"errors/index.ts",
+		"github.com/s4wave/spacewave/core/plugin/space/config.gs.ts",
+	} {
+		path := filepath.Join(outputRoot, "@goscript", filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatalf("create output parent: %v", err)
+		}
+		if err := os.WriteFile(path, []byte("export const value = 1\n"), 0o644); err != nil {
+			t.Fatalf("write output file: %v", err)
+		}
+	}
+
+	req := &normalizedRequest{
+		WorkDir:        workDir,
+		RuntimeBackend: RuntimeBackendBun,
+	}
+	phase := materializeRuntimeModuleShims(req, []string{outputRoot})
+	if phase.Failed() {
+		t.Fatalf("materialize shims: %s", phase.Error)
+	}
+	for _, root := range []string{workDir, outputRoot} {
+		for _, name := range []string{
+			"errors/index.js",
+			"github.com/s4wave/spacewave/core/plugin/space/config.gs.js",
+		} {
+			path := filepath.Join(root, "node_modules", "@goscript", filepath.FromSlash(name))
+			data, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("read shim %s: %v", name, err)
+			}
+			text := string(data)
+			if !strings.Contains(text, ".ts\"") {
+				t.Fatalf("shim should re-export generated TypeScript: %s", text)
+			}
+			if strings.Contains(text, workDir) {
+				t.Fatalf("shim should use a portable relative import, got: %s", text)
+			}
+		}
+	}
+}
+
 func TestRenderTypeScriptProjectsCanUseIncrementalBuildInfo(t *testing.T) {
 	req := &normalizedRequest{
 		WorkDir:              "/work",

package/compiler/gotest/testdata/browserapi/browserapi_test.go

@@ -3,6 +3,8 @@
 package browserapi
 
 import (
+	"fmt"
+	"os"
 	"syscall/js"
 	"testing"
 )
@@ -18,3 +20,37 @@ func TestBrowserAPI(t *testing.T) {
 		t.Fatalf("div id = %q", got)
 	}
 }
+
+func TestBrowserStderrUsesConsoleLog(t *testing.T) {
+	console := js.Global().Get("console")
+	if console.IsUndefined() || console.IsNull() {
+		t.Fatal("missing browser console")
+	}
+
+	originalLog := console.Get("log")
+	originalError := console.Get("error")
+	calls := make([]string, 0, 1)
+	logFn := js.FuncOf(func(this js.Value, args []js.Value) any {
+		calls = append(calls, "log:"+args[0].String())
+		return nil
+	})
+	errorFn := js.FuncOf(func(this js.Value, args []js.Value) any {
+		calls = append(calls, "error:"+args[0].String())
+		return nil
+	})
+	defer logFn.Release()
+	defer errorFn.Release()
+	defer console.Set("log", originalLog)
+	defer console.Set("error", originalError)
+
+	console.Set("log", logFn)
+	console.Set("error", errorFn)
+
+	if _, err := fmt.Fprintln(os.Stderr, "goscript stderr proof"); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(calls) != 1 || calls[0] != "log:goscript stderr proof" {
+		t.Fatalf("stderr console calls = %#v, want console.log", calls)
+	}
+}

package/compiler/lowering.go

@@ -16,6 +16,8 @@ import (
 	"strconv"
 	"strings"
 	"unicode/utf8"
+
+	"golang.org/x/tools/go/packages"
 )
 
 // LoweringOwner owns conversion from the semantic model to compiler IR.
@@ -2506,6 +2508,14 @@ func (o *LoweringOwner) runtimeMethodSignaturesWithSeen(iface *types.Interface,
 	return "[" + strings.Join(methods, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertSignaturesWithSeen(ctx lowerFileContext, iface *types.Interface, seen map[types.Type]bool) string {
+	methods := make([]string, 0, iface.NumMethods())
+	for method := range iface.Methods() {
+		methods = append(methods, o.runtimeMethodAssertSignature(ctx, method, seen))
+	}
+	return "[" + strings.Join(methods, ", ") + "]"
+}
+
 func (o *LoweringOwner) runtimeMethodSignature(method *types.Func, seen map[types.Type]bool) string {
 	signature, _ := method.Type().(*types.Signature)
 	if signature == nil {
@@ -2516,6 +2526,16 @@ func (o *LoweringOwner) runtimeMethodSignature(method *types.Func, seen map[type
 		", returns: " + o.runtimeMethodReturns(signature.Results(), seen) + " }"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertSignature(ctx lowerFileContext, method *types.Func, seen map[types.Type]bool) string {
+	signature, _ := method.Type().(*types.Signature)
+	if signature == nil {
+		return "{ name: " + strconv.Quote(method.Name()) + ", args: [], returns: [] }"
+	}
+	return "{ name: " + strconv.Quote(method.Name()) +
+		", args: " + o.runtimeMethodAssertArgs(ctx, signature.Params(), seen) +
+		", returns: " + o.runtimeMethodAssertReturns(ctx, signature.Results(), seen) + " }"
+}
+
 func (o *LoweringOwner) runtimeMethodArgs(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -2532,6 +2552,22 @@ func (o *LoweringOwner) runtimeMethodArgs(tuple *types.Tuple, seen map[types.Typ
 	return "[" + strings.Join(args, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertArgs(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	args := make([]string, 0, tuple.Len())
+	for idx := range tuple.Len() {
+		param := tuple.At(idx)
+		name := param.Name()
+		if name == "" {
+			name = "_p" + strconv.Itoa(idx)
+		}
+		args = append(args, "{ name: "+strconv.Quote(name)+", type: "+o.runtimeTypeAssertInfoExprWithSeen(ctx, param.Type(), seen)+" }")
+	}
+	return "[" + strings.Join(args, ", ") + "]"
+}
+
 func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -2548,6 +2584,22 @@ func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.
 	return "[" + strings.Join(results, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertReturns(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	results := make([]string, 0, tuple.Len())
+	for idx := range tuple.Len() {
+		result := tuple.At(idx)
+		name := result.Name()
+		if name == "" {
+			name = "_r" + strconv.Itoa(idx)
+		}
+		results = append(results, "{ name: "+strconv.Quote(name)+", type: "+o.runtimeTypeAssertInfoExprWithSeen(ctx, result.Type(), seen)+" }")
+	}
+	return "[" + strings.Join(results, ", ") + "]"
+}
+
 func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticType) (*loweredStruct, []Diagnostic) {
 	lowered := &loweredStruct{
 		exported:             ctx.topLevel,
@@ -4554,6 +4606,8 @@ func shortDeclNeedsTypeAnnotation(typ types.Type) bool {
 		return true
 	case *types.Slice:
 		return true
+	case *types.Chan:
+		return true
 	default:
 		return false
 	}
@@ -6797,7 +6851,7 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	deferState := &loweredDeferState{}
 	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
-	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
+	if asyncCompatibleParams || funcLiteralUsesAwaitableCall(ctx, lit) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
 	}
 	var params []loweredParam
@@ -6814,7 +6868,7 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	renderNamedResults(&rendered, o.lowerNamedResults(ctx, signature), 1)
 	renderDeferStack(&rendered, deferState, 1)
 	renderStmts(&rendered, body, 1)
-	async := stmtsContainAwait(body) || deferState.async
+	async := bodyCtx.asyncFunction || stmtsContainAwait(body) || deferState.async
 	prefix := ""
 	if async {
 		prefix = "async "
@@ -6837,7 +6891,7 @@ func renderLoweredParams(params []loweredParam) string {
 	return strings.Join(rendered, ", ")
 }
 
-func funcLiteralUsesFunctionIdentifierCall(ctx lowerFileContext, lit *ast.FuncLit) bool {
+func funcLiteralUsesAwaitableCall(ctx lowerFileContext, lit *ast.FuncLit) bool {
 	if lit == nil || lit.Body == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
 	}
@@ -6853,7 +6907,8 @@ func funcLiteralUsesFunctionIdentifierCall(ctx lowerFileContext, lit *ast.FuncLi
 		if !ok {
 			return true
 		}
-		uses = callUsesFunctionIdentifier(ctx.semPkg.source, call.Fun)
+		uses = callUsesFunctionIdentifier(ctx.semPkg.source, call.Fun) ||
+			callUsesInterfaceMethod(ctx.semPkg.source, call.Fun)
 		return !uses
 	})
 	return uses
@@ -7055,15 +7110,16 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 						}
 					}
 				}
+				appendHelper := o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend)
 				if expr.Ellipsis != token.NoPos && len(args) > 1 {
 					last := len(args) - 1
 					spread := args[last]
 					if isStringType(ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[len(expr.Args)-1])) {
 						spread = o.runtimeOwner.QualifiedHelper(RuntimeHelperStringToBytes) + "(" + spread + ")"
 					}
-					args[last] = "...(" + spread + " ?? [])"
+					args[last] = spread
+					appendHelper = o.runtimeOwner.QualifiedHelper(RuntimeHelperAppendSlice)
 				}
-				appendHelper := o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend)
 				if len(args) > 0 && args[0] == "null" {
 					if slice, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Slice); ok {
 						appendHelper += "<" + o.tsTypeFor(ctx, slice.Elem()) + ">"
@@ -7973,6 +8029,13 @@ func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 			methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
 		return call, diagnostics, true
 	}
+	if receiver != nil && receiver.Obj() != nil && receiver.Obj().Pkg() != nil {
+		pkgPath := receiver.Obj().Pkg().Path()
+		if ctx.importPaths[pkgPath] == "" && !o.hasGeneratedImportPackage(ctx.model, pkgPath) {
+			call := receiverExpr + "." + methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
+			return call, diagnostics, true
+		}
+	}
 	if crossPackageUnexportedNamedType(ctx, receiver) {
 		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
 			"<any>(" + receiverExpr + ")." + methodMemberName(selector.Sel.Name) +
@@ -8688,7 +8751,7 @@ func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Exp
 		return value, diagnostics
 	}
 	if ref, diagnostics, ok := o.lowerUnsafeArrayPointerRefExpr(ctx, expr); ok {
-		return ref + ".value", diagnostics
+		return ref + "!.value", diagnostics
 	}
 	if ref, diagnostics, ok := o.lowerUnsafePointerRefExpr(ctx, expr); ok {
 		return ref + ".value", diagnostics
@@ -8925,7 +8988,7 @@ func sameLoweredSourceExpr(ctx lowerFileContext, left ast.Expr, right ast.Expr)
 
 func (o *LoweringOwner) lowerPointerStorageExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
 	if ref, diagnostics, ok := o.lowerUnsafeArrayPointerRefExpr(ctx, expr); ok {
-		return ref + ".value", diagnostics
+		return ref + "!.value", diagnostics
 	}
 	if ref, diagnostics, ok := o.lowerUnsafePointerRefExpr(ctx, expr); ok {
 		return ref + ".value", diagnostics
@@ -9784,12 +9847,61 @@ func (o *LoweringOwner) runtimeTypeInfoExpr(typ types.Type) string {
 }
 
 func (o *LoweringOwner) runtimeTypeAssertInfoExpr(ctx lowerFileContext, typ types.Type) string {
+	return o.runtimeTypeAssertInfoExprWithSeen(ctx, typ, make(map[types.Type]bool))
+}
+
+func (o *LoweringOwner) runtimeTypeAssertInfoExprWithSeen(ctx lowerFileContext, typ types.Type, seen map[types.Type]bool) string {
 	typeParam, ok := types.Unalias(typ).(*types.TypeParam)
-	if !ok || !typeParamInScope(ctx, typeParam) {
+	if ok && typeParamInScope(ctx, typeParam) {
+		return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "]?.type ?? " +
+			o.runtimeTypeInfoExpr(typ)
+	}
+
+	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
+	if typ == nil {
+		return "{ kind: " + typeKind + ".Basic, name: \"unknown\" }"
+	}
+	typeKey := types.Unalias(typ)
+	if typeKey != nil {
+		if seen[typeKey] {
+			return o.shallowRuntimeTypeInfoExpr(typ)
+		}
+		seen[typeKey] = true
+		defer delete(seen, typeKey)
+	}
+	if named := namedFunctionType(typ); named != nil {
+		return o.runtimeFunctionTypeAssertInfoWithSeen(ctx, named.Underlying().(*types.Signature), runtimeNamedTypeName(named), seen)
+	}
+	if named := namedStructType(typ); named != nil {
+		return strconv.Quote(runtimeNamedTypeName(named))
+	}
+	if named := namedNonStructType(typ); named != nil {
+		if basic, ok := types.Unalias(named.Underlying()).(*types.Basic); ok {
+			return runtimeBasicTypeInfoExpr(typeKind, basic, runtimeNamedTypeName(named))
+		}
+		return strconv.Quote(runtimeNamedTypeName(named))
+	}
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Pointer:
+		return "{ kind: " + typeKind + ".Pointer, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Struct:
+		return "{ kind: " + typeKind + ".Struct, methods: [], fields: " + o.runtimeStructAssertFieldsExpr(ctx, typed, seen) + " }"
+	case *types.Slice:
+		return "{ kind: " + typeKind + ".Slice, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Array:
+		return "{ kind: " + typeKind + ".Array, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + ", length: " + strconv.FormatInt(typed.Len(), 10) + " }"
+	case *types.Map:
+		return "{ kind: " + typeKind + ".Map, keyType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Key(), seen) + ", elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Chan:
+		return "{ kind: " + typeKind + ".Channel, direction: " + strconv.Quote(channelDirectionString(typed.Dir())) + ", elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Interface:
+		typed.Complete()
+		return "{ kind: " + typeKind + ".Interface, methods: " + o.runtimeMethodAssertSignaturesWithSeen(ctx, typed, seen) + " }"
+	case *types.Signature:
+		return o.runtimeFunctionTypeAssertInfoWithSeen(ctx, typed, "", seen)
+	default:
 		return o.runtimeTypeInfoExpr(typ)
 	}
-	return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "]?.type ?? " +
-		o.runtimeTypeInfoExpr(typ)
 }
 
 func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[types.Type]bool) string {
@@ -9917,6 +10029,40 @@ func (o *LoweringOwner) runtimeStructFieldsExpr(structType *types.Struct, seen m
 	return "[" + strings.Join(fields, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeStructAssertFieldsExpr(ctx lowerFileContext, structType *types.Struct, seen map[types.Type]bool) string {
+	fields := make([]string, 0, structType.NumFields())
+	var vars []*types.Var
+	for field := range structType.Fields() {
+		vars = append(vars, field)
+	}
+	offsets := structFieldOffsets(goScriptTypeSizes(), vars)
+	for idx := range structType.NumFields() {
+		field := structType.Field(idx)
+		fieldName := tsStructFieldName(field.Name(), idx)
+		runtimeName := ""
+		if fieldName != field.Name() {
+			runtimeName = field.Name()
+		}
+		pkgPath := ""
+		if !field.Exported() && field.Pkg() != nil {
+			pkgPath = field.Pkg().Path()
+		}
+		fieldInfo := runtimeStructFieldInfoExpr(
+			o.runtimeTypeAssertInfoExprWithSeen(ctx, field.Type(), seen),
+			fieldName,
+			runtimeName,
+			structType.Tag(idx),
+			pkgPath,
+			field.Embedded(),
+			[]int{idx},
+			offsets[idx],
+			field.Exported(),
+		)
+		fields = append(fields, fieldInfo)
+	}
+	return "[" + strings.Join(fields, ", ") + "]"
+}
+
 func runtimeStructFieldInfoExpr(
 	runtimeType string,
 	storageKey string,
@@ -9981,6 +10127,26 @@ func (o *LoweringOwner) runtimeFunctionTypeInfoWithSeen(signature *types.Signatu
 	return "({ " + strings.Join(parts, ", ") + " } as " + runtimePackage + ".FunctionTypeInfo)"
 }
 
+func (o *LoweringOwner) runtimeFunctionTypeAssertInfoWithSeen(
+	ctx lowerFileContext,
+	signature *types.Signature,
+	name string,
+	seen map[types.Type]bool,
+) string {
+	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
+	parts := []string{"kind: " + typeKind + ".Function"}
+	if name != "" {
+		parts = append(parts, "name: "+strconv.Quote(name))
+	}
+	parts = append(parts, "params: "+o.runtimeTypeAssertSignatureTypes(ctx, signature.Params(), seen))
+	parts = append(parts, "results: "+o.runtimeTypeAssertSignatureTypes(ctx, signature.Results(), seen))
+	if signature.Variadic() {
+		parts = append(parts, "isVariadic: true")
+	}
+	runtimePackage := strings.TrimSuffix(typeKind, ".TypeKind")
+	return "({ " + strings.Join(parts, ", ") + " } as " + runtimePackage + ".FunctionTypeInfo)"
+}
+
 func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -9992,6 +10158,17 @@ func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types
 	return "[" + strings.Join(types, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeTypeAssertSignatureTypes(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	types := make([]string, 0, tuple.Len())
+	for v := range tuple.Variables() {
+		types = append(types, o.runtimeTypeAssertInfoExprWithSeen(ctx, v.Type(), seen))
+	}
+	return "[" + strings.Join(types, ", ") + "]"
+}
+
 func tsStructFieldName(name string, idx int) string {
 	if name == "_" {
 		return "_blank" + strconv.Itoa(idx)
@@ -10943,6 +11120,7 @@ func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool
 			return o.functionAsync(ctx, calledFunction(ctx.semPkg.source, fun)) ||
 				o.overrideCallNeedsAwait(ctx, fun) ||
 				callUsesFunctionValue(ctx.semPkg.source, fun) ||
+				(ctx.asyncFunction && callUsesInterfaceMethod(ctx.semPkg.source, fun)) ||
 				(ctx.asyncFunction && callUsesFunctionIdentifier(ctx.semPkg.source, fun))
 		}
 		if ctx.semPkg == nil || ctx.semPkg.source == nil {
@@ -10951,10 +11129,48 @@ func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool
 		return o.functionAsync(ctx, calledFunction(ctx.semPkg.source, fun)) ||
 			o.overrideCallNeedsAwait(ctx, fun) ||
 			callUsesFunctionValue(ctx.semPkg.source, fun) ||
+			(ctx.asyncFunction && callUsesInterfaceMethod(ctx.semPkg.source, fun)) ||
 			(ctx.asyncFunction && callUsesFunctionIdentifier(ctx.semPkg.source, fun))
 	}
 }
 
+func callUsesInterfaceMethod(pkg *packages.Package, fun ast.Expr) bool {
+	if pkg == nil {
+		return false
+	}
+	selector, ok := fun.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+	selection := pkg.TypesInfo.Selections[selector]
+	if selection == nil || selection.Kind() != types.MethodVal {
+		return false
+	}
+	if selectionUsesSyncErrorMethod(selection) {
+		return false
+	}
+	return isInterfaceType(selection.Recv())
+}
+
+func selectionUsesSyncErrorMethod(selection *types.Selection) bool {
+	if selection == nil || selection.Kind() != types.MethodVal {
+		return false
+	}
+	method, _ := selection.Obj().(*types.Func)
+	return isSyncErrorMethodFunc(method)
+}
+
+func isSyncErrorMethodFunc(fn *types.Func) bool {
+	if fn == nil || fn.Name() != "Error" {
+		return false
+	}
+	signature, _ := fn.Type().(*types.Signature)
+	if signature == nil || signature.Params().Len() != 0 || signature.Results().Len() != 1 {
+		return false
+	}
+	return types.Identical(signature.Results().At(0).Type(), types.Typ[types.String])
+}
+
 func (o *LoweringOwner) overrideCallNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool {
 	if o.overrideOwner == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false

package/compiler/override-registry_test.go

@@ -488,6 +488,56 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	}
 }
 
+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",