goscript 0.1.1 → 0.1.3

package/compiler/semantic-model.go

@@ -6,6 +6,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"maps"
 	"slices"
 	"strconv"
 	"strings"
@@ -82,24 +83,39 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
-	diagnostics = append(diagnostics, o.resolveInterfaceImplementations(ctx, model)...)
+	interfaceGraph, interfaceDiagnostics := o.resolveInterfaceImplementationGraph(ctx, model)
+	diagnostics = append(diagnostics, interfaceDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
-	diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
+	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),
-		functionsByFullName: make(map[string]*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),
 	}
 }
 
@@ -238,6 +254,8 @@ 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:
@@ -259,7 +277,7 @@ func (o *SemanticModelOwner) collectFileFacts(
 			o.recordAssignNilFacts(semPkg, pkg, typed)
 			o.recordAsyncCompatibleFunctionAssignments(model, pkg, typed.Lhs, typed.Rhs)
 		case *ast.FuncLit:
-			o.recordFuncLitAssignedCaptures(model, pkg, typed)
+			o.collectFuncLitFacts(model, semPkg, pkg, typed)
 			return false
 		case *ast.CallExpr:
 			o.recordCallSignatureImports(model, semPkg, pkg, typed)
@@ -268,24 +286,44 @@ func (o *SemanticModelOwner) collectFileFacts(
 	})
 }
 
-func (o *SemanticModelOwner) recordFuncLitAssignedCaptures(
+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.recordFuncLitAssignedCaptures(model, pkg, typed)
+			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:
 			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)
 			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)
 		}
@@ -293,6 +331,21 @@ func (o *SemanticModelOwner) recordFuncLitAssignedCaptures(
 	})
 }
 
+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,
@@ -431,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)
@@ -499,6 +555,15 @@ func (o *SemanticModelOwner) addFunction(
 			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(),
@@ -627,10 +692,10 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				}
 			case *ast.CallExpr:
 				if called := calledFunction(pkg, typed.Fun); called != nil {
-					semFn.calls[called.Origin()] = true
+					semFn.calls[functionOriginOrSelf(called)] = true
 				}
-				if fun, ok := ast.Unparen(typed.Fun).(*ast.FuncLit); ok && funcLitUsesFunctionIdentifierCall(pkg, fun) {
-					markFunctionAsync(semFn, "async-function-literal-call")
+				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")
@@ -651,6 +716,56 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	return diagnostics
 }
 
+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,
@@ -811,12 +926,22 @@ func semanticFunctionFor(model *SemanticModel, fn *types.Func) *semanticFunction
 	if semFn := model.functions[fn]; semFn != nil {
 		return semFn
 	}
