goscript 0.0.60 → 0.0.62

package/compiler/analysis.go

@@ -6,6 +6,7 @@ import (
 	"go/token"
 	"go/types"
 	"path/filepath"
+	"slices"
 	"strings"
 
 	"github.com/aperturerobotics/goscript"
@@ -51,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
@@ -106,9 +111,8 @@ type MethodKey struct {
 
 // ImplementationInfo tracks information about a struct that implements an interface method
 type ImplementationInfo struct {
-	StructType    *types.Named // The struct type that implements the interface
-	Method        *types.Func  // The method object
-	IsAsyncByFlow bool         // Whether this implementation is async based on control flow analysis
+	StructType *types.Named // The struct type that implements the interface
+	Method     *types.Func  // The method object
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -122,6 +126,10 @@ type Analysis struct {
 	// Imports stores the imports for the file
 	Imports map[string]*fileImport
 
+	// SyntheticImports stores imports that need to be written but were not in the source file.
+	// These are typically needed for promoted methods from embedded structs.
+	SyntheticImports map[string]*fileImport
+
 	// Cmap stores the comment map for the file
 	Cmap ast.CommentMap
 
@@ -141,6 +149,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
@@ -153,10 +166,6 @@ type Analysis struct {
 	// This is used to determine interface method async status based on implementations
 	InterfaceImplementations map[InterfaceMethodKey][]ImplementationInfo
 
-	// InterfaceMethodAsyncStatus caches the async status determination for interface methods
-	// This is computed once during analysis and reused during code generation
-	InterfaceMethodAsyncStatus map[InterfaceMethodKey]bool
-
 	// MethodAsyncStatus stores the async status of all methods analyzed
 	// This is computed once during analysis and reused during code generation
 	MethodAsyncStatus map[MethodKey]bool
@@ -179,6 +188,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.
@@ -188,19 +205,19 @@ 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
-		NamedBasicTypes:            make(map[types.Type]bool),
-		AllPackages:                allPackages,
-		InterfaceImplementations:   make(map[InterfaceMethodKey][]ImplementationInfo),
-		InterfaceMethodAsyncStatus: make(map[InterfaceMethodKey]bool),
-		MethodAsyncStatus:          make(map[MethodKey]bool),
+		VariableUsage:        make(map[types.Object]*VariableUsageInfo),
+		Imports:              make(map[string]*fileImport),
+		SyntheticImports:     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),
 	}
 }
 
@@ -211,6 +228,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),
 	}
 }
 
@@ -236,6 +255,22 @@ func (a *Analysis) ensureFunctionData(obj types.Object) *FunctionInfo {
 	return a.FunctionData[obj]
 }
 
+// GetFunctionInfoFromContext returns FunctionInfo based on the enclosing function context
+func (a *Analysis) GetFunctionInfoFromContext(nodeInfo *NodeInfo, pkg *packages.Package) *FunctionInfo {
+	if nodeInfo == nil {
+		return nil
+	}
+	if nodeInfo.EnclosingFuncDecl != nil {
+		if obj := pkg.TypesInfo.ObjectOf(nodeInfo.EnclosingFuncDecl.Name); obj != nil {
+			return a.FunctionData[obj]
+		}
+	}
+	if nodeInfo.EnclosingFuncLit != nil {
+		return a.FuncLitData[nodeInfo.EnclosingFuncLit]
+	}
+	return nil
+}
+
 // NeedsDefer returns whether the given node needs defer handling.
 func (a *Analysis) NeedsDefer(node ast.Node) bool {
 	if node == nil {
@@ -302,6 +337,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
@@ -370,7 +414,7 @@ func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 	}
 
 	// For pointer variables, check if they point to a variable-referenced value
-	if ptrType, ok := obj.Type().(*types.Pointer); ok {
+	if _, ok := obj.Type().(*types.Pointer); ok {
 		// Check all assignments to this pointer variable
 		for varObj, info := range a.VariableUsage {
 			if varObj == obj {
@@ -382,11 +426,6 @@ func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 				}
 			}
 		}
-
-		// Handle direct pointer initialization like: var p *int = &x
-		// Check if the pointer type's element type requires variable referencing
-		_ = ptrType.Elem()
-		// For now, conservatively return false for untracked cases
 	}
 
 	return false
@@ -453,9 +492,6 @@ type analysisVisitor struct {
 
 	// currentFuncLit tracks the *ast.FuncLit of the function literal we're currently analyzing.
 	currentFuncLit *ast.FuncLit
-
-	// visitingMethods tracks methods currently being analyzed to prevent infinite recursion
-	visitingMethods map[MethodKey]bool
 }
 
 // getOrCreateUsageInfo retrieves or creates the VariableUsageInfo for a given object.
@@ -906,9 +942,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)
@@ -922,18 +1012,8 @@ func (v *analysisVisitor) visitReturnStmt(n *ast.ReturnStmt) ast.Visitor {
 
 	// Check if it's a bare return
 	if len(n.Results) == 0 {
-		if v.currentFuncDecl != nil {
-			// Check if the enclosing function declaration has named returns
-			if obj := v.pkg.TypesInfo.ObjectOf(v.currentFuncDecl.Name); obj != nil {
-				if _, ok := v.analysis.FunctionData[obj]; ok {
-					nodeInfo.IsBareReturn = true
-				}
-			}
-		} else if v.currentFuncLit != nil {
-			// Check if the enclosing function literal has named returns
-			if _, ok := v.analysis.FuncLitData[v.currentFuncLit]; ok {
-				nodeInfo.IsBareReturn = true
-			}
+		if v.analysis.GetFunctionInfoFromContext(nodeInfo, v.pkg) != nil {
+			nodeInfo.IsBareReturn = true
 		}
 	}
 	return v
@@ -1011,14 +1091,8 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 		// Find the corresponding method in the struct type
 		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 		if structMethod != nil {
-			// Determine if this struct method is async using unified system
-			isAsync := false
-			if obj := structMethod; obj != nil {
-				isAsync = v.analysis.IsAsyncFunc(obj)
-			}
-
 			// Track this interface implementation
-			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod)
 		}
 	}
 	return v
@@ -1182,9 +1256,8 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 
 	// Create visitor for the entire package
 	visitor := &analysisVisitor{
-		analysis:        analysis,
-		pkg:             pkg,
-		visitingMethods: make(map[MethodKey]bool),
+		analysis: analysis,
+		pkg:      pkg,
 	}
 
 	// First pass: analyze all declarations and statements across all files
@@ -1221,9 +1294,165 @@ 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 all struct types in the package for embedded fields
+// and adds imports for any packages referenced by the promoted methods' parameter/return types.
+func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
+	// Collect all package names we need to add
+	packagesToAdd := make(map[string]*types.Package)
+
+	// Iterate through all type definitions in the package
+	scope := pkg.Types.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj == nil {
+			continue
+		}
+
+		// Check if it's a type definition
+		typeName, ok := obj.(*types.TypeName)
+		if !ok {
+			continue
+		}
+
+		// Get the underlying type
+		namedType, ok := typeName.Type().(*types.Named)
+		if !ok {
+			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)
+					}
+				}
+			}
+		}
+	}
+
+	// Add collected packages to imports (both regular and synthetic)
+	// Always add to SyntheticImports - the file compiler will check if
+	// the import was already written from the AST to avoid duplicates
+	for pkgName, pkgObj := range packagesToAdd {
+		tsImportPath := "@goscript/" + pkgObj.Path()
+		fileImp := &fileImport{
+			importPath: tsImportPath,
+			importVars: make(map[string]struct{}),
+		}
+		// Add to SyntheticImports unconditionally
+		a.SyntheticImports[pkgName] = fileImp
+		// Also add to Imports if not already present
+		if _, exists := a.Imports[pkgName]; !exists {
+			a.Imports[pkgName] = fileImp
+		}
+	}
+}
+
+// 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 {
@@ -1235,19 +1464,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)
+						}
 					}
 				}
 			}
@@ -1256,8 +1516,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
 		}
 	}
 
@@ -1276,13 +1539,7 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 
 					// Check if this function is defined in the current file
 					currentFileFuncs := analysis.FunctionDefs[baseFileName]
-					isDefinedInCurrentFile := false
-					for _, f := range currentFileFuncs {
-						if f == funcName {
-							isDefinedInCurrentFile = true
-							break
-						}
-					}
+					isDefinedInCurrentFile := slices.Contains(currentFileFuncs, funcName)
 
 					// If not defined in current file, find which file defines it
 					if !isDefinedInCurrentFile {
@@ -1290,24 +1547,15 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 							if sourceFile == baseFileName {
 								continue // Skip current file
 							}
-							for _, f := range funcs {
-								if f == funcName {
-									// Found the function in another file
-									if callsFromOtherFiles[sourceFile] == nil {
-										callsFromOtherFiles[sourceFile] = []string{}
-									}
-									// Check if already added to avoid duplicates
-									found := false
-									for _, existing := range callsFromOtherFiles[sourceFile] {
-										if existing == funcName {
-											found = true
-											break
-										}
-									}
-									if !found {
-										callsFromOtherFiles[sourceFile] = append(callsFromOtherFiles[sourceFile], funcName)
-									}
-									break
+							if slices.Contains(funcs, funcName) {
+								// Found the function in another file
+								if callsFromOtherFiles[sourceFile] == nil {
+									callsFromOtherFiles[sourceFile] = []string{}
+								}
+								// Check if already added to avoid duplicates
+								found := slices.Contains(callsFromOtherFiles[sourceFile], funcName)
+								if !found {
+									callsFromOtherFiles[sourceFile] = append(callsFromOtherFiles[sourceFile], funcName)
 								}
 							}
 						}
@@ -1340,13 +1588,7 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 
 						// Check if this type is defined in the current file
 						currentFileTypes := analysis.TypeDefs[baseFileName]
-						isDefinedInCurrentFile := false
-						for _, t := range currentFileTypes {
-							if t == typeName {
-								isDefinedInCurrentFile = true
-								break
-							}
-						}
+						isDefinedInCurrentFile := slices.Contains(currentFileTypes, typeName)
 
 						// If not defined in current file, find which file defines it
 						if !isDefinedInCurrentFile {
@@ -1354,24 +1596,99 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 								if sourceFile == baseFileName {
 									continue // Skip current file
 								}
-								for _, t := range types {
-									if t == typeName {
-										// Found the type in another file
-										if typeRefsFromOtherFiles[sourceFile] == nil {
-											typeRefsFromOtherFiles[sourceFile] = []string{}
+								if slices.Contains(types, typeName) {
+									// Found the type in another file
+									if typeRefsFromOtherFiles[sourceFile] == nil {
+										typeRefsFromOtherFiles[sourceFile] = []string{}
+									}
+									// Check if already added to avoid duplicates
+									found := slices.Contains(typeRefsFromOtherFiles[sourceFile], typeName)
+									if !found {
+										typeRefsFromOtherFiles[sourceFile] = append(typeRefsFromOtherFiles[sourceFile], typeName)
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(typeRefsFromOtherFiles) > 0 {
+			analysis.TypeCalls[baseFileName] = typeRefsFromOtherFiles
+		}
+	}
+
+	// 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 := false
-										for _, existing := range typeRefsFromOtherFiles[sourceFile] {
-											if existing == typeName {
-												found = true
-												break
-											}
+										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 {
-											typeRefsFromOtherFiles[sourceFile] = append(typeRefsFromOtherFiles[sourceFile], typeName)
+											varRefsFromOtherFiles[sourceFile] = append(varRefsFromOtherFiles[sourceFile], constName)
 										}
-										break
 									}
 								}
 							}
@@ -1382,11 +1699,93 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 			return true
 		})
 
-		if len(typeRefsFromOtherFiles) > 0 {
-			analysis.TypeCalls[baseFileName] = typeRefsFromOtherFiles
+		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
 }
 
@@ -1590,6 +1989,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
@@ -1607,12 +2007,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 {
@@ -1695,16 +2143,15 @@ func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map
 }
 
 // trackInterfaceImplementation records that a struct type implements an interface method
-func (a *Analysis) trackInterfaceImplementation(interfaceType *types.Interface, structType *types.Named, method *types.Func, isAsync bool) {
+func (a *Analysis) trackInterfaceImplementation(interfaceType *types.Interface, structType *types.Named, method *types.Func) {
 	key := InterfaceMethodKey{
 		InterfaceType: interfaceType.String(),
 		MethodName:    method.Name(),
 	}
 
 	implementation := ImplementationInfo{
-		StructType:    structType,
-		Method:        method,
-		IsAsyncByFlow: isAsync,
+		StructType: structType,
+		Method:     method,
 	}
 
 	a.InterfaceImplementations[key] = append(a.InterfaceImplementations[key], implementation)
@@ -1717,49 +2164,25 @@ func (a *Analysis) IsInterfaceMethodAsync(interfaceType *types.Interface, method
 		MethodName:    methodName,
 	}
 
-	// Check if we've already computed this
-	if result, exists := a.InterfaceMethodAsyncStatus[key]; exists {
-		return result
-	}
-
 	// Find all implementations of this interface method
 	implementations, exists := a.InterfaceImplementations[key]
 	if !exists {
-		// No implementations found, default to sync
-		a.InterfaceMethodAsyncStatus[key] = false
 		return false
 	}
 
-	// Update implementations with current async status before checking
-	for i := range implementations {
-		impl := &implementations[i]
-
-		// Create method key for this implementation
+	// If ANY implementation is async, the interface method is async
+	for _, impl := range implementations {
 		methodKey := MethodKey{
 			PackagePath:  impl.StructType.Obj().Pkg().Path(),
 			ReceiverType: impl.StructType.Obj().Name(),
 			MethodName:   impl.Method.Name(),
 		}
 
-		// Update with current async status from method analysis
-		if isAsync, exists := a.MethodAsyncStatus[methodKey]; exists {
-			impl.IsAsyncByFlow = isAsync
-		}
-	}
-
-	// Store the updated implementations back to the map
-	a.InterfaceImplementations[key] = implementations
-
-	// If ANY implementation is async, the interface method is async
-	for _, impl := range implementations {
-		if impl.IsAsyncByFlow {
-			a.InterfaceMethodAsyncStatus[key] = true
+		if isAsync, exists := a.MethodAsyncStatus[methodKey]; exists && isAsync {
 			return true
 		}
 	}
 
-	// All implementations are sync
-	a.InterfaceMethodAsyncStatus[key] = false
 	return false
 }
 
@@ -1844,56 +2267,6 @@ func (a *Analysis) GetIdentifierMapping(ident *ast.Ident) string {
 	return ""
 }
 
-// trackTypeAssertion analyzes type assertions and records interface implementations
-func (v *analysisVisitor) trackTypeAssertion(typeAssert *ast.TypeAssertExpr) {
-	// Get the type being asserted to
-	assertedType := v.pkg.TypesInfo.TypeOf(typeAssert.Type)
-	if assertedType == nil {
-		return
-	}
-
-	// Check if the asserted type is an interface
-	interfaceType, isInterface := assertedType.Underlying().(*types.Interface)
-	if !isInterface {
-		return
-	}
-
-	// Get the type of the expression being asserted
-	exprType := v.pkg.TypesInfo.TypeOf(typeAssert.X)
-	if exprType == nil {
-		return
-	}
-
-	// Handle pointer types by getting the element type
-	if ptrType, isPtr := exprType.(*types.Pointer); isPtr {
-		exprType = ptrType.Elem()
-	}
-
-	// Check if the expression type is a named struct type
-	namedType, isNamed := exprType.(*types.Named)
-	if !isNamed {
-		return
-	}
-
-	// For each method in the interface, check if the struct implements it
-	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
-		interfaceMethod := interfaceType.ExplicitMethod(i)
-
-		// Find the corresponding method in the struct type
-		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
-		if structMethod != nil {
-			// Determine if this struct method is async using unified system
-			isAsync := false
-			if obj := structMethod; obj != nil {
-				isAsync = v.analysis.IsAsyncFunc(obj)
-			}
-
-			// Track this interface implementation
-			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
-		}
-	}
-}
-
 // findStructMethod finds a method with the given name on a named type
 func (v *analysisVisitor) findStructMethod(namedType *types.Named, methodName string) *types.Func {
 	// Check methods directly on the type
@@ -2006,10 +2379,7 @@ func (v *analysisVisitor) trackInterfaceAssignments(assignStmt *ast.AssignStmt)
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
-				// Determine if this struct method is async using unified system
-				isAsync := v.analysis.IsAsyncFunc(structMethod)
-
-				v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+				v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod)
 			}
 		}
 	}
@@ -2068,9 +2438,7 @@ func (v *analysisVisitor) trackInterfaceCallArguments(callExpr *ast.CallExpr) {
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
-				// Note: Don't determine async status here - it will be determined later after method analysis
-				// For now, just track the implementation relationship without async status
-				v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, false)
+				v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod)
 			}
 		}
 	}
@@ -2216,10 +2584,7 @@ func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *type
 		// Find the method in the implementing type
 		structMethod := v.findMethodInType(namedType, interfaceMethod.Name())
 		if structMethod != nil {
-			// Determine if this implementation is async using unified system
-			isAsync := v.analysis.IsAsyncFunc(structMethod)
-
-			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod)
 		}
 	}
 }
@@ -2235,93 +2600,106 @@ func (v *interfaceImplementationVisitor) findMethodInType(namedType *types.Named
 	return nil
 }
 
-// getNamedReturns retrieves the named returns for a function
-func (v *analysisVisitor) getNamedReturns(funcDecl *ast.FuncDecl) []string {
-	var namedReturns []string
-	if funcDecl.Type != nil && funcDecl.Type.Results != nil {
-		for _, field := range funcDecl.Type.Results.List {
-			for _, name := range field.Names {
-				namedReturns = append(namedReturns, name.Name)
-			}
-		}
-	}
-	return namedReturns
-}
-
-// analyzeAllMethodsAsync performs comprehensive async analysis on all methods in all packages
+// analyzeAllMethodsAsync performs comprehensive async analysis on all methods in all packages using topological sort
 func (v *analysisVisitor) analyzeAllMethodsAsync() {
-	// Initialize visitingMethods map
-	v.visitingMethods = make(map[MethodKey]bool)
-
-	// Fixed-point iteration: keep analyzing until nothing changes
-	// This handles cases where method A calls method B, but B is analyzed after A
+	// Build the method call graph for all packages
+	methodCalls := v.buildMethodCallGraph()
+
+	// Topologically sort methods by their dependencies
+	sorted, cycles := v.topologicalSortMethods(methodCalls)
+
+	// Mark methods in cycles - check if they contain async operations
+	// We can't rely on the call graph for methods in cycles (circular dependency),
+	// but we can still detect if they call async external methods
+	//
+	// We need to iterate multiple times because methods in cycles can call each other,
+	// and we need to propagate async status until no changes occur
 	maxIterations := 10
 	for iteration := 0; iteration < maxIterations; iteration++ {
-		// Clear visitingMethods map for this iteration
-		v.visitingMethods = make(map[MethodKey]bool)
-
-		// Track if anything changed in this iteration
 		changed := false
 
-		// Save previous state
-		previousState := make(map[MethodKey]bool)
-		for k, v := range v.analysis.MethodAsyncStatus {
-			previousState[k] = v
-		}
+		for _, methodKey := range cycles {
+			// For methods in cycles, we need to check their body directly for async operations
+			pkg := v.analysis.AllPackages[methodKey.PackagePath]
+			if pkg == nil && methodKey.PackagePath == v.pkg.Types.Path() {
+				pkg = v.pkg
+			}
 
-		// Re-analyze methods in current package
-		v.analyzePackageMethodsAsync(v.pkg)
+			if pkg != nil {
+				var funcDecl *ast.FuncDecl
+				if methodKey.ReceiverType == "" {
+					funcDecl = v.findFunctionDecl(methodKey.MethodName, pkg)
+				} else {
+					funcDecl = v.findMethodDecl(methodKey.ReceiverType, methodKey.MethodName, pkg)
+				}
 
-		// Re-analyze methods in all dependency packages
-		for _, pkg := range v.analysis.AllPackages {
-			if pkg != v.pkg {
-				v.analyzePackageMethodsAsync(pkg)
-			}
-		}
+				if funcDecl != nil && funcDecl.Body != nil {
+					// Check if the method contains async operations (including calls to async external methods)
+					isAsync := v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
+
+					// Check if status changed
+					if oldStatus, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists || oldStatus != isAsync {
+						changed = true
+					}
 
-		// Check if anything changed
-		for k, newValue := range v.analysis.MethodAsyncStatus {
-			oldValue, existed := previousState[k]
-			if !existed {
-				// New method added - check if it's async (if sync, no need to re-analyze dependents)
-				if newValue {
-					changed = true
+					v.analysis.MethodAsyncStatus[methodKey] = isAsync
+					continue
 				}
-			} else if oldValue != newValue {
-				// Method changed from sync to async (or vice versa)
+			}
+
+			// Fallback: mark as sync if we can't analyze the body
+			if _, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists {
+				v.analysis.MethodAsyncStatus[methodKey] = false
 				changed = true
 			}
 		}
 
-		// If nothing changed, we've reached a fixed point
+		// If no changes in this iteration, we're done
 		if !changed {
 			break
 		}
 	}
 
+	// Analyze methods in dependency order (dependencies analyzed before dependents)
+	for _, methodKey := range sorted {
+		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)
 }
 
-// analyzePackageMethodsAsync analyzes all methods in a specific package
-func (v *analysisVisitor) analyzePackageMethodsAsync(pkg *packages.Package) {
-	// Analyze function declarations
+// buildMethodCallGraph builds a graph of which methods call which other methods
+func (v *analysisVisitor) analyzeFunctionLiteralsAsync(pkg *packages.Package) {
 	for _, file := range pkg.Syntax {
-		for _, decl := range file.Decls {
-			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
-				v.analyzeMethodAsync(funcDecl, pkg)
+		ast.Inspect(file, func(n ast.Node) bool {
+			if funcLit, ok := n.(*ast.FuncLit); ok {
+				v.analyzeFunctionLiteralAsync(funcLit, pkg)
 			}
-		}
+			return true
+		})
 	}
 }
 
-// analyzeFunctionLiteralsAsync analyzes all function literals in a package for async operations
-func (v *analysisVisitor) analyzeFunctionLiteralsAsync(pkg *packages.Package) {
-	for _, file := range pkg.Syntax {
+// 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 funcLit, ok := n.(*ast.FuncLit); ok {
-				v.analyzeFunctionLiteralAsync(funcLit, pkg)
+			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
 		})
@@ -2350,55 +2728,320 @@ func (v *analysisVisitor) analyzeFunctionLiteralAsync(funcLit *ast.FuncLit, pkg
 	nodeInfo.InAsyncContext = isAsync
 }
 
-// analyzeMethodAsync determines if a method is async and stores the result
-func (v *analysisVisitor) analyzeMethodAsync(funcDecl *ast.FuncDecl, pkg *packages.Package) {
-	methodKey := v.getMethodKey(funcDecl, pkg)
+// buildMethodCallGraph builds a graph of which methods call which other methods
+func (v *analysisVisitor) buildMethodCallGraph() map[MethodKey][]MethodKey {
+	methodCalls := make(map[MethodKey][]MethodKey)
 
-	// Check for cycles
-	if v.visitingMethods[methodKey] {
-		// Cycle detected, assume sync to break recursion
-		v.analysis.MethodAsyncStatus[methodKey] = false
-		return
+	// Iterate through all packages
+	allPkgs := []*packages.Package{v.pkg}
+	for _, pkg := range v.analysis.AllPackages {
+		if pkg != v.pkg {
+			allPkgs = append(allPkgs, pkg)
+		}
 	}
 
-	// Mark as visiting
-	v.visitingMethods[methodKey] = true
+	for _, pkg := range allPkgs {
+		for _, file := range pkg.Syntax {
+			for _, decl := range file.Decls {
+				if funcDecl, ok := decl.(*ast.FuncDecl); ok {
+					methodKey := v.getMethodKey(funcDecl, pkg)
 
-	// Determine if method is async
-	isAsync := false
+					// Initialize the entry for this method
+					if _, exists := methodCalls[methodKey]; !exists {
+						methodCalls[methodKey] = []MethodKey{}
+					}
+
+					// Extract method calls from the function body
+					if funcDecl.Body != nil {
+						callees := v.extractMethodCalls(funcDecl.Body, pkg)
+						methodCalls[methodKey] = callees
+					}
+				}
+			}
+		}
+	}
+
+	return methodCalls
+}
+
+// extractMethodCalls extracts all method and function calls from a node
+func (v *analysisVisitor) extractMethodCalls(node ast.Node, pkg *packages.Package) []MethodKey {
+	var calls []MethodKey
+	seen := make(map[MethodKey]bool)
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return false
+		}
+
+		if callExpr, ok := n.(*ast.CallExpr); ok {
+			methodKeys := v.extractMethodKeysFromCall(callExpr, pkg)
+			for _, methodKey := range methodKeys {
+				if !seen[methodKey] {
+					seen[methodKey] = true
+					calls = append(calls, methodKey)
+				}
+			}
+		}
+
+		return true
+	})
+
+	return calls
+}
+
+// extractMethodKeysFromCall extracts MethodKeys from a call expression
+// Returns multiple keys for interface method calls (one for each implementation)
+func (v *analysisVisitor) extractMethodKeysFromCall(callExpr *ast.CallExpr, pkg *packages.Package) []MethodKey {
+	singleKey := v.extractMethodKeyFromCall(callExpr, pkg)
+	if singleKey != nil {
+		return []MethodKey{*singleKey}
+	}
+
+	// Check if this is an interface method call
+	if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+		if receiverType := pkg.TypesInfo.TypeOf(selExpr.X); receiverType != nil {
+			if interfaceType, isInterface := receiverType.Underlying().(*types.Interface); isInterface {
+				methodName := selExpr.Sel.Name
+				// Find all implementations of this interface method
+				key := InterfaceMethodKey{
+					InterfaceType: interfaceType.String(),
+					MethodName:    methodName,
+				}
+				if implementations, exists := v.analysis.InterfaceImplementations[key]; exists {
+					var keys []MethodKey
+					for _, impl := range implementations {
+						keys = append(keys, MethodKey{
+							PackagePath:  impl.StructType.Obj().Pkg().Path(),
+							ReceiverType: impl.StructType.Obj().Name(),
+							MethodName:   impl.Method.Name(),
+						})
+					}
+					return keys
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// extractMethodKeyFromCall extracts a MethodKey from a call expression
+func (v *analysisVisitor) extractMethodKeyFromCall(callExpr *ast.CallExpr, pkg *packages.Package) *MethodKey {
+	switch fun := callExpr.Fun.(type) {
+	case *ast.Ident:
+		// Direct function call
+		if obj := pkg.TypesInfo.Uses[fun]; obj != nil {
+			if funcObj, ok := obj.(*types.Func); ok {
+				pkgPath := pkg.Types.Path()
+				if funcObj.Pkg() != nil {
+					pkgPath = funcObj.Pkg().Path()
+				}
+				return &MethodKey{
+					PackagePath:  pkgPath,
+					ReceiverType: "",
+					MethodName:   funcObj.Name(),
+				}
+			}
+		}
+
+	case *ast.SelectorExpr:
+		// Package-level function call (e.g., time.Sleep)
+		if ident, ok := fun.X.(*ast.Ident); ok {
+			if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+				if pkgName, isPkg := obj.(*types.PkgName); isPkg {
+					return &MethodKey{
+						PackagePath:  pkgName.Imported().Path(),
+						ReceiverType: "",
+						MethodName:   fun.Sel.Name,
+					}
+				}
+			}
+		}
+
+		// Check if this is an interface method call - if so, return nil
+		// so extractMethodKeysFromCall can expand it to all implementations
+		if receiverType := pkg.TypesInfo.TypeOf(fun.X); receiverType != nil {
+			if _, isInterface := receiverType.Underlying().(*types.Interface); isInterface {
+				// This is an interface method call - return nil to let
+				// extractMethodKeysFromCall handle expanding to implementations
+				return nil
+			}
+		}
+
+		// Method call on concrete objects
+		if selection := pkg.TypesInfo.Selections[fun]; selection != nil {
+			if methodObj := selection.Obj(); methodObj != nil {
+				receiverType := ""
+				methodPkgPath := ""
+
+				// Get receiver type
+				switch x := fun.X.(type) {
+				case *ast.Ident:
+					if obj := pkg.TypesInfo.Uses[x]; obj != nil {
+						if varObj, ok := obj.(*types.Var); ok {
+							receiverType = v.getTypeName(varObj.Type())
+						}
+					}
+				case *ast.SelectorExpr:
+					if typeExpr := pkg.TypesInfo.TypeOf(x); typeExpr != nil {
+						receiverType = v.getTypeName(typeExpr)
+					}
+				}
+
+				// Get method's package path
+				if methodFunc, ok := methodObj.(*types.Func); ok {
+					if methodFunc.Pkg() != nil {
+						methodPkgPath = methodFunc.Pkg().Path()
+					}
+				}
+
+				if methodPkgPath == "" {
+					methodPkgPath = pkg.Types.Path()
+				}
+
+				return &MethodKey{
+					PackagePath:  methodPkgPath,
+					ReceiverType: receiverType,
+					MethodName:   methodObj.Name(),
+				}
+			}
+		}
+	}
 
-	// Determine if this is a handwritten package (from gs/ directory)
-	// Handwritten packages should not have their bodies analyzed
+	return nil
+}
+
+// topologicalSortMethods performs a topological sort of methods based on their call dependencies
+// Returns sorted methods and methods involved in cycles
+func (v *analysisVisitor) topologicalSortMethods(methodCalls map[MethodKey][]MethodKey) ([]MethodKey, []MethodKey) {
+	// Kahn's algorithm for topological sorting
+	inDegree := make(map[MethodKey]int)
+	graph := make(map[MethodKey][]MethodKey)
+
+	// Initialize in-degree counts and reverse graph
+	for method := range methodCalls {
+		inDegree[method] = 0
+		graph[method] = []MethodKey{}
+	}
+
+	// Build reverse graph and count in-degrees
+	// graph[dependency] = methods that depend on it
+	for method, callees := range methodCalls {
+		for _, callee := range callees {
+			// Only create dependency edges for callees that exist in the call graph
+			// This automatically excludes handwritten packages that aren't being compiled
+			if _, exists := inDegree[callee]; exists {
+				// Additionally, skip if the callee is from a handwritten package
+				// This prevents our code from being blocked by unresolved handwritten package dependencies
+				if !v.analysis.isHandwrittenPackage(callee.PackagePath) {
+					graph[callee] = append(graph[callee], method)
+					inDegree[method]++
+				}
+			}
+		}
+	}
+
+	// Find methods with no dependencies (in-degree == 0)
+	var queue []MethodKey
+	for method, degree := range inDegree {
+		if degree == 0 {
+			queue = append(queue, method)
+		}
+	}
+
+	var sorted []MethodKey
+
+	for len(queue) > 0 {
+		// Remove method from queue
+		current := queue[0]
+		queue = queue[1:]
+		sorted = append(sorted, current)
+
+		// For each method that depends on current
+		for _, dependent := range graph[current] {
+			inDegree[dependent]--
+			if inDegree[dependent] == 0 {
+				queue = append(queue, dependent)
+			}
+		}
+	}
+
+	// Find methods in cycles (not in sorted list)
+	var cycles []MethodKey
+	if len(sorted) != len(methodCalls) {
+		for method := range methodCalls {
+			found := slices.Contains(sorted, method)
+			if !found {
+				cycles = append(cycles, method)
+			}
+		}
+	}
+
+	return sorted, cycles
+}
+
+// analyzeMethodAsyncTopological analyzes a single method for async operations in topological order
+func (v *analysisVisitor) analyzeMethodAsyncTopological(methodKey MethodKey, callees []MethodKey) {
+	// Check if method is from handwritten package
 	isHandwrittenPackage := v.analysis.isHandwrittenPackage(methodKey.PackagePath)
 
 	if isHandwrittenPackage {
 		// For handwritten packages, check if we have pre-loaded metadata
-		metadataKey := MethodKey{
-			PackagePath:  methodKey.PackagePath,
-			ReceiverType: methodKey.ReceiverType,
-			MethodName:   methodKey.MethodName,
+		_, hasMetadata := v.analysis.MethodAsyncStatus[methodKey]
+		if hasMetadata {
+			// Already set from metadata, don't override
+			return
 		}
-		metadataIsAsync, hasMetadata := v.analysis.MethodAsyncStatus[metadataKey]
+		// No metadata means assume sync
+		v.analysis.MethodAsyncStatus[methodKey] = false
+		return
+	}
 
-		if hasMetadata {
-			// Use explicit metadata from handwritten packages (gs/)
-			isAsync = metadataIsAsync
-		} else {
-			// Handwritten package but no explicit metadata: assume sync
-			isAsync = false
+	// Find the method declaration
+	pkg := v.analysis.AllPackages[methodKey.PackagePath]
+	if pkg == nil {
+		if methodKey.PackagePath == v.pkg.Types.Path() {
+			pkg = v.pkg
 		}
-	} else if funcDecl.Body != nil {
-		// Not a handwritten package and has body: always analyze for async operations
-		// This allows fixed-point iteration to update results
-		isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
 	}
-	// Otherwise leave isAsync as false
 
-	// Store result in MethodAsyncStatus
-	v.analysis.MethodAsyncStatus[methodKey] = isAsync
+	if pkg == nil {
+		// Can't find package, assume sync
+		v.analysis.MethodAsyncStatus[methodKey] = false
+		return
+	}
+
+	var funcDecl *ast.FuncDecl
+	if methodKey.ReceiverType == "" {
+		// Package-level function
+		funcDecl = v.findFunctionDecl(methodKey.MethodName, pkg)
+	} else {
+		// Method with receiver
+		funcDecl = v.findMethodDecl(methodKey.ReceiverType, methodKey.MethodName, pkg)
+	}
+
+	if funcDecl == nil || funcDecl.Body == nil {
+		// No body to analyze, assume sync
+		v.analysis.MethodAsyncStatus[methodKey] = false
+		return
+	}
+
+	// Check if method contains async operations (including calls to async external methods)
+	isAsync := v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
+
+	// If not directly async, check if any callee from the call graph is async
+	// (This catches calls to other methods in the same codebase)
+	if !isAsync {
+		for _, callee := range callees {
+			if calleeAsync, exists := v.analysis.MethodAsyncStatus[callee]; exists && calleeAsync {
+				isAsync = true
+				break
+			}
+		}
+	}
 
-	// Unmark as visiting
-	delete(v.visitingMethods, methodKey)
+	v.analysis.MethodAsyncStatus[methodKey] = isAsync
 }
 
 // getMethodKey creates a unique key for a method
@@ -2408,14 +3051,19 @@ func (v *analysisVisitor) getMethodKey(funcDecl *ast.FuncDecl, pkg *packages.Pac
 	receiverType := ""
 
 	if funcDecl.Recv != nil && len(funcDecl.Recv.List) > 0 {
-		// Get receiver type name
-		if len(funcDecl.Recv.List[0].Names) > 0 {
+		// Try to get receiver type from TypesInfo first
+		if len(funcDecl.Recv.List[0].Names) > 0 && pkg.TypesInfo != nil {
 			if def := pkg.TypesInfo.Defs[funcDecl.Recv.List[0].Names[0]]; def != nil {
 				if vr, ok := def.(*types.Var); ok {
 					receiverType = v.getTypeName(vr.Type())
 				}
 			}
 		}
+
+		// Fallback to AST if TypesInfo is unavailable or failed
+		if receiverType == "" {
+			receiverType = v.getReceiverTypeFromAST(funcDecl.Recv.List[0].Type)
+		}
 	}
 
 	return MethodKey{
@@ -2437,6 +3085,23 @@ func (v *analysisVisitor) getTypeName(t types.Type) string {
 	}
 }
 
+// getReceiverTypeFromAST extracts the receiver type name from AST when TypesInfo is unavailable
+func (v *analysisVisitor) getReceiverTypeFromAST(expr ast.Expr) string {
+	switch t := expr.(type) {
+	case *ast.StarExpr:
+		// Pointer receiver: *Type
+		return v.getReceiverTypeFromAST(t.X)
+	case *ast.Ident:
+		// Simple type name
+		return t.Name
+	case *ast.SelectorExpr:
+		// Qualified type: pkg.Type
+		return t.Sel.Name
+	default:
+		return ""
+	}
+}
+
 // containsAsyncOperationsComplete is a comprehensive async detection that handles method calls
 func (v *analysisVisitor) containsAsyncOperationsComplete(node ast.Node, pkg *packages.Package) bool {
 	var hasAsync bool
@@ -2489,7 +3154,13 @@ func (v *analysisVisitor) isCallAsync(callExpr *ast.CallExpr, pkg *packages.Pack
 		// Direct function call
 		if obj := pkg.TypesInfo.Uses[fun]; obj != nil {
 			if funcObj, ok := obj.(*types.Func); ok {
-				return v.isFunctionAsync(funcObj, pkg)
+				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
 			}
 		}
 
@@ -2512,14 +3183,16 @@ func (v *analysisVisitor) isCallAsync(callExpr *ast.CallExpr, pkg *packages.Pack
 			if interfaceType, isInterface := receiverType.Underlying().(*types.Interface); isInterface {
 				methodName := fun.Sel.Name
 				// For interface method calls, check if the interface method is async
-				return v.analysis.IsInterfaceMethodAsync(interfaceType, methodName)
+				result := v.analysis.IsInterfaceMethodAsync(interfaceType, methodName)
+				return result
 			}
 		}
 
 		// Method call on concrete objects
 		if selection := pkg.TypesInfo.Selections[fun]; selection != nil {
 			if methodObj := selection.Obj(); methodObj != nil {
-				return v.isMethodAsyncFromSelection(fun, methodObj, pkg)
+				result := v.isMethodAsyncFromSelection(fun, methodObj, pkg)
+				return result
 			}
 		}
 	}
@@ -2534,7 +3207,7 @@ func (v *analysisVisitor) isFunctionAsync(funcObj *types.Func, pkg *packages.Pac
 		return v.analysis.IsMethodAsync(funcObj.Pkg().Path(), "", funcObj.Name())
 	}
 
-	// Check internal method status
+	// Check internal method status (should already be computed during analysis)
 	methodKey := MethodKey{
 		PackagePath:  pkg.Types.Path(),
 		ReceiverType: "",
@@ -2545,14 +3218,7 @@ func (v *analysisVisitor) isFunctionAsync(funcObj *types.Func, pkg *packages.Pac
 		return status
 	}
 
-	// Not analyzed yet, analyze now
-	if funcDecl := v.findFunctionDecl(funcObj.Name(), pkg); funcDecl != nil {
-		v.analyzeMethodAsync(funcDecl, pkg)
-		if status, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {
-			return status
-		}
-	}
-
+	// Not found - should have been analyzed during analyzeAllMethodsAsync
 	return false
 }
 
@@ -2572,7 +3238,12 @@ func (v *analysisVisitor) isMethodAsyncFromSelection(selExpr *ast.SelectorExpr,
 			}
 		}
 	case *ast.SelectorExpr:
-		// Field access (e.g., l.m.Lock())
+		// Field access (e.g., l.m.Lock() or d.mu.Lock())
+		if typeExpr := pkg.TypesInfo.TypeOf(x); typeExpr != nil {
+			receiverType = v.getTypeName(typeExpr)
+		}
+	default:
+		// For other cases, try to get type directly
 		if typeExpr := pkg.TypesInfo.TypeOf(x); typeExpr != nil {
 			receiverType = v.getTypeName(typeExpr)
 		}
@@ -2585,7 +3256,6 @@ func (v *analysisVisitor) isMethodAsyncFromSelection(selExpr *ast.SelectorExpr,
 		}
 	}
 
-	// If no package path found, use current package
 	if methodPkgPath == "" {
 		methodPkgPath = pkg.Types.Path()
 	}
@@ -2602,28 +3272,7 @@ func (v *analysisVisitor) isMethodAsyncFromSelection(selExpr *ast.SelectorExpr,
 		return status
 	}
 
-	// Check if this is a method in the same package we're currently analyzing
-	if methodPkgPath == v.pkg.Types.Path() {
-		// This is a method in the same package - we should analyze it if we haven't yet
-		if funcDecl := v.findMethodDecl(receiverType, methodObj.Name(), v.pkg); funcDecl != nil {
-			v.analyzeMethodAsync(funcDecl, v.pkg)
-			if status, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {
-				return status
-			}
-		}
-	} else {
-		// For methods in other packages that we're compiling together
-		if targetPkg := v.analysis.AllPackages[methodPkgPath]; targetPkg != nil {
-			// Try to analyze the method if we haven't already
-			if funcDecl := v.findMethodDecl(receiverType, methodObj.Name(), targetPkg); funcDecl != nil {
-				v.analyzeMethodAsync(funcDecl, targetPkg)
-				if status, exists := v.analysis.MethodAsyncStatus[methodKey]; exists {
-					return status
-				}
-			}
-		}
-	}
-
+	// Not found - should have been analyzed during analyzeAllMethodsAsync
 	return false
 }
 
@@ -2663,22 +3312,6 @@ func (v *analysisVisitor) findMethodDecl(receiverType, methodName string, pkg *p
 	return nil
 }
 
-// checkExternalMethodMetadata checks if an external method is async based on pre-loaded metadata
-func (v *analysisVisitor) checkExternalMethodMetadata(pkgPath, receiverType, methodName string) bool {
-	// Use MethodKey to check pre-loaded metadata in MethodAsyncStatus
-	key := MethodKey{
-		PackagePath:  pkgPath,
-		ReceiverType: receiverType,
-		MethodName:   methodName,
-	}
-
-	if isAsync, exists := v.analysis.MethodAsyncStatus[key]; exists {
-		return isAsync
-	}
-
-	return false
-}
-
 // IsLocalMethodAsync checks if a local method is async using pre-computed analysis
 func (a *Analysis) IsLocalMethodAsync(pkgPath, receiverType, methodName string) bool {
 	methodKey := MethodKey{
@@ -2693,31 +3326,3 @@ func (a *Analysis) IsLocalMethodAsync(pkgPath, receiverType, methodName string)
 
 	return false
 }
-
-// updateInterfaceImplementationAsyncStatus updates interface implementations with correct async status
-// This runs after method async analysis is complete
-func (v *analysisVisitor) updateInterfaceImplementationAsyncStatus() {
-	// Iterate through all tracked interface implementations and update their async status
-	for key, implementations := range v.analysis.InterfaceImplementations {
-		// Remove duplicates first
-		seenMethods := make(map[string]bool)
-		uniqueImplementations := []ImplementationInfo{}
-
-		for _, impl := range implementations {
-			methodKey := impl.StructType.Obj().Name() + "." + key.MethodName
-			if !seenMethods[methodKey] {
-				seenMethods[methodKey] = true
-
-				// Now that method async analysis is complete, get the correct async status
-				isAsync := v.analysis.IsAsyncFunc(impl.Method)
-
-				// Update the implementation with the correct async status
-				impl.IsAsyncByFlow = isAsync
-				uniqueImplementations = append(uniqueImplementations, impl)
-			}
-		}
-
-		// Store the updated implementations without duplicates
-		v.analysis.InterfaceImplementations[key] = uniqueImplementations
-	}
-}