goscript 0.1.4 → 0.2.1

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,12 +83,17 @@ 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)
+	anonymousInterfaceGraph, anonymousInterfaceDiagnostics := o.resolveAnonymousInterfaceImplementationGraph(ctx, model, methodSets)
 	diagnostics = append(diagnostics, anonymousInterfaceDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
@@ -120,12 +125,14 @@ func newSemanticModel() *SemanticModel {
 		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),
 	}
@@ -219,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",
@@ -354,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())
 }
 
@@ -392,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(
@@ -478,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()))
 	}
@@ -490,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 {
@@ -497,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
 	}
@@ -506,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
@@ -604,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
 	}
@@ -614,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 {
@@ -1128,28 +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 {
-				if model.functionAsync(called) {
-					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
@@ -1179,21 +1261,12 @@ func semanticAsyncFunctionCount(model *SemanticModel) int {
 func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 	ctx context.Context,
 	model *SemanticModel,
+	methodSets []semanticImplementationMethodSet,
 ) ([]semanticInterfaceImplementationGraphEntry, []Diagnostic) {
 	interfaces := collectInterfaceImplementationCandidates(model)
-	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(interfaces)
-	sortNamedTypes(concretes)
-	methodSets := implementationMethodSets(concretes)
 
+	methodSetIndexByName := indexImplementationMethodSets(methodSets)
 	implementationGraph := make([]semanticInterfaceImplementationGraphEntry, 0)
 	for _, ifaceNamed := range interfaces {
 		if err := ctx.Err(); err != nil {
@@ -1208,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)
 			}
@@ -1223,19 +1297,13 @@ func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
 	ctx context.Context,
 	model *SemanticModel,
+	methodSets []semanticImplementationMethodSet,
 ) ([]semanticAnonymousInterfaceImplementation, []Diagnostic) {
 	interfaces := collectAnonymousInterfaceImplementationCandidates(model)
-	var concretes []*types.Named
-	for named, semType := range model.types {
+	for _, namedIface := range collectNamedInterfaceImplementationCandidates(model) {
 		if err := ctx.Err(); err != nil {
 			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
 		}
-		if !semType.isInterface {
-			concretes = append(concretes, namedOriginOrSelf(named))
-		}
-	}
-	methodSets := implementationMethodSets(concretes)
-	for _, namedIface := range collectNamedInterfaceImplementationCandidates(model) {
 		methodSets = append(methodSets, semanticImplementationMethodSet{
 			typ:      namedIface,
 			receiver: namedIface,
@@ -1243,6 +1311,7 @@ func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
 		})
 	}
 
+	methodSetIndexByName := indexImplementationMethodSets(methodSets)
 	implementationGraph := make([]semanticAnonymousInterfaceImplementation, 0)
 	for _, iface := range interfaces {
 		if err := ctx.Err(); err != nil {
@@ -1253,13 +1322,26 @@ func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
 		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 !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 {
@@ -1276,13 +1358,30 @@ func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
 			}
 			implementationGraph = append(implementationGraph, semanticAnonymousInterfaceImplementation{
 				ifaceMethods: ifaceMethods,
-				implMethods:  implementationMethodMap(methodSet.methods, 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
@@ -1557,33 +1656,31 @@ func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 	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 {
+		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
+			implMethod := graphEntry.implMethods[methodName]
 			implFn := semanticFunctionFor(model, implMethod)
 			if implFn != nil && implFn.async {
-				implementation.asyncMethods[methodName] = true
-				model.markInterfaceMethodAsync(graphEntry.ifaceMethods[methodName])
-				if ifaceFn := semanticFunctionFor(model, 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
-			}
-			markFunctionAsync(semanticFunctionFor(model, graphEntry.implMethods[methodName]), "interface-method")
-		}
 		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
 	}
 	return nil
@@ -1598,9 +1695,10 @@ func (o *SemanticModelOwner) applyAnonymousInterfaceAsyncMethods(
 		if err := ctx.Err(); err != nil {
 			return []Diagnostic{contextCanceledDiagnostic(err)}
 		}
-		for methodName, implMethod := range graphEntry.implMethods {
+		for methodName, ifaceMethod := range graphEntry.ifaceMethods {
+			implMethod := graphEntry.implMethods[methodName]
 			if model.functionAsync(implMethod) {
-				model.markInterfaceMethodAsync(graphEntry.ifaceMethods[methodName])
+				model.markInterfaceMethodAsync(ifaceMethod)
 			}
 		}
 	}
@@ -1654,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 {
@@ -1678,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
 }
 
@@ -1696,6 +1809,33 @@ 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 ""
@@ -1771,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 {
@@ -1951,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(