-	if semFn := model.functions[fn.Origin()]; semFn != nil {
-		return semFn
+	if origin := fn.Origin(); origin != nil {
+		if semFn := model.functions[origin]; semFn != nil {
+			model.functions[fn] = semFn
+			return semFn
+		}
 	}
-	if semFn := model.functionsByFullName[fn.FullName()]; semFn != nil {
-		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
 }
 
@@ -847,6 +972,16 @@ unwrapped:
 	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
@@ -856,10 +991,11 @@ func callUsesFunctionValue(pkg *packages.Package, expr ast.Expr) bool {
 		return true
 	case *ast.SelectorExpr:
 		selection := pkg.TypesInfo.Selections[typed]
-		if selection == nil || selection.Kind() != types.FieldVal {
-			return false
+		if selection != nil {
+			return selection.Kind() == types.FieldVal && signatureForType(selection.Type()) != nil
 		}
-		return 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
@@ -891,32 +1027,6 @@ func callUsesFunctionIdentifier(pkg *packages.Package, expr ast.Expr) bool {
 	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,
@@ -1040,15 +1150,28 @@ func markFunctionAsync(fn *semanticFunction, reason string) bool {
 	return true
 }
 
-func (o *SemanticModelOwner) resolveInterfaceImplementations(
+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,
-) []Diagnostic {
+) ([]semanticInterfaceImplementationGraphEntry, []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)}
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
 		}
 		if semType.isInterface {
 			interfaces = append(interfaces, named)
@@ -1058,23 +1181,66 @@ func (o *SemanticModelOwner) resolveInterfaceImplementations(
 	}
 	sortNamedTypes(interfaces)
 	sortNamedTypes(concretes)
+	methodSets := implementationMethodSets(concretes)
 
+	implementationGraph := make([]semanticInterfaceImplementationGraphEntry, 0)
 	for _, ifaceNamed := range interfaces {
 		if err := ctx.Err(); err != nil {
-			return []Diagnostic{contextCanceledDiagnostic(err)}
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
 		}
 		iface, _ := ifaceNamed.Underlying().(*types.Interface)
 		if iface == nil {
 			continue
 		}
 		iface.Complete()
-		for _, concrete := range concretes {
+		ifaceMethods := interfaceMethodMap(iface)
+		if len(ifaceMethods) == 0 {
+			continue
+		}
+		for _, methodSet := range methodSets {
 			if err := ctx.Err(); err != nil {
-				return []Diagnostic{contextCanceledDiagnostic(err)}
+				return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+			}
+			if implementation, ok := o.interfaceImplementationGraphEntry(methodSet, ifaceNamed, ifaceMethods); ok {
+				implementationGraph = append(implementationGraph, implementation)
+			}
+		}
+	}
+	return implementationGraph, nil
+}
+
+func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
+	ctx context.Context,
+	model *SemanticModel,
+	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
 			}
-			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, false)
-			o.addInterfaceImplementation(model, concrete, ifaceNamed, iface, true)
+			markFunctionAsync(model.functions[graphEntry.implMethods[methodName]], "interface-method")
 		}
+		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
 	}
 	return nil
 }
@@ -1087,50 +1253,129 @@ func contextCanceledDiagnostic(err error) Diagnostic {
 	}
 }
 
-func (o *SemanticModelOwner) addInterfaceImplementation(
-	model *SemanticModel,
-	concrete *types.Named,
+func (o *SemanticModelOwner) interfaceImplementationGraphEntry(
+	methodSet semanticImplementationMethodSet,
 	ifaceNamed *types.Named,
-	iface *types.Interface,
-	pointer bool,
-) {
-	var receiver types.Type = concrete
-	if pointer {
-		receiver = types.NewPointer(concrete)
+	ifaceMethods map[string]*types.Func,
+) (semanticInterfaceImplementationGraphEntry, bool) {
+	if !implementationHasMethods(methodSet.methods, ifaceMethods) {
+		return semanticInterfaceImplementationGraphEntry{}, false
+	}
+
+	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)
+			}
+		}
+		if ifaceNamed.TypeParams() != nil && ifaceNamed.TypeParams().Len() == len(args) {
+			if instantiated, err := types.Instantiate(nil, ifaceNamed, args, false); err == nil {
+				implementsIface = instantiated.Underlying()
+			}
+		}
 	}
-	if !types.Implements(receiver, iface) {
-		return
+	if !types.Implements(implementsReceiver, implementsIface.Underlying().(*types.Interface)) {
+		return semanticInterfaceImplementationGraphEntry{}, false
 	}
 
-	implementation := semanticInterfaceImplementation{
-		typ:          concrete,
+	implementation := semanticInterfaceImplementationGraphEntry{
+		typ:          methodSet.typ,
 		iface:        ifaceNamed,
-		pointer:      pointer,
-		asyncMethods: make(map[string]bool),
+		pointer:      methodSet.pointer,
+		ifaceMethods: make(map[string]*types.Func),
+		implMethods:  implementationMethodMap(methodSet.methods, ifaceMethods),
 	}
-	for ifaceMethod := range iface.Methods() {
-		obj, _, _ := types.LookupFieldOrMethod(receiver, true, concrete.Obj().Pkg(), ifaceMethod.Name())
-		implMethod, _ := obj.(*types.Func)
-		if implMethod == nil {
-			continue
-		}
-		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")
-			}
+	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
 		}
 	}
-	for methodName, async := range implementation.asyncMethods {
-		if !async {
-			continue
+	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) {

package/compiler/semantic-model_test.go

@@ -282,6 +282,38 @@ func TestSemanticModelColorsAsyncFunctionsAndOverrides(t *testing.T) {
 	}
 }
 
+func TestSemanticModelPropagatesCascadedAsyncInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/asynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package asynciface",
+			"type Config interface { Equals(Config) bool }",
+			"type Directive interface { IsEquivalent(Directive) bool }",
+			"type channelConfig struct { ch chan struct{} }",
+			"func (c *channelConfig) Equals(other Config) bool { <-c.ch; return true }",
+			"type execDirective struct { c Config }",
+			"func (d *execDirective) IsEquivalent(other Directive) bool { return d.c.Equals(nil) }",
+			"func Use(d Directive, other Directive) bool { return d.IsEquivalent(other) }",
+			"",
+		}, "\n"),
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	model := buildSemanticModel(t, graph)
+
+	for _, name := range []string{"Equals", "IsEquivalent", "Use"} {
+		fn := requireDefinedFunc(t, graph, "example.test/asynciface", name)
+		if !model.functions[fn].async {
+			t.Fatalf("expected %s to be async, got %#v", name, model.functions[fn])
+		}
+	}
+}
+
 func TestSemanticModelIndexesFunctionsByFullName(t *testing.T) {
 	model := newSemanticModel()
 	semPkg := &semanticPackage{}
@@ -293,7 +325,24 @@ func TestSemanticModelIndexesFunctionsByFullName(t *testing.T) {
 	duplicatePkg := types.NewPackage("example.test/indexed", "indexed")
 	duplicate := types.NewFunc(token.NoPos, duplicatePkg, "Call", signature)
 	if got := semanticFunctionFor(model, duplicate); got != semFn {
-		t.Fatalf("semanticFunctionFor() = %#v, want %#v", got, semFn)
+		t.Fatalf("semanticFunctionFor duplicate before add = %#v, want %#v", got, semFn)
+	}
+	stalePkg := types.NewPackage("example.test/indexed", "indexed")
+	stale := types.NewFunc(token.NoPos, stalePkg, "Call", signature)
+	staleModel := newSemanticModel()
+	if got := semanticFunctionFor(staleModel, stale); got != nil {
+		t.Fatalf("semanticFunctionFor stale before add = %#v, want nil", got)
+	}
+	NewSemanticModelOwner().addFunction(staleModel, &semanticPackage{}, fn, sourcePosition{})
+	if got := semanticFunctionFor(staleModel, stale); got == nil {
+		t.Fatalf("semanticFunctionFor stale miss did not retry full-name lookup")
+	}
+	duplicatePkgEntry := &semanticPackage{}
+	if got := NewSemanticModelOwner().addFunction(model, duplicatePkgEntry, duplicate, sourcePosition{}); got != semFn {
+		t.Fatalf("addFunction duplicate = %#v, want %#v", got, semFn)
+	}
+	if got := semanticFunctionFor(model, duplicate); got != semFn {
+		t.Fatalf("semanticFunctionFor duplicate = %#v, want %#v", got, semFn)
 	}
 }
 

package/compiler/service.go

@@ -1,6 +1,9 @@
 package compiler
 
-import "context"
+import (
+	"context"
+	"slices"
+)
 
 // CompileService owns the v2 compiler pipeline.
 type CompileService struct {
@@ -14,8 +17,8 @@ type CompileService struct {
 }
 
 // NewCompileService creates a compile service with every pipeline owner.
-func NewCompileService() *CompileService {
-	overrideOwner := NewOverrideRegistryOwner()
+func NewCompileService(overrideDirs ...string) *CompileService {
+	overrideOwner := NewOverrideRegistryOwner(overrideDirs...)
 	runtimeOwner := NewRuntimeContractOwner()
 	return &CompileService{
 		requestOwner:  NewCompileRequestOwner(),
@@ -79,6 +82,9 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		result.Diagnostics = diagnostics
 		return result, NewCompileError(diagnostics)
 	}
+	if !slices.Equal(s.overrideOwner.overrideDirs, req.OverrideDirs) {
+		return NewCompileService(req.OverrideDirs...).Compile(ctx, req)
+	}
 
 	graph, graphDiagnostics := s.graphOwner.Load(ctx, req)
 	diagnostics = append(diagnostics, graphDiagnostics...)