goscript 0.0.61 → 0.0.63

package/compiler/analysis.go

@@ -52,6 +52,10 @@ type ShadowingInfo struct {
 	ShadowedVariables map[string]types.Object
 	// TempVariables maps shadowed variable names to temporary variable names
 	TempVariables map[string]string
+	// TypeShadowedVars maps variable names that shadow type names to their renamed identifier
+	// This happens when a variable name matches a type name used in its initialization
+	// e.g., field := field{...} where the variable 'field' shadows the type 'field'
+	TypeShadowedVars map[string]string
 }
 
 // FunctionTypeInfo represents Go function type information for reflection
@@ -141,6 +145,11 @@ type Analysis struct {
 	// FunctionAssignments tracks which function literals are assigned to which variables
 	FunctionAssignments map[types.Object]ast.Node
 
+	// AsyncReturningVars tracks variables whose function type returns async values
+	// This happens when a variable is assigned from a higher-order function (like sync.OnceValue)
+	// that receives an async function literal as an argument
+	AsyncReturningVars map[types.Object]bool
+
 	// NamedBasicTypes tracks types that should be implemented as type aliases with standalone functions
 	// This includes named types with basic underlying types (like uint32, string) that have methods
 	NamedBasicTypes map[types.Type]bool
@@ -156,6 +165,16 @@ type Analysis struct {
 	// MethodAsyncStatus stores the async status of all methods analyzed
 	// This is computed once during analysis and reused during code generation
 	MethodAsyncStatus map[MethodKey]bool
+
+	// ReferencedTypesPerFile tracks which named types are referenced in each file.
+	// This is used to filter synthetic imports to only include packages needed
+	// by types actually used in each specific file, not all types in the package.
+	// Key: file path, Value: set of named types referenced in that file
+	ReferencedTypesPerFile map[string]map[*types.Named]bool
+
+	// SyntheticImportsPerFile stores synthetic imports needed per file.
+	// Key: file path, Value: map of package name to import info
+	SyntheticImportsPerFile map[string]map[string]*fileImport
 }
 
 // PackageAnalysis holds cross-file analysis data for a package
@@ -175,6 +194,14 @@ type PackageAnalysis struct {
 	// TypeCalls maps file names to the types they reference from other files
 	// Key: filename (without .go extension), Value: map[sourceFile][]typeNames
 	TypeCalls map[string]map[string][]string
+
+	// VariableDefs maps file names to the package-level variables defined in that file
+	// Key: filename (without .go extension), Value: list of variable names
+	VariableDefs map[string][]string
+
+	// VariableCalls maps file names to the package-level variables they reference from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]variableNames
+	VariableCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
@@ -184,18 +211,20 @@ func NewAnalysis(allPackages map[string]*packages.Package) *Analysis {
 	}
 
 	return &Analysis{
-		VariableUsage:       make(map[types.Object]*VariableUsageInfo),
-		Imports:             make(map[string]*fileImport),
-		FunctionData:        make(map[types.Object]*FunctionInfo),
-		NodeData:            make(map[ast.Node]*NodeInfo),
-		FuncLitData:         make(map[*ast.FuncLit]*FunctionInfo),
-		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
-		FunctionAssignments: make(map[types.Object]ast.Node),
-		// PackageMetadata removed - using MethodAsyncStatus only
+		VariableUsage:            make(map[types.Object]*VariableUsageInfo),
+		Imports:                  make(map[string]*fileImport),
+		FunctionData:             make(map[types.Object]*FunctionInfo),
+		NodeData:                 make(map[ast.Node]*NodeInfo),
+		FuncLitData:              make(map[*ast.FuncLit]*FunctionInfo),
+		ReflectedFunctions:       make(map[ast.Node]*ReflectedFunctionInfo),
+		FunctionAssignments:      make(map[types.Object]ast.Node),
+		AsyncReturningVars:       make(map[types.Object]bool),
 		NamedBasicTypes:          make(map[types.Type]bool),
 		AllPackages:              allPackages,
-		InterfaceImplementations: make(map[InterfaceMethodKey][]ImplementationInfo),
-		MethodAsyncStatus:        make(map[MethodKey]bool),
+		InterfaceImplementations:  make(map[InterfaceMethodKey][]ImplementationInfo),
+		MethodAsyncStatus:         make(map[MethodKey]bool),
+		ReferencedTypesPerFile:    make(map[string]map[*types.Named]bool),
+		SyntheticImportsPerFile:   make(map[string]map[string]*fileImport),
 	}
 }
 
@@ -206,6 +235,8 @@ func NewPackageAnalysis() *PackageAnalysis {
 		FunctionCalls: make(map[string]map[string][]string),
 		TypeDefs:      make(map[string][]string),
 		TypeCalls:     make(map[string]map[string][]string),
+		VariableDefs:  make(map[string][]string),
+		VariableCalls: make(map[string]map[string][]string),
 	}
 }
 
