goscript 0.1.0 → 0.1.2

package/compiler/semantic-model.go

@@ -6,6 +6,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"maps"
 	"slices"
 	"strconv"
 	"strings"
@@ -68,35 +69,66 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 			})
 			continue
 		}
-		diagnostics = append(diagnostics, o.buildPackage(model, node, pkg)...)
+		diagnostics = append(diagnostics, o.buildPackage(ctx, model, node, pkg)...)
 	}
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
 
-	o.propagateFunctionAsync(model)
-	o.resolveInterfaceImplementations(model)
-	o.propagateFunctionAsync(model)
+	diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
+	diagnostics = append(diagnostics, o.propagateAsyncFunctionArguments(ctx, model)...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
+	interfaceGraph, interfaceDiagnostics := o.resolveInterfaceImplementationGraph(ctx, model)
+	diagnostics = append(diagnostics, interfaceDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
+	for {
+		asyncCount := semanticAsyncFunctionCount(model)
+		diagnostics = append(diagnostics, o.applyInterfaceAsyncMethods(ctx, model, interfaceGraph)...)
+		if diagnosticsHaveErrors(diagnostics) {
+			return model, diagnostics
+		}
+		diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
+		if diagnosticsHaveErrors(diagnostics) {
+			return model, diagnostics
+		}
+		if semanticAsyncFunctionCount(model) == asyncCount {
+			break
+		}
+	}
 	return model, diagnostics
 }
 
 func newSemanticModel() *SemanticModel {
 	return &SemanticModel{
-		packages:         make(map[string]*semanticPackage),
-		addressTaken:     make(map[types.Object]bool),
-		needsVarRef:      make(map[types.Object]bool),
-		functions:        make(map[*types.Func]*semanticFunction),
-		types:            make(map[*types.Named]*semanticType),
-		values:           make(map[types.Object]*semanticValue),
-		generatedImports: make(map[string]map[string]bool),
+		packages:             make(map[string]*semanticPackage),
+		addressTaken:         make(map[types.Object]bool),
+		needsVarRef:          make(map[types.Object]bool),
+		functions:            make(map[*types.Func]*semanticFunction),
+		functionsByFullName:  make(map[string]*semanticFunction),
+		functionLookupMisses: make(map[*types.Func]bool),
+		types:                make(map[*types.Named]*semanticType),
+		values:               make(map[types.Object]*semanticValue),
+		generatedImports:     make(map[string]map[string]bool),
 	}
 }
 
 func (o *SemanticModelOwner) buildPackage(
+	ctx context.Context,
 	model *SemanticModel,
 	node *PackageGraphNode,
 	pkg *packages.Package,
 ) []Diagnostic {
+	overrideFacts, diagnostics := o.overrideOwner.Facts(ctx)
+	if diagnosticsHaveErrors(diagnostics) {
+		return diagnostics
+	}
 	semPkg := &semanticPackage{
 		pkgPath:          node.PkgPath,
 		name:             node.Name,
@@ -109,9 +141,8 @@ func (o *SemanticModelOwner) buildPackage(
 		o.collectFileDeclarations(model, semPkg, pkg, file)
 		o.collectFileFacts(model, semPkg, pkg, file)
 	}
-	var diagnostics []Diagnostic
 	for _, file := range pkg.Syntax {
-		diagnostics = append(diagnostics, o.collectFunctionFacts(model, pkg, file)...)
+		diagnostics = append(diagnostics, o.collectFunctionFacts(model, pkg, file, overrideFacts)...)
 	}
 	return diagnostics
 }
@@ -150,7 +181,8 @@ func (o *SemanticModelOwner) collectFileDeclarations(
 				continue
 			}
 			position := sourcePos(pkg, typed.Name.Pos())
-			o.addFunction(model, semPkg, fn, position)
+			semFn := o.addFunction(model, semPkg, fn, position)
+			semFn.hasBody = typed.Body != nil
 			semPkg.declarations = append(semPkg.declarations, semanticDeclaration{
 				kind:     "func",
 				name:     typed.Name.Name,
@@ -176,6 +208,7 @@ func (o *SemanticModelOwner) collectGenDecl(
 			}
 			position := sourcePos(pkg, typed.Name.Pos())
 			o.addType(model, semPkg, obj, position, typed.Type)
+			o.recordGeneratedImports(model, semPkg, position.file, pkg.PkgPath, obj.Type())
 			semPkg.declarations = append(semPkg.declarations, semanticDeclaration{
 				kind:     "type",
 				name:     typed.Name.Name,
@@ -221,6 +254,51 @@ func (o *SemanticModelOwner) collectFileFacts(
 ) {
 	ast.Inspect(file, func(node ast.Node) bool {
 		switch typed := node.(type) {
+		case *ast.TypeSpec:
+			o.recordTypeSpec(model, semPkg, pkg, typed)
+		case *ast.Ident:
+			o.addDefinedObject(model, semPkg, pkg, typed)
+		case *ast.UnaryExpr:
+			if typed.Op == token.AND {
+				o.recordAddressTaken(model, pkg, typed.X)
+			}
+		case *ast.SelectorExpr:
+			o.recordPointerReceiverUse(model, pkg, typed)
+		case *ast.TypeAssertExpr:
+			o.recordTypeAssertion(semPkg, pkg, typed)
+		case *ast.ValueSpec:
+			o.recordValueSpecNilFacts(semPkg, pkg, typed)
+			names := make([]ast.Expr, 0, len(typed.Names))
+			for _, name := range typed.Names {
+				names = append(names, name)
+			}
+			o.recordAsyncCompatibleFunctionAssignments(model, pkg, names, typed.Values)
+		case *ast.AssignStmt:
+			o.recordAssignNilFacts(semPkg, pkg, typed)
+			o.recordAsyncCompatibleFunctionAssignments(model, pkg, typed.Lhs, typed.Rhs)
+		case *ast.FuncLit:
+			o.collectFuncLitFacts(model, semPkg, pkg, typed)
+			return false
+		case *ast.CallExpr:
+			o.recordCallSignatureImports(model, semPkg, pkg, typed)
+		}
+		return true
+	})
+}
+
+func (o *SemanticModelOwner) collectFuncLitFacts(
+	model *SemanticModel,
+	semPkg *semanticPackage,
+	pkg *packages.Package,
+	lit *ast.FuncLit,
+) {
+	ast.Inspect(lit.Body, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.FuncLit:
+			o.collectFuncLitFacts(model, semPkg, pkg, typed)
+			return false
+		case *ast.TypeSpec:
+			o.recordTypeSpec(model, semPkg, pkg, typed)
 		case *ast.Ident:
 			o.addDefinedObject(model, semPkg, pkg, typed)
 		case *ast.UnaryExpr:
@@ -233,13 +311,113 @@ func (o *SemanticModelOwner) collectFileFacts(
 			o.recordTypeAssertion(semPkg, pkg, typed)
 		case *ast.ValueSpec:
 			o.recordValueSpecNilFacts(semPkg, pkg, typed)
+			names := make([]ast.Expr, 0, len(typed.Names))
+			for _, name := range typed.Names {
+				names = append(names, name)
+			}
+			o.recordAsyncCompatibleFunctionAssignments(model, pkg, names, typed.Values)
 		case *ast.AssignStmt:
 			o.recordAssignNilFacts(semPkg, pkg, typed)
+			o.recordAsyncCompatibleFunctionAssignments(model, pkg, typed.Lhs, typed.Rhs)
+			for _, lhs := range typed.Lhs {
+				o.recordFuncLitAssignedCapture(model, pkg, lit, lhs)
+			}
+		case *ast.CallExpr:
+			o.recordCallSignatureImports(model, semPkg, pkg, typed)
+		case *ast.IncDecStmt:
+			o.recordFuncLitAssignedCapture(model, pkg, lit, typed.X)
 		}
 		return true
 	})
 }
 
+func (o *SemanticModelOwner) recordTypeSpec(
+	model *SemanticModel,
+	semPkg *semanticPackage,
+	pkg *packages.Package,
+	spec *ast.TypeSpec,
+) {
+	obj, _ := pkg.TypesInfo.Defs[spec.Name].(*types.TypeName)
+	if obj == nil {
+		return
+	}
+	position := sourcePos(pkg, spec.Name.Pos())
+	o.addType(model, semPkg, obj, position, spec.Type)
+	o.recordGeneratedImports(model, semPkg, position.file, pkg.PkgPath, obj.Type())
+}
+
+func (o *SemanticModelOwner) recordFuncLitAssignedCapture(
+	model *SemanticModel,
+	pkg *packages.Package,
+	lit *ast.FuncLit,
+	expr ast.Expr,
+) {
+	ident, ok := ast.Unparen(expr).(*ast.Ident)
+	if !ok {
+		return
+	}
+	obj, _ := pkg.TypesInfo.Uses[ident].(*types.Var)
+	if obj == nil || !obj.Pos().IsValid() {
+		return
+	}
+	if lit.Pos() < obj.Pos() && obj.Pos() < lit.End() {
+		return
+	}
+	if signatureForType(obj.Type()) == nil {
+		return
+	}
+	model.needsVarRef[obj] = true
+}
+
+func (o *SemanticModelOwner) recordCallSignatureImports(
+	model *SemanticModel,
+	semPkg *semanticPackage,
+	pkg *packages.Package,
+	expr *ast.CallExpr,
+) {
+	signature := signatureForType(pkg.TypesInfo.TypeOf(expr.Fun))
+	if signature == nil {
+		return
+	}
+	position := sourcePos(pkg, expr.Pos())
+	o.recordTupleImports(model, semPkg, position.file, pkg.PkgPath, signature.Params(), make(map[types.Type]bool))
+	o.recordTupleImports(model, semPkg, position.file, pkg.PkgPath, signature.Results(), make(map[types.Type]bool))
+}
+
+func (o *SemanticModelOwner) recordAsyncCompatibleFunctionAssignments(
+	model *SemanticModel,
+	pkg *packages.Package,
+	lhs []ast.Expr,
+	rhs []ast.Expr,
+) {
+	for idx, target := range lhs {
+		if idx >= len(rhs) {
+			return
+		}
+		obj := objectForAddress(pkg, target)
+		if obj == nil || signatureForType(obj.Type()) == nil {
+			continue
+		}
+		if !exprMayNeedAwait(model, pkg, rhs[idx]) {
+			continue
+		}
+		if value := model.values[obj]; value != nil {
+			value.asyncCompatibleFunction = true
+		}
+	}
+}
+
+func signatureForType(typ types.Type) *types.Signature {
+	if typ == nil {
+		return nil
+	}
+	if signature, ok := typ.(*types.Signature); ok {
+		return signature
+	}
+	signature, _ := types.Unalias(typ).Underlying().(*types.Signature)
+	return signature
+}
+
 func (o *SemanticModelOwner) recordPointerReceiverUse(
 	model *SemanticModel,
 	pkg *packages.Package,
@@ -306,6 +484,9 @@ func (o *SemanticModelOwner) addType(
 		return nil
 	}
 	if existing := model.types[named]; existing != nil {
+		if typeExpr != nil && len(existing.fields) == 0 {
+			existing.fields = semanticFields(named, typeExpr)
+		}
 		return existing
 	}
 	_, isInterface := named.Underlying().(*types.Interface)
@@ -368,6 +549,21 @@ func (o *SemanticModelOwner) addFunction(
 	if existing := model.functions[fn]; existing != nil {
 		return existing
 	}
+	if origin := fn.Origin(); origin != nil {
+		if existing := model.functions[origin]; existing != nil {
+			model.functions[fn] = existing
+			return existing
+		}
+	}
+	if fullName := fn.FullName(); fullName != "" {
+		if existing := model.functionsByFullName[fullName]; existing != nil {
+			model.functions[fn] = existing
+			if origin := fn.Origin(); origin != nil {
+				model.functions[origin] = existing
+			}
+			return existing
+		}
+	}
 	signature, _ := fn.Type().(*types.Signature)
 	semFn := &semanticFunction{
 		name:      fn.Name(),
@@ -384,6 +580,14 @@ func (o *SemanticModelOwner) addFunction(
 		semFn.receiver = receiverNamedType(recv)
 	}
 	model.functions[fn] = semFn
+	if origin := fn.Origin(); origin != nil {
+		model.functions[origin] = semFn
+	}
+	if fullName := fn.FullName(); fullName != "" {
+		if existing := model.functionsByFullName[fullName]; existing == nil {
+			model.functionsByFullName[fullName] = semFn
+		}
+	}
 	semPkg.functions = append(semPkg.functions, semFn)
 	return semFn
 }
@@ -461,6 +665,7 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	model *SemanticModel,
 	pkg *packages.Package,
 	file *ast.File,
+	overrideFacts *OverrideFacts,
 ) []Diagnostic {
 	var diagnostics []Diagnostic
 	for _, decl := range file.Decls {
@@ -487,19 +692,21 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				}
 			case *ast.CallExpr:
 				if called := calledFunction(pkg, typed.Fun); called != nil {
-					semFn.calls[called] = true
+					semFn.calls[functionOriginOrSelf(called)] = true
 				}
-				async, err := o.isOverrideAsyncCall(pkg, typed.Fun)
-				if err != nil {
-					diagnostics = append(diagnostics, Diagnostic{
-						Severity: DiagnosticSeverityError,
-						Code:     "goscript/overrides:metadata",
-						Message:  "failed to read override metadata",
-						Detail:   err.Error(),
-					})
-					return false
+				if fun, ok := ast.Unparen(typed.Fun).(*ast.FuncLit); ok {
+					recordImmediateFuncLitAsyncFacts(model, pkg, overrideFacts, semFn, fun)
+				}
+				if callUsesFunctionValue(pkg, typed.Fun) {
+					markFunctionAsync(semFn, "function-value-call")
 				}
-				if async {
+				if callUsesFunctionIdentifier(pkg, typed.Fun) {
+					markFunctionAsync(semFn, "function-identifier-call")
+				}
+				if overrideFacts.IsMethodAsync(overrideCallPackage(pkg, typed.Fun), overrideCallMethod(pkg, typed.Fun)) {
+					markFunctionAsync(semFn, "override")
+				}
+				if overrideFacts.IsFunctionAsync(overrideFunctionCallPackage(pkg, typed.Fun), overrideFunctionCallName(pkg, typed.Fun)) {
 					markFunctionAsync(semFn, "override")
 				}
 			}
@@ -509,28 +716,247 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	return diagnostics
 }
 
-func (o *SemanticModelOwner) isOverrideAsyncCall(pkg *packages.Package, expr ast.Expr) (bool, error) {
+func recordImmediateFuncLitAsyncFacts(
+	model *SemanticModel,
+	pkg *packages.Package,
+	overrideFacts *OverrideFacts,
+	semFn *semanticFunction,
+	lit *ast.FuncLit,
+) {
+	if lit == nil || lit.Body == nil {
+		return
+	}
+	ast.Inspect(lit.Body, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.FuncLit:
+			return false
+		case *ast.SendStmt:
+			markFunctionAsync(semFn, "async-function-literal-call")
+		case *ast.SelectStmt:
+			markFunctionAsync(semFn, "async-function-literal-call")
+		case *ast.UnaryExpr:
+			if typed.Op == token.ARROW {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
+		case *ast.CallExpr:
+			called := calledFunction(pkg, typed.Fun)
+			if called != nil {
+				semFn.calls[functionOriginOrSelf(called)] = true
+			}
+			if callUsesFunctionValue(pkg, typed.Fun) {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
+			if callUsesFunctionIdentifier(pkg, typed.Fun) {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
+			if called != nil {
+				calledFn := semanticFunctionFor(model, called)
+				if calledFn != nil && calledFn.async {
+					markFunctionAsync(semFn, "async-function-literal-call")
+				}
+			}
+			if overrideFacts.IsMethodAsync(overrideCallPackage(pkg, typed.Fun), overrideCallMethod(pkg, typed.Fun)) {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
+			if overrideFacts.IsFunctionAsync(overrideFunctionCallPackage(pkg, typed.Fun), overrideFunctionCallName(pkg, typed.Fun)) {
+				markFunctionAsync(semFn, "async-function-literal-call")
+			}
+		}
+		return true
+	})
+}
+
+func (o *SemanticModelOwner) propagateAsyncFunctionArguments(
+	ctx context.Context,
+	model *SemanticModel,
+) []Diagnostic {
+	changed := true
+	for changed {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		changed = false
+		for _, semPkg := range model.packages {
+			if err := ctx.Err(); err != nil {
+				return []Diagnostic{contextCanceledDiagnostic(err)}
+			}
+			pkg := semPkg.source
+			if pkg == nil {
+				continue
+			}
+			for _, file := range pkg.Syntax {
+				if err := ctx.Err(); err != nil {
+					return []Diagnostic{contextCanceledDiagnostic(err)}
+				}
+				var inspectErr error
+				ast.Inspect(file, func(node ast.Node) bool {
+					if inspectErr = ctx.Err(); inspectErr != nil {
+						return false
+					}
+					switch typed := node.(type) {
+					case *ast.CallExpr:
+						called := calledFunction(pkg, typed.Fun)
+						semFn := semanticFunctionFor(model, called)
+						if semFn == nil || !semFn.hasBody {
+							return true
+						}
+						signature, _ := called.Type().(*types.Signature)
+						if callPassesAsyncFunctionArgument(model, pkg, signature, typed.Args) {
+							if markFunctionAsync(semFn, "async-function-argument") {
+								changed = true
+							}
+						}
+					}
+					return true
+				})
+				if inspectErr != nil {
+					return []Diagnostic{contextCanceledDiagnostic(inspectErr)}
+				}
+			}
+		}
+		if changed {
+			if diagnostics := o.propagateFunctionAsync(ctx, model); diagnosticsHaveErrors(diagnostics) {
+				return diagnostics
+			}
+		}
+	}
+	return nil
+}
+
+func overrideCallPackage(pkg *packages.Package, expr ast.Expr) string {
 	selector, ok := expr.(*ast.SelectorExpr)
 	if !ok {
-		return false, nil
+		return ""
 	}
 	selection := pkg.TypesInfo.Selections[selector]
 	if selection == nil {
-		return false, nil
+		return ""
 	}
 	method, _ := selection.Obj().(*types.Func)
 	if method == nil {
-		return false, nil
+		return ""
 	}
-	named := receiverNamedType(selection.Recv())
+	named := selectedReceiverNamedType(pkg, selector, selection)
 	if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
-		return false, nil
+		return ""
+	}
+	return named.Obj().Pkg().Path()
+}
+
+func overrideCallMethod(pkg *packages.Package, expr ast.Expr) string {
+	selector, ok := expr.(*ast.SelectorExpr)
+	if !ok {
+		return ""
+	}
+	selection := pkg.TypesInfo.Selections[selector]
+	if selection == nil {
+		return ""
+	}
+	method, _ := selection.Obj().(*types.Func)
+	if method == nil {
+		return ""
+	}
+	named := selectedReceiverNamedType(pkg, selector, selection)
+	if named == nil || named.Obj() == nil {
+		return ""
+	}
+	return named.Obj().Name() + "." + method.Name()
+}
+
+func selectedReceiverNamedType(pkg *packages.Package, selector *ast.SelectorExpr, selection *types.Selection) *types.Named {
+	if named := promotedReceiverNamedType(selection); named != nil {
+		return named
+	}
+	if named := receiverNamedType(selection.Recv()); named != nil {
+		return named
+	}
+	if pkg == nil || selector == nil {
+		return nil
 	}
-	methodKey := named.Obj().Name() + "." + method.Name()
-	return o.overrideOwner.IsMethodAsync(named.Obj().Pkg().Path(), methodKey)
+	return receiverNamedType(pkg.TypesInfo.TypeOf(selector.X))
+}
+
+func promotedReceiverNamedType(selection *types.Selection) *types.Named {
+	index := selection.Index()
+	if len(index) <= 1 {
+		return nil
+	}
+	typ := selection.Recv()
+	for _, idx := range index[:len(index)-1] {
+		for {
+			if pointer, ok := types.Unalias(typ).(*types.Pointer); ok {
+				typ = pointer.Elem()
+				continue
+			}
+			break
+		}
+		switch underlying := types.Unalias(typ).Underlying().(type) {
+		case *types.Struct:
+			if idx < 0 || idx >= underlying.NumFields() {
+				return nil
+			}
+			typ = underlying.Field(idx).Type()
+		default:
+			return receiverNamedType(typ)
+		}
+	}
+	return receiverNamedType(typ)
+}
+
+func overrideFunctionCallPackage(pkg *packages.Package, expr ast.Expr) string {
+	fn := calledFunction(pkg, expr)
+	if fn == nil || fn.Pkg() == nil {
+		return ""
+	}
+	return fn.Pkg().Path()
+}
+
+func overrideFunctionCallName(pkg *packages.Package, expr ast.Expr) string {
+	fn := calledFunction(pkg, expr)
+	if fn == nil {
+		return ""
+	}
+	return fn.Name()
+}
+
+func semanticFunctionFor(model *SemanticModel, fn *types.Func) *semanticFunction {
+	if model == nil || fn == nil {
+		return nil
+	}
+	if semFn := model.functions[fn]; semFn != nil {
+		return semFn
+	}
+	if origin := fn.Origin(); origin != nil {
+		if semFn := model.functions[origin]; semFn != nil {
+			model.functions[fn] = semFn
+			return semFn
+		}
+	}
+	if fullName := fn.FullName(); fullName != "" {
+		if semFn := model.functionsByFullName[fullName]; semFn != nil {
+			model.functions[fn] = semFn
+			return semFn
+		}
+	}
+	if model.functionLookupMisses[fn] {
+		return nil
+	}
+	model.functionLookupMisses[fn] = true
+	return nil
 }
 
 func calledFunction(pkg *packages.Package, expr ast.Expr) *types.Func {
+	for {
+		switch typed := expr.(type) {
+		case *ast.IndexExpr:
+			expr = typed.X
+		case *ast.IndexListExpr:
+			expr = typed.X
+		default:
+			goto unwrapped
+		}
+	}
+unwrapped:
 	switch typed := expr.(type) {
 	case *ast.Ident:
 		fn, _ := pkg.TypesInfo.Uses[typed].(*types.Func)
@@ -546,6 +972,135 @@ func calledFunction(pkg *packages.Package, expr ast.Expr) *types.Func {
 	return nil
 }
 
+func functionOriginOrSelf(fn *types.Func) *types.Func {
+	if fn == nil {
+		return nil
+	}
+	if origin := fn.Origin(); origin != nil {
+		return origin
+	}
+	return fn
+}
+
+func callUsesFunctionValue(pkg *packages.Package, expr ast.Expr) bool {
+	if signatureForType(pkg.TypesInfo.TypeOf(expr)) == nil {
+		return false
+	}
+	switch typed := expr.(type) {
+	case *ast.CallExpr:
+		return true
+	case *ast.SelectorExpr:
+		selection := pkg.TypesInfo.Selections[typed]
+		if selection != nil {
+			return selection.Kind() == types.FieldVal && signatureForType(selection.Type()) != nil
+		}
+		obj, _ := pkg.TypesInfo.Uses[typed.Sel].(*types.Var)
+		return obj != nil && signatureForType(obj.Type()) != nil
+	case *ast.IndexExpr:
+		if signatureForType(pkg.TypesInfo.TypeOf(typed.X)) != nil {
+			return false
+		}
+		return true
+	case *ast.IndexListExpr:
+		if signatureForType(pkg.TypesInfo.TypeOf(typed.X)) != nil {
+			return false
+		}
+		return true
+	default:
+		return false
+	}
+}
+
+func callUsesFunctionIdentifier(pkg *packages.Package, expr ast.Expr) bool {
+	if signatureForType(pkg.TypesInfo.TypeOf(expr)) == nil {
+		return false
+	}
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return false
+	}
+	obj := pkg.TypesInfo.Uses[ident]
+	if obj == nil {
+		obj = pkg.TypesInfo.Defs[ident]
+	}
+	_, ok = obj.(*types.Var)
+	return ok
+}
+
+func callPassesAsyncFunctionArgument(
+	model *SemanticModel,
+	pkg *packages.Package,
+	signature *types.Signature,
+	args []ast.Expr,
+) bool {
+	if signature == nil || signature.Params() == nil {
+		return false
+	}
+	for idx, arg := range args {
+		paramIdx := idx
+		if signature.Variadic() && idx >= signature.Params().Len()-1 {
+			paramIdx = signature.Params().Len() - 1
+		}
+		if paramIdx < 0 || paramIdx >= signature.Params().Len() {
+			continue
+		}
+		if signatureForType(signature.Params().At(paramIdx).Type()) == nil {
+			continue
+		}
+		if exprMayNeedAwait(model, pkg, arg) {
+			return true
+		}
+	}
+	return false
+}
+
+func exprMayNeedAwait(model *SemanticModel, pkg *packages.Package, expr ast.Expr) bool {
+	if called := calledFunction(pkg, expr); called != nil {
+		semFn := semanticFunctionFor(model, called)
+		return semFn != nil && semFn.async
+	}
+	lit, ok := expr.(*ast.FuncLit)
+	if !ok {
+		return false
+	}
+	needsAwait := false
+	ast.Inspect(lit.Body, func(node ast.Node) bool {
+		if needsAwait {
+			return false
+		}
+		switch typed := node.(type) {
+		case *ast.FuncLit:
+			return false
+		case *ast.SendStmt, *ast.SelectStmt:
+			needsAwait = true
+			return false
+		case *ast.UnaryExpr:
+			if typed.Op == token.ARROW {
+				needsAwait = true
+				return false
+			}
+		case *ast.CallExpr:
+			if callUsesFunctionValue(pkg, typed.Fun) {
+				needsAwait = true
+				return false
+			}
+			if callUsesFunctionIdentifier(pkg, typed.Fun) {
+				needsAwait = true
+				return false
+			}
+			if called := calledFunction(pkg, typed.Fun); called != nil {
+				semFn := semanticFunctionFor(model, called)
+				if semFn != nil && semFn.async {
+					needsAwait = true
+					return false
+				}
+			}
+		}
+		return true
+	})
+	return needsAwait
+}
+
 func receiverNamedType(typ types.Type) *types.Named {
 	for {
 		pointer, ok := typ.(*types.Pointer)
@@ -554,17 +1109,23 @@ func receiverNamedType(typ types.Type) *types.Named {
 		}
 		typ = pointer.Elem()
 	}
-	named, _ := typ.(*types.Named)
+	named, _ := types.Unalias(typ).(*types.Named)
 	return named
 }
 
-func (o *SemanticModelOwner) propagateFunctionAsync(model *SemanticModel) {
+func (o *SemanticModelOwner) propagateFunctionAsync(ctx context.Context, model *SemanticModel) []Diagnostic {
 	changed := true
 	for changed {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
 		changed = false
 		for _, semFn := range model.functions {
+			if err := ctx.Err(); err != nil {
+				return []Diagnostic{contextCanceledDiagnostic(err)}
+			}
 			for called := range semFn.calls {
-				calledFn := model.functions[called]
+				calledFn := semanticFunctionFor(model, called)
 				if calledFn != nil && calledFn.async {
 					if markFunctionAsync(semFn, "call:"+called.FullName()) {
 						changed = true
@@ -573,6 +1134,7 @@ func (o *SemanticModelOwner) propagateFunctionAsync(model *SemanticModel) {
 			}
 		}
 	}
+	return nil
 }
 
 func markFunctionAsync(fn *semanticFunction, reason string) bool {
@@ -588,10 +1150,29 @@ func markFunctionAsync(fn *semanticFunction, reason string) bool {
 	return true
 }
 
-func (o *SemanticModelOwner) resolveInterfaceImplementations(model *SemanticModel) {
+func semanticAsyncFunctionCount(model *SemanticModel) int {
+	if model == nil {
+		return 0
+	}
+	count := 0
+	for _, fn := range model.functions {
+		if fn != nil && fn.async {
+			count++
+		}
+	}
+	return count
+}
+
+func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
+	ctx context.Context,
+	model *SemanticModel,
+) ([]semanticInterfaceImplementationGraphEntry, []Diagnostic) {
 	var interfaces []*types.Named
 	var concretes []*types.Named
 	for named, semType := range model.types {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
 		if semType.isInterface {
 			interfaces = append(interfaces, named)
 			continue
@@ -600,64 +1181,201 @@ func (o *SemanticModelOwner) resolveInterfaceImplementations(model *SemanticMode
 	}
 	sortNamedTypes(interfaces)
 	sortNamedTypes(concretes)
+	methodSets := implementationMethodSets(concretes)
 
+	implementationGraph := make([]semanticInterfaceImplementationGraphEntry, 0)
 	for _, ifaceNamed := range interfaces {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
 		iface, _ := ifaceNamed.Underlying().(*types.Interface)
 		if iface == nil {
 			continue
 		}
 		iface.Complete()
-		for _, concrete := range concretes {
-			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, false)
-			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, true)
+		ifaceMethods := interfaceMethodMap(iface)
+		if len(ifaceMethods) == 0 {
+			continue
+		}
+		for _, methodSet := range methodSets {
+			if err := ctx.Err(); err != nil {
+				return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+			}
+			if implementation, ok := o.interfaceImplementationGraphEntry(methodSet, ifaceNamed, ifaceMethods); ok {
+				implementationGraph = append(implementationGraph, implementation)
+			}
 		}
 	}
+	return implementationGraph, nil
 }
 
-func (o *SemanticModelOwner) addInterfaceImplementation(
+func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
+	ctx context.Context,
 	model *SemanticModel,
-	concrete *types.Named,
-	ifaceNamed *types.Named,
-	iface *types.Interface,
-	pointer bool,
-) {
-	var receiver types.Type = concrete
-	if pointer {
-		receiver = types.NewPointer(concrete)
+	interfaceGraph []semanticInterfaceImplementationGraphEntry,
+) []Diagnostic {
+	model.interfaceImplementations = model.interfaceImplementations[:0]
+	for _, graphEntry := range interfaceGraph {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		implementation := semanticInterfaceImplementation{
+			typ:          graphEntry.typ,
+			iface:        graphEntry.iface,
+			pointer:      graphEntry.pointer,
+			asyncMethods: make(map[string]bool),
+		}
+		for methodName, implMethod := range graphEntry.implMethods {
+			implFn := model.functions[implMethod]
+			if implFn != nil && implFn.async {
+				implementation.asyncMethods[methodName] = true
+				if ifaceFn := model.functions[graphEntry.ifaceMethods[methodName]]; ifaceFn != nil {
+					markFunctionAsync(ifaceFn, "interface-implementation")
+				}
+			}
+		}
+		for methodName, async := range implementation.asyncMethods {
+			if !async {
+				continue
+			}
+			markFunctionAsync(model.functions[graphEntry.implMethods[methodName]], "interface-method")
+		}
+		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
 	}
-	if !types.Implements(receiver, iface) {
-		return
+	return nil
+}
+
+func contextCanceledDiagnostic(err error) Diagnostic {
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/context:canceled",
+		Message:  err.Error(),
 	}
+}
 
-	implementation := semanticInterfaceImplementation{
-		typ:          concrete,
-		iface:        ifaceNamed,
-		pointer:      pointer,
-		asyncMethods: make(map[string]bool),
+func (o *SemanticModelOwner) interfaceImplementationGraphEntry(
+	methodSet semanticImplementationMethodSet,
+	ifaceNamed *types.Named,
+	ifaceMethods map[string]*types.Func,
+) (semanticInterfaceImplementationGraphEntry, bool) {
+	if !implementationHasMethods(methodSet.methods, ifaceMethods) {
+		return semanticInterfaceImplementationGraphEntry{}, false
 	}
-	for ifaceMethod := range iface.Methods() {
-		obj, _, _ := types.LookupFieldOrMethod(receiver, true, concrete.Obj().Pkg(), ifaceMethod.Name())
-		implMethod, _ := obj.(*types.Func)
-		if implMethod == nil {
-			continue
+
+	implementsReceiver := methodSet.receiver
+	implementsIface := types.Type(ifaceNamed.Underlying())
+	if methodSet.typ.TypeParams() != nil && methodSet.typ.TypeParams().Len() != 0 {
+		args := typeParamTypes(methodSet.typ.TypeParams())
+		if instantiated, err := types.Instantiate(nil, methodSet.typ, args, false); err == nil {
+			implementsReceiver = instantiated
+			if methodSet.pointer {
+				implementsReceiver = types.NewPointer(instantiated)
+			}
 		}
-		implFn := model.functions[implMethod]
-		if implFn != nil && implFn.async {
-			implementation.asyncMethods[ifaceMethod.Name()] = true
-			if ifaceFn := model.functions[ifaceMethod]; ifaceFn != nil {
-				markFunctionAsync(ifaceFn, "interface-implementation")
+		if ifaceNamed.TypeParams() != nil && ifaceNamed.TypeParams().Len() == len(args) {
+			if instantiated, err := types.Instantiate(nil, ifaceNamed, args, false); err == nil {
+				implementsIface = instantiated.Underlying()
 			}
 		}
 	}
-	for methodName, async := range implementation.asyncMethods {
-		if !async {
-			continue
+	if !types.Implements(implementsReceiver, implementsIface.Underlying().(*types.Interface)) {
+		return semanticInterfaceImplementationGraphEntry{}, false
+	}
+
+	implementation := semanticInterfaceImplementationGraphEntry{
+		typ:          methodSet.typ,
+		iface:        ifaceNamed,
+		pointer:      methodSet.pointer,
+		ifaceMethods: make(map[string]*types.Func),
+		implMethods:  implementationMethodMap(methodSet.methods, ifaceMethods),
+	}
+	maps.Copy(implementation.ifaceMethods, ifaceMethods)
+	return implementation, true
+}
+
+func interfaceMethodMap(iface *types.Interface) map[string]*types.Func {
+	if iface == nil {
+		return nil
+	}
+	methods := make(map[string]*types.Func)
+	for method := range iface.Methods() {
+		methods[method.Name()] = method
+	}
+	return methods
+}
+
+func implementationMethodSets(concretes []*types.Named) []semanticImplementationMethodSet {
+	methodSets := make([]semanticImplementationMethodSet, 0, len(concretes)*2)
+	for _, concrete := range concretes {
+		methodSets = append(methodSets, semanticImplementationMethodSet{
+			typ:      concrete,
+			receiver: concrete,
+			methods:  methodSetMap(concrete),
+		})
+		pointer := types.NewPointer(concrete)
+		methodSets = append(methodSets, semanticImplementationMethodSet{
+			typ:      concrete,
+			receiver: pointer,
+			pointer:  true,
+			methods:  methodSetMap(pointer),
+		})
+	}
+	return methodSets
+}
+
+func methodSetMap(receiver types.Type) map[string]*types.Func {
+	if receiver == nil {
+		return nil
+	}
+	set := types.NewMethodSet(receiver)
+	if set.Len() == 0 {
+		return nil
+	}
+	methods := make(map[string]*types.Func, set.Len())
+	for method := range set.Methods() {
+		fn, _ := method.Obj().(*types.Func)
+		if fn != nil {
+			methods[fn.Name()] = fn
+		}
+	}
+	return methods
+}
+
+func implementationHasMethods(
+	receiverMethods map[string]*types.Func,
+	ifaceMethods map[string]*types.Func,
+) bool {
+	if len(receiverMethods) == 0 || len(ifaceMethods) == 0 {
+		return false
+	}
+	for methodName := range ifaceMethods {
+		if receiverMethods[methodName] == nil {
+			return false
 		}
-		obj, _, _ := types.LookupFieldOrMethod(receiver, true, concrete.Obj().Pkg(), methodName)
-		implMethod, _ := obj.(*types.Func)
-		markFunctionAsync(model.functions[implMethod], "interface-method")
 	}
-	model.interfaceImplementations = append(model.interfaceImplementations, implementation)
+	return true
+}
+
+func implementationMethodMap(
+	receiverMethods map[string]*types.Func,
+	ifaceMethods map[string]*types.Func,
+) map[string]*types.Func {
+	methods := make(map[string]*types.Func, len(ifaceMethods))
+	for methodName := range ifaceMethods {
+		methods[methodName] = receiverMethods[methodName]
+	}
+	return methods
+}
+
+func typeParamTypes(params *types.TypeParamList) []types.Type {
+	if params == nil {
+		return nil
+	}
+	args := make([]types.Type, 0, params.Len())
+	for tparam := range params.TypeParams() {
+		args = append(args, tparam)
+	}
+	return args
 }
 
 func sortNamedTypes(named []*types.Named) {
@@ -774,6 +1492,18 @@ func isInterfaceType(typ types.Type) bool {
 	return ok
 }
 
+func isNonEmptyInterfaceType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	iface, ok := types.Unalias(typ).Underlying().(*types.Interface)
+	if !ok {
+		return false
+	}
+	iface.Complete()
+	return iface.NumMethods() != 0
+}
+
 func isNilableType(typ types.Type) bool {
 	if typ == nil {
 		return false
@@ -812,6 +1542,19 @@ func (o *SemanticModelOwner) recordTypeImports(
 	}
 	seen[typ] = true
 
+	if alias, ok := typ.(*types.Alias); ok {
+		if obj := alias.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() != currentPkg {
+			addGeneratedImport(model, semPkg, file, obj.Pkg().Path())
+		}
+		if args := alias.TypeArgs(); args != nil {
+			for t := range args.Types() {
+				o.recordTypeImports(model, semPkg, file, currentPkg, t, seen)
+			}
+		}
+		o.recordTypeImports(model, semPkg, file, currentPkg, alias.Rhs(), seen)
+		return
+	}
+
 	switch typed := types.Unalias(typ).(type) {
 	case *types.Named:
 		if obj := typed.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() != currentPkg {
@@ -822,7 +1565,9 @@ func (o *SemanticModelOwner) recordTypeImports(
 				o.recordTypeImports(model, semPkg, file, currentPkg, t, seen)
 			}
 		}
-		o.recordTypeImports(model, semPkg, file, currentPkg, typed.Underlying(), seen)
+		if obj := typed.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == currentPkg {
+			o.recordTypeImports(model, semPkg, file, currentPkg, typed.Underlying(), seen)
+		}
 	case *types.Pointer:
 		o.recordTypeImports(model, semPkg, file, currentPkg, typed.Elem(), seen)
 	case *types.Slice: