goscript 0.2.2 → 0.2.4

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,
@@ -6795,11 +6847,32 @@ func isLegacyOctalLiteral(value string) bool {
 }
 
 func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (string, bool, []Diagnostic) {
+	return o.lowerFuncLitWithAsyncCalls(ctx, lit, true)
+}
+
+func (o *LoweringOwner) lowerFuncLitForTarget(
+	ctx lowerFileContext,
+	lit *ast.FuncLit,
+	targetType types.Type,
+	allowAsyncOverrideCallback bool,
+) (string, bool, []Diagnostic) {
+	allowAsyncCalls := true
+	if !allowAsyncOverrideCallback && signatureForType(targetType) != nil {
+		allowAsyncCalls = false
+	}
+	return o.lowerFuncLitWithAsyncCalls(ctx, lit, allowAsyncCalls)
+}
+
+func (o *LoweringOwner) lowerFuncLitWithAsyncCalls(
+	ctx lowerFileContext,
+	lit *ast.FuncLit,
+	allowAsyncCalls bool,
+) (string, bool, []Diagnostic) {
 	signature, _ := ctx.semPkg.source.TypesInfo.TypeOf(lit).(*types.Signature)
 	deferState := &loweredDeferState{}
 	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
-	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
+	if allowAsyncCalls && (asyncCompatibleParams || funcLiteralUsesAwaitableCall(ctx, lit)) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
 	}
 	var params []loweredParam
@@ -6816,7 +6889,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 "
@@ -6839,7 +6912,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
 	}
@@ -6855,7 +6928,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
@@ -7057,15 +7131,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()) + ">"
@@ -7222,13 +7297,14 @@ func (o *LoweringOwner) lowerCallArgs(
 	signature *types.Signature,
 ) ([]string, []Diagnostic) {
 	overrideCall := o.callUsesOverridePackage(ctx, expr.Fun)
+	allowAsyncOverrideCallback := !overrideCall || o.overrideCallNeedsAwait(ctx, expr.Fun)
 	if args, diagnostics, ok := o.lowerTupleCallArgs(ctx, expr, signature, overrideCall); ok {
 		return args, diagnostics
 	}
 	if signature != nil && signature.Variadic() && overrideCall && !isBuiltinCallTarget(ctx, expr.Fun) {
 		params := signature.Params()
 		if params == nil || params.Len() == 0 {
-			return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+			return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 		}
 		fixedCount := params.Len() - 1
 		targetType := params.At(fixedCount).Type()
@@ -7238,7 +7314,7 @@ func (o *LoweringOwner) lowerCallArgs(
 		args := make([]string, 0, len(expr.Args))
 		var diagnostics []Diagnostic
 		for idx, arg := range expr.Args {
-			lowered, argDiagnostics := o.lowerExpr(ctx, arg)
+			lowered, argDiagnostics := o.lowerCallArgExpr(ctx, arg, params.At(min(idx, fixedCount)).Type(), allowAsyncOverrideCallback)
 			diagnostics = append(diagnostics, argDiagnostics...)
 			if idx < fixedCount {
 				lowered = o.lowerCallArgForTarget(ctx, arg, params.At(idx).Type(), lowered, overrideCall)
@@ -7255,11 +7331,11 @@ func (o *LoweringOwner) lowerCallArgs(
 	if signature == nil || !signature.Variadic() ||
 		isBuiltinCallTarget(ctx, expr.Fun) ||
 		overrideCall {
-		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 	}
 	params := signature.Params()
 	if params == nil || params.Len() == 0 {
-		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 	}
 
 	fixedCount := params.Len() - 1
@@ -7267,7 +7343,11 @@ func (o *LoweringOwner) lowerCallArgs(
 	var variadicArgs []string
 	var diagnostics []Diagnostic
 	for idx, arg := range expr.Args {
-		lowered, argDiagnostics := o.lowerExpr(ctx, arg)
+		targetType := params.At(fixedCount).Type()
+		if idx < fixedCount {
+			targetType = params.At(idx).Type()
+		}
+		lowered, argDiagnostics := o.lowerCallArgExpr(ctx, arg, targetType, allowAsyncOverrideCallback)
 		diagnostics = append(diagnostics, argDiagnostics...)
 		if idx < fixedCount {
 			lowered = o.lowerCallArgForTarget(ctx, arg, params.At(idx).Type(), lowered, overrideCall)
@@ -7368,6 +7448,7 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	exprs []ast.Expr,
 	signature *types.Signature,
 	overrideCall bool,
+	allowAsyncOverrideCallback bool,
 ) ([]string, []Diagnostic) {
 	var params *types.Tuple
 	if signature != nil {
@@ -7376,7 +7457,11 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	args := make([]string, 0, len(exprs))
 	var diagnostics []Diagnostic
 	for idx, expr := range exprs {
-		lowered, exprDiagnostics := o.lowerExpr(ctx, expr)
+		var targetType types.Type
+		if params != nil && idx < params.Len() {
+			targetType = params.At(idx).Type()
+		}
+		lowered, exprDiagnostics := o.lowerCallArgExpr(ctx, expr, targetType, allowAsyncOverrideCallback)
 		diagnostics = append(diagnostics, exprDiagnostics...)
 		if params != nil && idx < params.Len() {
 			lowered = o.lowerCallArgForTarget(ctx, expr, params.At(idx).Type(), lowered, overrideCall)
@@ -7386,6 +7471,19 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	return args, diagnostics
 }
 
+func (o *LoweringOwner) lowerCallArgExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+	targetType types.Type,
+	overrideCall bool,
+) (string, []Diagnostic) {
+	if lit, ok := ast.Unparen(expr).(*ast.FuncLit); ok && targetType != nil {
+		value, _, diagnostics := o.lowerFuncLitForTarget(ctx, lit, targetType, overrideCall)
+		return value, diagnostics
+	}
+	return o.lowerExpr(ctx, expr)
+}
+
 func (o *LoweringOwner) lowerCallArgForTarget(
 	ctx lowerFileContext,
 	expr ast.Expr,
@@ -7975,6 +8073,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) +
@@ -8329,7 +8434,12 @@ func (o *LoweringOwner) lowerMethodValueClosure(
 	if includeReceiver {
 		args = append([]string{"__receiver"}, args...)
 	}
-	return "((__receiver) => (" + strings.Join(params, ", ") + ") => " + callee + "(" + strings.Join(args, ", ") + "))(" + receiver + ")"
+	closure := "((__receiver) => (" + strings.Join(params, ", ") + ") => " + callee + "(" + strings.Join(args, ", ") + "))(" + receiver + ")"
+	if signature == nil {
+		return closure
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFunctionValue) +
+		"(" + closure + ", " + o.runtimeFunctionTypeInfo(signature, "") + ")"
 }
 
 func (o *LoweringOwner) lowerMethodExpressionClosure(ctx lowerFileContext, selection *types.Selection) string {
@@ -9786,12 +9896,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 {
@@ -9919,6 +10078,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,
@@ -9983,6 +10176,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 "[]"
@@ -9994,6 +10207,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)
@@ -10945,6 +11169,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 {
@@ -10953,10 +11178,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