@@ -313,6 +344,15 @@ func (a *Analysis) IsAsyncFunc(obj types.Object) bool {
 	return false
 }
 
+// IsAsyncReturningVar returns whether the given variable holds a function that returns async values.
+// This is true when the variable is assigned from a higher-order function that receives an async function literal.
+func (a *Analysis) IsAsyncReturningVar(obj types.Object) bool {
+	if obj == nil {
+		return false
+	}
+	return a.AsyncReturningVars[obj]
+}
+
 func (a *Analysis) IsReceiverUsed(obj types.Object) bool {
 	if obj == nil {
 		return false
@@ -459,6 +499,10 @@ type analysisVisitor struct {
 
 	// currentFuncLit tracks the *ast.FuncLit of the function literal we're currently analyzing.
 	currentFuncLit *ast.FuncLit
+
+	// currentFilePath tracks the file path of the file we're currently analyzing.
+	// This is used to track which types are referenced in each file.
+	currentFilePath string
 }
 
 // getOrCreateUsageInfo retrieves or creates the VariableUsageInfo for a given object.
@@ -491,6 +535,18 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		if n.Tok == token.VAR {
 			for _, spec := range n.Specs {
 				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+					// Track type references from variable declarations for synthetic import filtering
+					if valueSpec.Type != nil {
+						if t := v.pkg.TypesInfo.TypeOf(valueSpec.Type); t != nil {
+							v.trackTypeReference(t)
+						}
+					}
+					for _, name := range valueSpec.Names {
+						if obj := v.pkg.TypesInfo.ObjectOf(name); obj != nil {
+							v.trackTypeReference(obj.Type())
+						}
+					}
+
 					// Process each declared variable (LHS)
 					for i, lhsIdent := range valueSpec.Names {
 						if lhsIdent.Name == "_" {
@@ -780,9 +836,30 @@ func (v *analysisVisitor) visitCallExpr(n *ast.CallExpr) ast.Visitor {
 	// Check for implicit address-taking in method calls with pointer receivers
 	v.checkImplicitAddressTaking(n)
 
+	// Check for address-of expressions in function arguments
+	v.checkAddressOfInArguments(n)
+
 	return v
 }
 
+// checkAddressOfInArguments detects when &variable is passed as a function argument.
+// Example: json.Unmarshal(data, &person) where person needs to be marked as NeedsVarRef
+func (v *analysisVisitor) checkAddressOfInArguments(callExpr *ast.CallExpr) {
+	for _, arg := range callExpr.Args {
+		if unaryExpr, ok := arg.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
+			if ident, ok := unaryExpr.X.(*ast.Ident); ok {
+				if obj := v.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+					usageInfo := v.getOrCreateUsageInfo(obj)
+					usageInfo.Destinations = append(usageInfo.Destinations, AssignmentInfo{
+						Object: nil,
+						Type:   AddressOfAssignment,
+					})
+				}
+			}
+		}
+	}
+}
+
 // checkImplicitAddressTaking detects when a method call with a pointer receiver
 // is called on a non-pointer variable, which requires implicit address-taking.
 // Example: var s MySlice; s.Add(10) where Add has receiver *MySlice
@@ -909,9 +986,63 @@ func (v *analysisVisitor) visitAssignStmt(n *ast.AssignStmt) ast.Visitor {
 		}
 	}
 
+	// NOTE: Async-returning variable tracking (trackAsyncReturningVar) is done in a separate pass
+	// after function literals are analyzed for async status. See trackAsyncReturningVarsAllFiles.
+
 	return v
 }
 
+// trackAsyncReturningVar tracks variables that are assigned from higher-order function calls
+// where one of the arguments is an async function literal.
+// Pattern: x := higherOrderFunc(asyncFuncLit)
+// This is needed because when sync.OnceValue(asyncFunc) is called, the result is a function
+// that returns a Promise, and callers of x() need to await the result.
+func (v *analysisVisitor) trackAsyncReturningVar(lhs ast.Expr, rhs ast.Expr) {
+	// LHS must be an identifier
+	lhsIdent, ok := lhs.(*ast.Ident)
+	if !ok {
+		return
+	}
+
+	// RHS must be a call expression
+	callExpr, ok := rhs.(*ast.CallExpr)
+	if !ok {
+		return
+	}
+
+	// The result type of the call must be a function type
+	rhsType := v.pkg.TypesInfo.TypeOf(rhs)
+	if rhsType == nil {
+		return
+	}
+	_, isFunc := rhsType.Underlying().(*types.Signature)
+	if !isFunc {
+		return
+	}
+
+	// Check if any argument is an async function literal
+	// Use containsAsyncOperationsComplete to check the function body directly
+	// rather than relying on the InAsyncContext flag which may not be set yet
+	hasAsyncArg := false
+	for _, arg := range callExpr.Args {
+		if funcLit, ok := arg.(*ast.FuncLit); ok {
+			if funcLit.Body != nil && v.containsAsyncOperationsComplete(funcLit.Body, v.pkg) {
+				hasAsyncArg = true
+				break
+			}
+		}
+	}
+
+	if !hasAsyncArg {
+		return
+	}
+
+	// Mark the LHS variable as returning async values
+	if obj := v.pkg.TypesInfo.ObjectOf(lhsIdent); obj != nil {
+		v.analysis.AsyncReturningVars[obj] = true
+	}
+}
+
 // visitReturnStmt handles return statement analysis
 func (v *analysisVisitor) visitReturnStmt(n *ast.ReturnStmt) ast.Visitor {
 	nodeInfo := v.analysis.ensureNodeData(n)
@@ -940,12 +1071,28 @@ func (v *analysisVisitor) visitDeclStmt(n *ast.DeclStmt) ast.Visitor {
 		// Check if we're inside a function (either FuncDecl or FuncLit)
 		isInsideFunction := v.currentFuncDecl != nil || v.currentFuncLit != nil
 
-		if isInsideFunction {
-			// Mark all specs in this declaration as being inside a function
-			for _, spec := range genDecl.Specs {
+		for _, spec := range genDecl.Specs {
+			if isInsideFunction {
+				// Mark all specs in this declaration as being inside a function
 				nodeInfo := v.analysis.ensureNodeData(spec)
 				nodeInfo.IsInsideFunction = true
 			}
+
+			// Track type references from variable declarations (e.g., var w MyWriter)
+			if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+				// Track explicit type if present
+				if valueSpec.Type != nil {
+					if t := v.pkg.TypesInfo.TypeOf(valueSpec.Type); t != nil {
+						v.trackTypeReference(t)
+					}
+				}
+				// Also track types inferred from values
+				for _, name := range valueSpec.Names {
+					if obj := v.pkg.TypesInfo.ObjectOf(name); obj != nil {
+						v.trackTypeReference(obj.Type())
+					}
+				}
+			}
 		}
 	}
 	return v
@@ -974,6 +1121,9 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 		return v
 	}
 
+	// Track the asserted type for synthetic import filtering
+	v.trackTypeReference(assertedType)
+
 	// Check if the asserted type is an interface
 	interfaceType, isInterface := assertedType.Underlying().(*types.Interface)
 	if !isInterface {
@@ -1011,10 +1161,36 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 	return v
 }
 
+// trackTypeReference records that a named type is referenced in the current file.
+// This is used to filter synthetic imports to only include packages actually needed.
+func (v *analysisVisitor) trackTypeReference(t types.Type) {
+	if t == nil || v.currentFilePath == "" {
+		return
+	}
+	// Unwrap pointers
+	if ptr, ok := t.(*types.Pointer); ok {
+		t = ptr.Elem()
+	}
+	// Track named types per file
+	if named, ok := t.(*types.Named); ok {
+		if v.analysis.ReferencedTypesPerFile[v.currentFilePath] == nil {
+			v.analysis.ReferencedTypesPerFile[v.currentFilePath] = make(map[*types.Named]bool)
+		}
+		v.analysis.ReferencedTypesPerFile[v.currentFilePath][named] = true
+	}
+}
+
 // visitCompositeLit analyzes composite literals for address-of expressions
 // This is important for detecting cases like: arr := []interface{}{value1, &value2}
 // where value2 needs to be marked as NeedsVarRef due to the &value2 usage
 func (v *analysisVisitor) visitCompositeLit(compLit *ast.CompositeLit) ast.Visitor {
+	// Track the type of this composite literal for synthetic import filtering
+	if compLit.Type != nil {
+		if t := v.pkg.TypesInfo.TypeOf(compLit.Type); t != nil {
+			v.trackTypeReference(t)
+		}
+	}
+
 	// Analyze each element of the composite literal
 	for _, elt := range compLit.Elts {
 		// Handle both direct elements and key-value pairs
@@ -1174,7 +1350,11 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	}
 
 	// First pass: analyze all declarations and statements across all files
-	for _, file := range pkg.Syntax {
+	for i, file := range pkg.Syntax {
+		// Set the current file path for per-file type tracking
+		if i < len(pkg.CompiledGoFiles) {
+			visitor.currentFilePath = pkg.CompiledGoFiles[i]
+		}
 		ast.Walk(visitor, file)
 	}
 
@@ -1207,9 +1387,153 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	// Interface implementation async status is now updated on-demand in IsInterfaceMethodAsync
 	visitor.analyzeAllMethodsAsync()
 
+	// Fourth pass: collect imports needed by promoted methods from embedded structs
+	analysis.addImportsForPromotedMethods(pkg)
+
 	return analysis
 }
 
+// addImportsForPromotedMethods scans struct types that are actually referenced in each file
+// and adds imports for any packages referenced by the promoted methods' parameter/return types.
+// This generates per-file synthetic imports to avoid adding unused imports.
+func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
+	// Process each file's referenced types separately
+	for filePath, referencedTypes := range a.ReferencedTypesPerFile {
+		// Collect package imports needed for this specific file
+		packagesToAdd := make(map[string]*types.Package)
+
+		// Only process types that are actually referenced in this file
+		// and are defined in the current package
+		for namedType := range referencedTypes {
+			// Skip types from other packages - we only need to process types defined in this package
+			if namedType.Obj().Pkg() != pkg.Types {
+				continue
+			}
+
+			// Check if it's a struct
+			structType, ok := namedType.Underlying().(*types.Struct)
+			if !ok {
+				continue
+			}
+
+			// Look for embedded fields
+			for i := 0; i < structType.NumFields(); i++ {
+				field := structType.Field(i)
+				if !field.Embedded() {
+					continue
+				}
+
+				// Get the type of the embedded field
+				embeddedType := field.Type()
+
+				// Handle pointer to embedded type
+				if ptr, ok := embeddedType.(*types.Pointer); ok {
+					embeddedType = ptr.Elem()
+				}
+
+				// Use method set to get all promoted methods including pointer receiver methods
+				// This matches Go's behavior where embedding T promotes both T and *T methods
+				methodSetType := embeddedType
+				if _, isPtr := embeddedType.(*types.Pointer); !isPtr {
+					if _, isInterface := embeddedType.Underlying().(*types.Interface); !isInterface {
+						methodSetType = types.NewPointer(embeddedType)
+					}
+				}
+				embeddedMethodSet := types.NewMethodSet(methodSetType)
+
+				// Scan all methods in the method set
+				for j := 0; j < embeddedMethodSet.Len(); j++ {
+					selection := embeddedMethodSet.At(j)
+					method := selection.Obj()
+					sig, ok := method.Type().(*types.Signature)
+					if !ok {
+						continue
+					}
+
+					// Scan parameters
+					if sig.Params() != nil {
+						for k := 0; k < sig.Params().Len(); k++ {
+							param := sig.Params().At(k)
+							a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
+						}
+					}
+
+					// Scan results
+					if sig.Results() != nil {
+						for k := 0; k < sig.Results().Len(); k++ {
+							result := sig.Results().At(k)
+							a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
+						}
+					}
+				}
+			}
+		}
+
+		// Store the synthetic imports for this file
+		if len(packagesToAdd) > 0 {
+			fileImports := make(map[string]*fileImport)
+			for pkgName, pkgObj := range packagesToAdd {
+				tsImportPath := "@goscript/" + pkgObj.Path()
+				fileImports[pkgName] = &fileImport{
+					importPath: tsImportPath,
+					importVars: make(map[string]struct{}),
+				}
+			}
+			a.SyntheticImportsPerFile[filePath] = fileImports
+		}
+	}
+}
+
+// collectPackageFromType recursively collects packages referenced by a type.
+func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Package, packagesToAdd map[string]*types.Package) {
+	switch typ := t.(type) {
+	case *types.Named:
+		pkg := typ.Obj().Pkg()
+		if pkg != nil && pkg != currentPkg {
+			packagesToAdd[pkg.Name()] = pkg
+		}
+		// Check type arguments for generics
+		if typ.TypeArgs() != nil {
+			for i := 0; i < typ.TypeArgs().Len(); i++ {
+				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
+			}
+		}
+	case *types.Interface:
+		// For interfaces, we need to check embedded interfaces and method signatures
+		for i := 0; i < typ.NumEmbeddeds(); i++ {
+			a.collectPackageFromType(typ.EmbeddedType(i), currentPkg, packagesToAdd)
+		}
+		for i := 0; i < typ.NumExplicitMethods(); i++ {
+			method := typ.ExplicitMethod(i)
+			a.collectPackageFromType(method.Type(), currentPkg, packagesToAdd)
+		}
+	case *types.Pointer:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Slice:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Array:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Map:
+		a.collectPackageFromType(typ.Key(), currentPkg, packagesToAdd)
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Chan:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Signature:
+		// Collect from parameters
+		if typ.Params() != nil {
+			for i := 0; i < typ.Params().Len(); i++ {
+				a.collectPackageFromType(typ.Params().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+		// Collect from results
+		if typ.Results() != nil {
+			for i := 0; i < typ.Results().Len(); i++ {
+				a.collectPackageFromType(typ.Results().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+	}
+}
+
 // AnalyzePackageImports performs package-level analysis to collect function definitions
 // and calls across all files in the package for auto-import generation
 func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
@@ -1221,19 +1545,50 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
 
 		var functions []string
-		var types []string
+		var typeNames []string
+		var variables []string
 		for _, decl := range syntax.Decls {
 			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
-				// Only collect top-level functions (not methods)
+				// Collect top-level functions (not methods)
 				if funcDecl.Recv == nil {
 					functions = append(functions, funcDecl.Name.Name)
+				} else {
+					// Check if this is a method on a wrapper type (named basic type)
+					// If so, it will be compiled as TypeName_MethodName function
+					if len(funcDecl.Recv.List) > 0 {
+						recvType := funcDecl.Recv.List[0].Type
+						// Handle pointer receiver (*Type)
+						if starExpr, ok := recvType.(*ast.StarExpr); ok {
+							recvType = starExpr.X
+						}
+						if recvIdent, ok := recvType.(*ast.Ident); ok {
+							// Check if this receiver type is a wrapper type
+							if obj := pkg.TypesInfo.Uses[recvIdent]; obj != nil {
+								if typeName, ok := obj.(*types.TypeName); ok {
+									if namedType, ok := typeName.Type().(*types.Named); ok {
+										if _, ok := namedType.Underlying().(*types.Basic); ok {
+											// This is a method on a wrapper type
+											funcName := recvIdent.Name + "_" + funcDecl.Name.Name
+											functions = append(functions, funcName)
+										}
+									}
+								}
+							}
+						}
+					}
 				}
 			}
 			if genDecl, ok := decl.(*ast.GenDecl); ok {
 				// Collect type declarations
 				for _, spec := range genDecl.Specs {
 					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
-						types = append(types, typeSpec.Name.Name)
+						typeNames = append(typeNames, typeSpec.Name.Name)
+					}
+					// Collect variable/constant declarations
+					if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+						for _, name := range valueSpec.Names {
+							variables = append(variables, name.Name)
+						}
 					}
 				}
 			}
@@ -1242,8 +1597,11 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		if len(functions) > 0 {
 			analysis.FunctionDefs[baseFileName] = functions
 		}
-		if len(types) > 0 {
-			analysis.TypeDefs[baseFileName] = types
+		if len(typeNames) > 0 {
+			analysis.TypeDefs[baseFileName] = typeNames
+		}
+		if len(variables) > 0 {
+			analysis.VariableDefs[baseFileName] = variables
 		}
 	}
 
@@ -1343,6 +1701,172 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		}
 	}
 
+	// Fourth pass: analyze variable references and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all variable references in this file
+		varRefsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			// Look for identifier references
+			if ident, ok := n.(*ast.Ident); ok {
+				// Check if this identifier refers to a package-level variable
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					if varObj, ok := obj.(*types.Var); ok {
+						// Only track package-level variables (not function parameters or local vars)
+						if varObj.Parent() == pkg.Types.Scope() {
+							varName := ident.Name
+
+							// Check if this variable is defined in the current file
+							currentFileVars := analysis.VariableDefs[baseFileName]
+							isDefinedInCurrentFile := slices.Contains(currentFileVars, varName)
+
+							// If not defined in current file, find which file defines it
+							if !isDefinedInCurrentFile {
+								for sourceFile, vars := range analysis.VariableDefs {
+									if sourceFile == baseFileName {
+										continue // Skip current file
+									}
+									if slices.Contains(vars, varName) {
+										// Found the variable in another file
+										if varRefsFromOtherFiles[sourceFile] == nil {
+											varRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := slices.Contains(varRefsFromOtherFiles[sourceFile], varName)
+										if !found {
+											varRefsFromOtherFiles[sourceFile] = append(varRefsFromOtherFiles[sourceFile], varName)
+										}
+									}
+								}
+							}
+						}
+					}
+					// Also check for constants
+					if constObj, ok := obj.(*types.Const); ok {
+						// Only track package-level constants
+						if constObj.Parent() == pkg.Types.Scope() {
+							constName := ident.Name
+
+							// Check if this constant is defined in the current file
+							currentFileVars := analysis.VariableDefs[baseFileName]
+							isDefinedInCurrentFile := slices.Contains(currentFileVars, constName)
+
+							// If not defined in current file, find which file defines it
+							if !isDefinedInCurrentFile {
+								for sourceFile, vars := range analysis.VariableDefs {
+									if sourceFile == baseFileName {
+										continue // Skip current file
+									}
+									if slices.Contains(vars, constName) {
+										// Found the constant in another file
+										if varRefsFromOtherFiles[sourceFile] == nil {
+											varRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := slices.Contains(varRefsFromOtherFiles[sourceFile], constName)
+										if !found {
+											varRefsFromOtherFiles[sourceFile] = append(varRefsFromOtherFiles[sourceFile], constName)
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(varRefsFromOtherFiles) > 0 {
+			analysis.VariableCalls[baseFileName] = varRefsFromOtherFiles
+		}
+	}
+
+	// Fifth pass: analyze method calls on wrapper types (named basic types with methods)
+	// These generate TypeName_MethodName function calls that need to be imported
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all method calls on wrapper types in this file
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			callExpr, ok := n.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+
+			// Check if this is a method call (selector expression)
+			selectorExpr, ok := callExpr.Fun.(*ast.SelectorExpr)
+			if !ok {
+				return true
+			}
+
+			// Get the type of the receiver
+			receiverType := pkg.TypesInfo.TypeOf(selectorExpr.X)
+			if receiverType == nil {
+				return true
+			}
+
+			// Check if this is a wrapper type (named type with basic underlying type and methods)
+			namedType, ok := receiverType.(*types.Named)
+			if !ok {
+				return true
+			}
+
+			// Check if it has a basic underlying type
+			if _, ok := namedType.Underlying().(*types.Basic); !ok {
+				return true
+			}
+
+			// Check if this type is defined in the same package
+			obj := namedType.Obj()
+			if obj == nil || obj.Pkg() == nil || obj.Pkg() != pkg.Types {
+				return true // Not from this package
+			}
+
+			// Check if this type has the method being called
+			methodName := selectorExpr.Sel.Name
+			found := false
+			for j := 0; j < namedType.NumMethods(); j++ {
+				if namedType.Method(j).Name() == methodName {
+					found = true
+					break
+				}
+			}
+			if !found {
+				return true
+			}
+
+			// Generate the function name: TypeName_MethodName
+			funcName := obj.Name() + "_" + methodName
+
+			// Find which file defines this function
+			for sourceFile, funcs := range analysis.FunctionDefs {
+				if sourceFile == baseFileName {
+					continue // Skip current file
+				}
+				if slices.Contains(funcs, funcName) {
+					// Found the function in another file
+					if analysis.FunctionCalls[baseFileName] == nil {
+						analysis.FunctionCalls[baseFileName] = make(map[string][]string)
+					}
+					if analysis.FunctionCalls[baseFileName][sourceFile] == nil {
+						analysis.FunctionCalls[baseFileName][sourceFile] = []string{}
+					}
+					// Check if already added to avoid duplicates
+					if !slices.Contains(analysis.FunctionCalls[baseFileName][sourceFile], funcName) {
+						analysis.FunctionCalls[baseFileName][sourceFile] = append(analysis.FunctionCalls[baseFileName][sourceFile], funcName)
+					}
+				}
+			}
+
+			return true
+		})
+	}
+
 	return analysis
 }
 
@@ -1546,6 +2070,7 @@ func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *S
 	shadowingInfo := &ShadowingInfo{
 		ShadowedVariables: make(map[string]types.Object),
 		TempVariables:     make(map[string]string),
+		TypeShadowedVars:  make(map[string]string),
 	}
 
 	hasShadowing := false
@@ -1563,12 +2088,60 @@ func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *S
 		v.findVariableUsageInExpr(rhsExpr, lhsVarNames, shadowingInfo, &hasShadowing)
 	}
 
+	// Check for type shadowing: variable name matches a type name used in its initialization
+	// e.g., field := field{...} where the variable 'field' shadows the type 'field'
+	if assignStmt.Tok == token.DEFINE {
+		for i, lhsExpr := range assignStmt.Lhs {
+			if i < len(assignStmt.Rhs) {
+				if lhsIdent, ok := lhsExpr.(*ast.Ident); ok && lhsIdent.Name != "_" {
+					if typeName := v.findTypeShadowing(lhsIdent.Name, assignStmt.Rhs[i]); typeName != "" {
+						shadowingInfo.TypeShadowedVars[lhsIdent.Name] = lhsIdent.Name + "_"
+						hasShadowing = true
+					}
+				}
+			}
+		}
+	}
+
 	if hasShadowing {
 		return shadowingInfo
 	}
 	return nil
 }
 
+// findTypeShadowing checks if the given variable name matches a type name used in the RHS expression.
+// Returns the type name if shadowing is detected, empty string otherwise.
+func (v *analysisVisitor) findTypeShadowing(varName string, rhsExpr ast.Expr) string {
+	// Handle address-of expressions: field := &field{...}
+	if unary, ok := rhsExpr.(*ast.UnaryExpr); ok && unary.Op == token.AND {
+		rhsExpr = unary.X
+	}
+
+	// Check if RHS is a composite literal with a type name matching varName
+	compLit, ok := rhsExpr.(*ast.CompositeLit)
+	if !ok {
+		return ""
+	}
+
+	// Get the type name from the composite literal
+	var typeName string
+	switch t := compLit.Type.(type) {
+	case *ast.Ident:
+		typeName = t.Name
+	case *ast.SelectorExpr:
+		// pkg.Type - just use the type name part
+		typeName = t.Sel.Name
+	default:
+		return ""
+	}
+
+	// Check if variable name matches type name
+	if typeName == varName {
+		return typeName
+	}
+	return ""
+}
+
 // findVariableUsageInExpr recursively searches for variable usage in an expression
 func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map[string]*ast.Ident, shadowingInfo *ShadowingInfo, hasShadowing *bool) {
 	if expr == nil {
@@ -2173,8 +2746,17 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 		v.analyzeMethodAsyncTopological(methodKey, methodCalls[methodKey])
 	}
 
+	// Track async-returning variables BEFORE analyzing function literals
+	// This detects variables assigned from higher-order functions with async function literal args
+	// e.g., indirect := sync.OnceValue(asyncFunc)
+	// This must happen first so that function literals containing calls to these variables
+	// will be correctly identified as async.
+	v.trackAsyncReturningVarsAllFiles()
+
 	// Finally, analyze function literals in the current package only
 	// (external packages' function literals are not accessible)
+	// This must run AFTER trackAsyncReturningVarsAllFiles so that function literals
+	// containing calls to async-returning variables are correctly marked as async.
 	v.analyzeFunctionLiteralsAsync(v.pkg)
 }
 
@@ -2190,6 +2772,21 @@ func (v *analysisVisitor) analyzeFunctionLiteralsAsync(pkg *packages.Package) {
 	}
 }
 
+// trackAsyncReturningVarsAllFiles scans all files for assignment statements
+// and marks variables that are assigned from higher-order functions with async function literal args
+func (v *analysisVisitor) trackAsyncReturningVarsAllFiles() {
+	for _, file := range v.pkg.Syntax {
+		ast.Inspect(file, func(n ast.Node) bool {
+			if assignStmt, ok := n.(*ast.AssignStmt); ok {
+				if len(assignStmt.Lhs) == 1 && len(assignStmt.Rhs) == 1 {
+					v.trackAsyncReturningVar(assignStmt.Lhs[0], assignStmt.Rhs[0])
+				}
+			}
+			return true
+		})
+	}
+}
+
 // analyzeFunctionLiteralAsync determines if a function literal is async and stores the result
 func (v *analysisVisitor) analyzeFunctionLiteralAsync(funcLit *ast.FuncLit, pkg *packages.Package) {
 	// Check if already analyzed
@@ -2641,6 +3238,11 @@ func (v *analysisVisitor) isCallAsync(callExpr *ast.CallExpr, pkg *packages.Pack
 				result := v.isFunctionAsync(funcObj, pkg)
 				return result
 			}
+			// Check if this is a variable that returns async values
+			// (e.g., indirect := sync.OnceValue(asyncFunc))
+			if v.analysis.IsAsyncReturningVar(obj) {
+				return true
+			}
 		}
 
 	case *ast.SelectorExpr: