goscript 0.1.0 → 0.1.1

package/compiler/semantic-model.go

@@ -68,35 +68,51 @@ 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
+	}
+	diagnostics = append(diagnostics, o.resolveInterfaceImplementations(ctx, model)...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
+	diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
 	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),
+		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 +125,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 +165,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 +192,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,
@@ -233,13 +250,121 @@ 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)
+		case *ast.FuncLit:
+			o.recordFuncLitAssignedCaptures(model, pkg, typed)
+			return false
+		case *ast.CallExpr:
+			o.recordCallSignatureImports(model, semPkg, pkg, typed)
+		}
+		return true
+	})
+}
+
+func (o *SemanticModelOwner) recordFuncLitAssignedCaptures(
+	model *SemanticModel,
+	pkg *packages.Package,
+	lit *ast.FuncLit,
+) {
+	ast.Inspect(lit.Body, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.FuncLit:
+			o.recordFuncLitAssignedCaptures(model, pkg, typed)
+			return false
+		case *ast.UnaryExpr:
+			if typed.Op == token.AND {
+				o.recordAddressTaken(model, pkg, typed.X)
+			}
+		case *ast.AssignStmt:
+			for _, lhs := range typed.Lhs {
+				o.recordFuncLitAssignedCapture(model, pkg, lit, lhs)
+			}
+		case *ast.IncDecStmt:
+			o.recordFuncLitAssignedCapture(model, pkg, lit, typed.X)
 		}
 		return true
 	})
 }
 
+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,
@@ -368,6 +493,12 @@ 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
+		}
+	}
 	signature, _ := fn.Type().(*types.Signature)
 	semFn := &semanticFunction{
 		name:      fn.Name(),
@@ -384,6 +515,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 +600,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 +627,21 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				}
 			case *ast.CallExpr:
 				if called := calledFunction(pkg, typed.Fun); called != nil {
-					semFn.calls[called] = true
+					semFn.calls[called.Origin()] = 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 && funcLitUsesFunctionIdentifierCall(pkg, fun) {
+					markFunctionAsync(semFn, "async-function-literal-call")
+				}
+				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 +651,187 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	return diagnostics
 }
 
-func (o *SemanticModelOwner) isOverrideAsyncCall(pkg *packages.Package, expr ast.Expr) (bool, error) {
+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
+	}
+	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
 	}
-	methodKey := named.Obj().Name() + "." + method.Name()
-	return o.overrideOwner.IsMethodAsync(named.Obj().Pkg().Path(), methodKey)
+	if semFn := model.functions[fn]; semFn != nil {
+		return semFn
+	}
+	if semFn := model.functions[fn.Origin()]; semFn != nil {
+		return semFn
+	}
+	if semFn := model.functionsByFullName[fn.FullName()]; semFn != nil {
+		return semFn
+	}
+	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 +847,150 @@ func calledFunction(pkg *packages.Package, expr ast.Expr) *types.Func {
 	return nil
 }
 
+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 || selection.Kind() != types.FieldVal {
+			return false
+		}
+		return signatureForType(selection.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 funcLitUsesFunctionIdentifierCall(pkg *packages.Package, lit *ast.FuncLit) bool {
+	if pkg == nil || lit == nil || lit.Body == nil {
+		return false
+	}
+	signature, _ := pkg.TypesInfo.TypeOf(lit).(*types.Signature)
+	if signature == nil || signature.Results() == nil || signature.Results().Len() == 0 {
+		return false
+	}
+	uses := false
+	ast.Inspect(lit.Body, func(node ast.Node) bool {
+		if uses {
+			return false
+		}
+		if nested, ok := node.(*ast.FuncLit); ok && nested != lit {
+			return false
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		uses = callUsesFunctionIdentifier(pkg, call.Fun)
+		return !uses
+	})
+	return uses
+}
+
+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 +999,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 +1024,7 @@ func (o *SemanticModelOwner) propagateFunctionAsync(model *SemanticModel) {
 			}
 		}
 	}
+	return nil
 }
 
 func markFunctionAsync(fn *semanticFunction, reason string) bool {
@@ -588,10 +1040,16 @@ func markFunctionAsync(fn *semanticFunction, reason string) bool {
 	return true
 }
 
-func (o *SemanticModelOwner) resolveInterfaceImplementations(model *SemanticModel) {
+func (o *SemanticModelOwner) resolveInterfaceImplementations(
+	ctx context.Context,
+	model *SemanticModel,
+) []Diagnostic {
 	var interfaces []*types.Named
 	var concretes []*types.Named
 	for named, semType := range model.types {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
 		if semType.isInterface {
 			interfaces = append(interfaces, named)
 			continue
@@ -602,16 +1060,31 @@ func (o *SemanticModelOwner) resolveInterfaceImplementations(model *SemanticMode
 	sortNamedTypes(concretes)
 
 	for _, ifaceNamed := range interfaces {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
 		iface, _ := ifaceNamed.Underlying().(*types.Interface)
 		if iface == nil {
 			continue
 		}
 		iface.Complete()
 		for _, concrete := range concretes {
+			if err := ctx.Err(); err != nil {
+				return []Diagnostic{contextCanceledDiagnostic(err)}
+			}
 			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, false)
 			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, true)
 		}
 	}
+	return nil
+}
+
+func contextCanceledDiagnostic(err error) Diagnostic {
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/context:canceled",
+		Message:  err.Error(),
+	}
 }
 
 func (o *SemanticModelOwner) addInterfaceImplementation(
@@ -774,6 +1247,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 +1297,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 +1320,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: