goscript 0.1.3 → 0.2.0

package/compiler/semantic-model.go

@@ -6,7 +6,6 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
-	"maps"
 	"slices"
 	"strconv"
 	"strings"
@@ -75,6 +74,7 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 		return model, diagnostics
 	}
 
+	model.functionCallers = semanticFunctionCallers(model)
 	diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
@@ -83,17 +83,31 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
-	interfaceGraph, interfaceDiagnostics := o.resolveInterfaceImplementationGraph(ctx, model)
+	methodSets, methodSetDiagnostics := o.resolveImplementationMethodSets(ctx, model)
+	diagnostics = append(diagnostics, methodSetDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
+	interfaceGraph, interfaceDiagnostics := o.resolveInterfaceImplementationGraph(ctx, model, methodSets)
 	diagnostics = append(diagnostics, interfaceDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
+	anonymousInterfaceGraph, anonymousInterfaceDiagnostics := o.resolveAnonymousInterfaceImplementationGraph(ctx, model, methodSets)
+	diagnostics = append(diagnostics, anonymousInterfaceDiagnostics...)
+	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.applyAnonymousInterfaceAsyncMethods(ctx, model, anonymousInterfaceGraph)...)
+		if diagnosticsHaveErrors(diagnostics) {
+			return model, diagnostics
+		}
 		diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
 		if diagnosticsHaveErrors(diagnostics) {
 			return model, diagnostics
@@ -107,15 +121,20 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 
 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),
-		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),
+		packages:                 make(map[string]*semanticPackage),
+		addressTaken:             make(map[types.Object]bool),
+		needsVarRef:              make(map[types.Object]bool),
+		functions:                make(map[*types.Func]*semanticFunction),
+		functionCallers:          make(map[*types.Func][]*semanticFunction),
+		functionsByFullName:      make(map[string]*semanticFunction),
+		functionLookupMisses:     make(map[*types.Func]bool),
+		functionFullNames:        make(map[*types.Func]string),
+		types:                    make(map[*types.Named]*semanticType),
+		values:                   make(map[types.Object]*semanticValue),
+		generatedImports:         make(map[string]map[string]bool),
+		generatedImportTypes:     make(map[string]map[types.Type]bool),
+		asyncInterfaceMethods:    make(map[string]bool),
+		asyncInterfaceMethodObjs: make(map[*types.Func]bool),
 	}
 }
 
@@ -207,7 +226,7 @@ func (o *SemanticModelOwner) collectGenDecl(
 				continue
 			}
 			position := sourcePos(pkg, typed.Name.Pos())
-			o.addType(model, semPkg, obj, position, typed.Type)
+			o.addType(model, semPkg, obj, position, typed.Type, pkg.TypesSizes)
 			o.recordGeneratedImports(model, semPkg, position.file, pkg.PkgPath, obj.Type())
 			semPkg.declarations = append(semPkg.declarations, semanticDeclaration{
 				kind:     "type",
@@ -342,7 +361,7 @@ func (o *SemanticModelOwner) recordTypeSpec(
 		return
 	}
 	position := sourcePos(pkg, spec.Name.Pos())
-	o.addType(model, semPkg, obj, position, spec.Type)
+	o.addType(model, semPkg, obj, position, spec.Type, pkg.TypesSizes)
 	o.recordGeneratedImports(model, semPkg, position.file, pkg.PkgPath, obj.Type())
 }
 
@@ -380,8 +399,9 @@ func (o *SemanticModelOwner) recordCallSignatureImports(
 		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))
+	seen := model.generatedImportSeen(position.file)
+	o.recordTupleImports(model, semPkg, position.file, pkg.PkgPath, signature.Params(), seen)
+	o.recordTupleImports(model, semPkg, position.file, pkg.PkgPath, signature.Results(), seen)
 }
 
 func (o *SemanticModelOwner) recordAsyncCompatibleFunctionAssignments(
@@ -466,7 +486,7 @@ func (o *SemanticModelOwner) addDefinedObject(
 		o.addValue(model, semPkg, typed, position, false)
 		o.recordGeneratedImports(model, semPkg, position.file, pkg.PkgPath, typed.Type())
 	case *types.TypeName:
-		o.addType(model, semPkg, typed, sourcePos(pkg, ident.Pos()), nil)
+		o.addType(model, semPkg, typed, sourcePos(pkg, ident.Pos()), nil, pkg.TypesSizes)
 	case *types.Func:
 		o.addFunction(model, semPkg, typed, sourcePos(pkg, ident.Pos()))
 	}
@@ -478,6 +498,7 @@ func (o *SemanticModelOwner) addType(
 	obj *types.TypeName,
 	position sourcePosition,
 	typeExpr ast.Expr,
+	sizes types.Sizes,
 ) *semanticType {
 	named, _ := obj.Type().(*types.Named)
 	if named == nil {
@@ -485,7 +506,7 @@ func (o *SemanticModelOwner) addType(
 	}
 	if existing := model.types[named]; existing != nil {
 		if typeExpr != nil && len(existing.fields) == 0 {
-			existing.fields = semanticFields(named, typeExpr)
+			existing.fields = semanticFields(named, typeExpr, sizes)
 		}
 		return existing
 	}
@@ -494,7 +515,7 @@ func (o *SemanticModelOwner) addType(
 		name:        obj.Name(),
 		named:       named,
 		isInterface: isInterface,
-		fields:      semanticFields(named, typeExpr),
+		fields:      semanticFields(named, typeExpr, sizes),
 		position:    position,
 	}
 	model.types[named] = semType
@@ -555,7 +576,7 @@ func (o *SemanticModelOwner) addFunction(
 			return existing
 		}
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if existing := model.functionsByFullName[fullName]; existing != nil {
 			model.functions[fn] = existing
 			if origin := fn.Origin(); origin != nil {
@@ -583,7 +604,7 @@ func (o *SemanticModelOwner) addFunction(
 	if origin := fn.Origin(); origin != nil {
 		model.functions[origin] = semFn
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if existing := model.functionsByFullName[fullName]; existing == nil {
 			model.functionsByFullName[fullName] = semFn
 		}
@@ -592,7 +613,7 @@ func (o *SemanticModelOwner) addFunction(
 	return semFn
 }
 
-func semanticFields(named *types.Named, typeExpr ast.Expr) []semanticField {
+func semanticFields(named *types.Named, typeExpr ast.Expr, sizes types.Sizes) []semanticField {
 	if named == nil {
 		return nil
 	}
@@ -602,19 +623,64 @@ func semanticFields(named *types.Named, typeExpr ast.Expr) []semanticField {
 	}
 	docs := structFieldDocs(typeExpr)
 	fields := make([]semanticField, 0, structType.NumFields())
+	var vars []*types.Var
+	for field := range structType.Fields() {
+		vars = append(vars, field)
+	}
+	offsets := structFieldOffsets(sizes, vars)
 	for i := range structType.NumFields() {
 		field := structType.Field(i)
+		pkgPath := ""
+		if !field.Exported() && field.Pkg() != nil {
+			pkgPath = field.Pkg().Path()
+		}
 		fields = append(fields, semanticField{
 			name:     field.Name(),
 			typ:      field.Type(),
 			doc:      docs[field.Name()],
 			tag:      structType.Tag(i),
 			embedded: field.Embedded(),
+			pkgPath:  pkgPath,
+			index:    []int{i},
+			offset:   offsets[i],
+			exported: field.Exported(),
 		})
 	}
 	return fields
 }
 
+func goScriptTypeSizes() types.Sizes {
+	if sizes := types.SizesFor("gc", "wasm"); sizes != nil {
+		return sizes
+	}
+	return types.SizesFor("gc", "amd64")
+}
+
+func structFieldOffsets(sizes types.Sizes, fields []*types.Var) (offsets []int64) {
+	offsets = make([]int64, len(fields))
+	if len(fields) == 0 {
+		return offsets
+	}
+	if sizes == nil {
+		sizes = goScriptTypeSizes()
+	}
+	if sizes == nil {
+		return offsets
+	}
+	defer func() {
+		if recover() != nil {
+			// Generic field layouts do not have concrete target offsets during
+			// package-level metadata emission; keep compiling and leave them zero.
+			offsets = make([]int64, len(fields))
+		}
+	}()
+	computed := sizes.Offsetsof(fields)
+	if len(computed) == len(fields) {
+		copy(offsets, computed)
+	}
+	return offsets
+}
+
 func structFieldDocs(typeExpr ast.Expr) map[string]string {
 	structType, _ := typeExpr.(*ast.StructType)
 	if structType == nil || structType.Fields == nil {
@@ -932,7 +998,7 @@ func semanticFunctionFor(model *SemanticModel, fn *types.Func) *semanticFunction
 			return semFn
 		}
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if semFn := model.functionsByFullName[fullName]; semFn != nil {
 			model.functions[fn] = semFn
 			return semFn
@@ -989,6 +1055,8 @@ func callUsesFunctionValue(pkg *packages.Package, expr ast.Expr) bool {
 	switch typed := expr.(type) {
 	case *ast.CallExpr:
 		return true
+	case *ast.TypeAssertExpr:
+		return true
 	case *ast.SelectorExpr:
 		selection := pkg.TypesInfo.Selections[typed]
 		if selection != nil {
@@ -1114,29 +1182,56 @@ func receiverNamedType(typ types.Type) *types.Named {
 }
 
 func (o *SemanticModelOwner) propagateFunctionAsync(ctx context.Context, model *SemanticModel) []Diagnostic {
-	changed := true
-	for changed {
+	if err := ctx.Err(); err != nil {
+		return []Diagnostic{contextCanceledDiagnostic(err)}
+	}
+	queued := make(map[*types.Func]bool)
+	queue := make([]*types.Func, 0)
+	enqueue := func(fn *types.Func) {
+		fn = functionOriginOrSelf(fn)
+		if fn == nil || queued[fn] {
+			return
+		}
+		queued[fn] = true
+		queue = append(queue, fn)
+	}
+	for called := range model.functionCallers {
+		if model.functionAsync(called) {
+			enqueue(called)
+		}
+	}
+	for len(queue) != 0 {
 		if err := ctx.Err(); err != nil {
 			return []Diagnostic{contextCanceledDiagnostic(err)}
 		}
-		changed = false
-		for _, semFn := range model.functions {
+		called := queue[0]
+		queue = queue[1:]
+		for _, semFn := range model.functionCallers[called] {
 			if err := ctx.Err(); err != nil {
 				return []Diagnostic{contextCanceledDiagnostic(err)}
 			}
-			for called := range semFn.calls {
-				calledFn := semanticFunctionFor(model, called)
-				if calledFn != nil && calledFn.async {
-					if markFunctionAsync(semFn, "call:"+called.FullName()) {
-						changed = true
-					}
-				}
+			if markFunctionAsync(semFn, "call:"+model.functionFullName(called)) {
+				enqueue(semFn.function)
 			}
 		}
 	}
 	return nil
 }
 
+func semanticFunctionCallers(model *SemanticModel) map[*types.Func][]*semanticFunction {
+	callers := make(map[*types.Func][]*semanticFunction)
+	for _, semFn := range model.functions {
+		for called := range semFn.calls {
+			called = functionOriginOrSelf(called)
+			if called == nil {
+				continue
+			}
+			callers[called] = append(callers[called], semFn)
+		}
+	}
+	return callers
+}
+
 func markFunctionAsync(fn *semanticFunction, reason string) bool {
 	if fn == nil {
 		return false
@@ -1166,23 +1261,12 @@ func semanticAsyncFunctionCount(model *SemanticModel) int {
 func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 	ctx context.Context,
 	model *SemanticModel,
+	methodSets []semanticImplementationMethodSet,
 ) ([]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
-		}
-		concretes = append(concretes, named)
-	}
+	interfaces := collectInterfaceImplementationCandidates(model)
 	sortNamedTypes(interfaces)
-	sortNamedTypes(concretes)
-	methodSets := implementationMethodSets(concretes)
 
+	methodSetIndexByName := indexImplementationMethodSets(methodSets)
 	implementationGraph := make([]semanticInterfaceImplementationGraphEntry, 0)
 	for _, ifaceNamed := range interfaces {
 		if err := ctx.Err(); err != nil {
@@ -1197,10 +1281,11 @@ func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 		if len(ifaceMethods) == 0 {
 			continue
 		}
-		for _, methodSet := range methodSets {
+		for _, methodSetIdx := range implementationMethodSetCandidates(methodSetIndexByName, ifaceMethods) {
 			if err := ctx.Err(); err != nil {
 				return nil, []Diagnostic{contextCanceledDiagnostic(err)}
 			}
+			methodSet := methodSets[methodSetIdx]
 			if implementation, ok := o.interfaceImplementationGraphEntry(methodSet, ifaceNamed, ifaceMethods); ok {
 				implementationGraph = append(implementationGraph, implementation)
 			}
@@ -1209,42 +1294,447 @@ func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 	return implementationGraph, nil
 }
 
+func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
+	ctx context.Context,
+	model *SemanticModel,
+	methodSets []semanticImplementationMethodSet,
+) ([]semanticAnonymousInterfaceImplementation, []Diagnostic) {
+	interfaces := collectAnonymousInterfaceImplementationCandidates(model)
+	for _, namedIface := range collectNamedInterfaceImplementationCandidates(model) {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		methodSets = append(methodSets, semanticImplementationMethodSet{
+			typ:      namedIface,
+			receiver: namedIface,
+			methods:  methodSetMap(namedIface),
+		})
+	}
+
+	methodSetIndexByName := indexImplementationMethodSets(methodSets)
+	implementationGraph := make([]semanticAnonymousInterfaceImplementation, 0)
+	for _, iface := range interfaces {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		iface.Complete()
+		ifaceMethods := interfaceMethodMap(iface)
+		if len(ifaceMethods) == 0 {
+			continue
+		}
+		for _, methodSetIdx := range implementationMethodSetCandidates(methodSetIndexByName, ifaceMethods) {
+			if err := ctx.Err(); err != nil {
+				return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+			}
+			methodSet := methodSets[methodSetIdx]
+			if !implementationHasMethods(methodSet.methods, ifaceMethods) {
+				continue
+			}
+			if !namedTypeHasParams(methodSet.typ) {
+				if matches, exact := implementationHasExactMethodSignatures(methodSet.methods, ifaceMethods); exact {
+					if !matches {
+						continue
+					}
+					implementationGraph = append(implementationGraph, semanticAnonymousInterfaceImplementation{
+						ifaceMethods: ifaceMethods,
+						implMethods:  methodSet.methods,
+					})
+					continue
+				}
+			}
+			receiver := methodSet.receiver
+			if (methodSet.typ.TypeArgs() == nil || methodSet.typ.TypeArgs().Len() == 0) &&
+				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 {
+					receiver = instantiated
+					if methodSet.pointer {
+						receiver = types.NewPointer(instantiated)
+					}
+				}
+			}
+			if !types.Implements(receiver, iface) {
+				continue
+			}
+			implementationGraph = append(implementationGraph, semanticAnonymousInterfaceImplementation{
+				ifaceMethods: ifaceMethods,
+				implMethods:  methodSet.methods,
+			})
+		}
+	}
+	return implementationGraph, nil
+}
+
+func (o *SemanticModelOwner) resolveImplementationMethodSets(
+	ctx context.Context,
+	model *SemanticModel,
+) ([]semanticImplementationMethodSet, []Diagnostic) {
+	var concretes []*types.Named
+	for named, semType := range model.types {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		if !semType.isInterface {
+			concretes = append(concretes, namedOriginOrSelf(named))
+		}
+	}
+	sortNamedTypes(concretes)
+	return implementationMethodSets(concretes), nil
+}
+
+func collectInterfaceImplementationCandidates(model *SemanticModel) []*types.Named {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[string]bool)
+	var interfaces []*types.Named
+	add := func(named *types.Named) {
+		if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+			return
+		}
+		named = namedOriginOrSelf(named)
+		if _, ok := types.Unalias(named.Underlying()).(*types.Interface); !ok {
+			return
+		}
+		key := named.Obj().Pkg().Path() + "." + named.Obj().Name()
+		if seen[key] {
+			return
+		}
+		seen[key] = true
+		interfaces = append(interfaces, named)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			add(typed)
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectAnonymousInterfaceImplementationCandidates(model *SemanticModel) []*types.Interface {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[*types.Interface]bool)
+	var interfaces []*types.Interface
+	add := func(iface *types.Interface) {
+		if iface == nil || seen[iface] {
+			return
+		}
+		seen[iface] = true
+		interfaces = append(interfaces, iface)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			add(typed)
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectNamedInterfaceImplementationCandidates(model *SemanticModel) []*types.Named {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[string]bool)
+	var interfaces []*types.Named
+	add := func(named *types.Named) {
+		if named == nil {
+			return
+		}
+		if _, ok := types.Unalias(named.Underlying()).(*types.Interface); !ok {
+			return
+		}
+		key := types.TypeString(named, func(pkg *types.Package) string {
+			if pkg == nil {
+				return ""
+			}
+			return pkg.Path()
+		})
+		if seen[key] {
+			return
+		}
+		seen[key] = true
+		interfaces = append(interfaces, named)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			add(typed)
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectTuple(collect func(types.Type), tuple *types.Tuple) {
+	if tuple == nil {
+		return
+	}
+	for v := range tuple.Variables() {
+		collect(v.Type())
+	}
+}
+
 func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 	ctx context.Context,
 	model *SemanticModel,
 	interfaceGraph []semanticInterfaceImplementationGraphEntry,
 ) []Diagnostic {
-	model.interfaceImplementations = model.interfaceImplementations[:0]
+	if cap(model.interfaceImplementations) < len(interfaceGraph) {
+		model.interfaceImplementations = make([]semanticInterfaceImplementation, 0, len(interfaceGraph))
+	} else {
+		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),
+			typ:     graphEntry.typ,
+			iface:   graphEntry.iface,
+			pointer: graphEntry.pointer,
 		}
-		for methodName, implMethod := range graphEntry.implMethods {
-			implFn := model.functions[implMethod]
+		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
+			implMethod := graphEntry.implMethods[methodName]
+			implFn := semanticFunctionFor(model, implMethod)
 			if implFn != nil && implFn.async {
-				implementation.asyncMethods[methodName] = true
-				if ifaceFn := model.functions[graphEntry.ifaceMethods[methodName]]; ifaceFn != nil {
+				model.markInterfaceMethodAsync(ifaceMethod)
+				if ifaceFn := semanticFunctionFor(model, ifaceMethod); ifaceFn != nil {
 					markFunctionAsync(ifaceFn, "interface-implementation")
 				}
+				markFunctionAsync(implFn, "interface-method")
 			}
 		}
-		for methodName, async := range implementation.asyncMethods {
-			if !async {
-				continue
+		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
+	}
+	return nil
+}
+
+func (o *SemanticModelOwner) applyAnonymousInterfaceAsyncMethods(
+	ctx context.Context,
+	model *SemanticModel,
+	interfaceGraph []semanticAnonymousInterfaceImplementation,
+) []Diagnostic {
+	for _, graphEntry := range interfaceGraph {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
+			implMethod := graphEntry.implMethods[methodName]
+			if model.functionAsync(implMethod) {
+				model.markInterfaceMethodAsync(ifaceMethod)
 			}
-			markFunctionAsync(model.functions[graphEntry.implMethods[methodName]], "interface-method")
 		}
-		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
 	}
 	return nil
 }
 
+func (m *SemanticModel) functionAsync(fn *types.Func) bool {
+	semFn := semanticFunctionFor(m, fn)
+	if semFn != nil && semFn.async {
+		return true
+	}
+	return m.interfaceMethodAsync(fn)
+}
+
+func (m *SemanticModel) markInterfaceMethodAsync(fn *types.Func) {
+	if m == nil || fn == nil {
+		return
+	}
+	m.asyncInterfaceMethodObjs[fn] = true
+	key := m.functionFullName(fn)
+	if key != "" {
+		m.asyncInterfaceMethods[key] = true
+	}
+}
+
+func (m *SemanticModel) interfaceMethodAsync(fn *types.Func) bool {
+	if m == nil || fn == nil {
+		return false
+	}
+	if m.asyncInterfaceMethodObjs[fn] {
+		return true
+	}
+	key := m.functionFullName(fn)
+	return key != "" && m.asyncInterfaceMethods[key]
+}
+
 func contextCanceledDiagnostic(err error) Diagnostic {
 	return Diagnostic{
 		Severity: DiagnosticSeverityError,
@@ -1262,6 +1752,22 @@ func (o *SemanticModelOwner) interfaceImplementationGraphEntry(
 		return semanticInterfaceImplementationGraphEntry{}, false
 	}
 
+	if !namedTypeHasParams(methodSet.typ) && !namedTypeHasParams(ifaceNamed) {
+		if matches, exact := implementationHasExactMethodSignatures(methodSet.methods, ifaceMethods); exact {
+			if !matches {
+				return semanticInterfaceImplementationGraphEntry{}, false
+			}
+			implementation := semanticInterfaceImplementationGraphEntry{
+				typ:          methodSet.typ,
+				iface:        ifaceNamed,
+				pointer:      methodSet.pointer,
+				ifaceMethods: ifaceMethods,
+				implMethods:  methodSet.methods,
+			}
+			return implementation, true
+		}
+	}
+
 	implementsReceiver := methodSet.receiver
 	implementsIface := types.Type(ifaceNamed.Underlying())
 	if methodSet.typ.TypeParams() != nil && methodSet.typ.TypeParams().Len() != 0 {
@@ -1286,10 +1792,9 @@ func (o *SemanticModelOwner) interfaceImplementationGraphEntry(
 		typ:          methodSet.typ,
 		iface:        ifaceNamed,
 		pointer:      methodSet.pointer,
-		ifaceMethods: make(map[string]*types.Func),
-		implMethods:  implementationMethodMap(methodSet.methods, ifaceMethods),
+		ifaceMethods: ifaceMethods,
+		implMethods:  methodSet.methods,
 	}
-	maps.Copy(implementation.ifaceMethods, ifaceMethods)
 	return implementation, true
 }
 
@@ -1304,6 +1809,56 @@ func interfaceMethodMap(iface *types.Interface) map[string]*types.Func {
 	return methods
 }
 
+func indexImplementationMethodSets(methodSets []semanticImplementationMethodSet) map[string][]int {
+	index := make(map[string][]int)
+	for methodSetIndex, methodSet := range methodSets {
+		for methodName := range methodSet.methods {
+			index[methodName] = append(index[methodName], methodSetIndex)
+		}
+	}
+	return index
+}
+
+func implementationMethodSetCandidates(
+	index map[string][]int,
+	ifaceMethods map[string]*types.Func,
+) []int {
+	var candidates []int
+	for methodName := range ifaceMethods {
+		methodSets := index[methodName]
+		if len(methodSets) == 0 {
+			return nil
+		}
+		if candidates == nil || len(methodSets) < len(candidates) {
+			candidates = methodSets
+		}
+	}
+	return candidates
+}
+
+func (m *SemanticModel) functionFullName(fn *types.Func) string {
+	if m == nil || fn == nil {
+		return ""
+	}
+	original := fn
+	if fullName, ok := m.functionFullNames[original]; ok {
+		return fullName
+	}
+	if origin := fn.Origin(); origin != nil && origin != fn {
+		if fullName, ok := m.functionFullNames[origin]; ok {
+			m.functionFullNames[original] = fullName
+			return fullName
+		}
+		fn = origin
+	}
+	fullName := fn.FullName()
+	m.functionFullNames[fn] = fullName
+	if original != fn {
+		m.functionFullNames[original] = fullName
+	}
+	return fullName
+}
+
 func implementationMethodSets(concretes []*types.Named) []semanticImplementationMethodSet {
 	methodSets := make([]semanticImplementationMethodSet, 0, len(concretes)*2)
 	for _, concrete := range concretes {
@@ -1356,15 +1911,78 @@ func implementationHasMethods(
 	return true
 }
 
-func implementationMethodMap(
+func implementationHasExactMethodSignatures(
 	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]
+) (bool, bool) {
+	for methodName, ifaceMethod := range ifaceMethods {
+		implMethod := receiverMethods[methodName]
+		if implMethod == nil {
+			return false, true
+		}
+		if !methodPackagesCompatible(implMethod, ifaceMethod) {
+			return false, true
+		}
+		implSignature, _ := implMethod.Type().(*types.Signature)
+		ifaceSignature, _ := ifaceMethod.Type().(*types.Signature)
+		if implSignature == nil || ifaceSignature == nil {
+			return false, false
+		}
+		if !methodSignaturesIdentical(implSignature, ifaceSignature) {
+			return false, true
+		}
 	}
-	return methods
+	return true, true
+}
+
+func methodPackagesCompatible(implMethod *types.Func, ifaceMethod *types.Func) bool {
+	if implMethod == nil || ifaceMethod == nil {
+		return false
+	}
+	if ifaceMethod.Exported() {
+		return true
+	}
+	return packagePathOfObject(implMethod) == packagePathOfObject(ifaceMethod)
+}
+
+func packagePathOfObject(obj types.Object) string {
+	if obj == nil || obj.Pkg() == nil {
+		return ""
+	}
+	return obj.Pkg().Path()
+}
+
+func methodSignaturesIdentical(implSignature *types.Signature, ifaceSignature *types.Signature) bool {
+	if implSignature == nil || ifaceSignature == nil || implSignature.Variadic() != ifaceSignature.Variadic() {
+		return false
+	}
+	return tupleTypesIdentical(implSignature.Params(), ifaceSignature.Params()) &&
+		tupleTypesIdentical(implSignature.Results(), ifaceSignature.Results())
+}
+
+func tupleTypesIdentical(a *types.Tuple, b *types.Tuple) bool {
+	if a == nil || b == nil {
+		return a == b
+	}
+	if a.Len() != b.Len() {
+		return false
+	}
+	for idx := range a.Len() {
+		if !types.IdenticalIgnoreTags(a.At(idx).Type(), b.At(idx).Type()) {
+			return false
+		}
+	}
+	return true
+}
+
+func namedTypeHasParams(named *types.Named) bool {
+	if named == nil {
+		return false
+	}
+	if params := named.TypeParams(); params != nil && params.Len() != 0 {
+		return true
+	}
+	return named.TypeArgs() != nil && named.TypeArgs().Len() != 0
 }
 
 func typeParamTypes(params *types.TypeParamList) []types.Type {
@@ -1378,6 +1996,16 @@ func typeParamTypes(params *types.TypeParamList) []types.Type {
 	return args
 }
 
+func namedOriginOrSelf(named *types.Named) *types.Named {
+	if named == nil {
+		return nil
+	}
+	if origin := named.Origin(); origin != nil {
+		return origin
+	}
+	return named
+}
+
 func sortNamedTypes(named []*types.Named) {
 	slices.SortFunc(named, func(a, b *types.Named) int {
 		return cmp.Compare(namedTypeKey(a), namedTypeKey(b))
@@ -1526,7 +2154,16 @@ func (o *SemanticModelOwner) recordGeneratedImports(
 	if file == "" || typ == nil {
 		return
 	}
-	o.recordTypeImports(model, semPkg, file, currentPkg, typ, make(map[types.Type]bool))
+	o.recordTypeImports(model, semPkg, file, currentPkg, typ, model.generatedImportSeen(file))
+}
+
+func (m *SemanticModel) generatedImportSeen(file string) map[types.Type]bool {
+	seen := m.generatedImportTypes[file]
+	if seen == nil {
+		seen = make(map[types.Type]bool)
+		m.generatedImportTypes[file] = seen
+	}
+	return seen
 }
 
 func (o *SemanticModelOwner) recordTypeImports(