goscript 0.0.49 → 0.0.50

package/compiler/analysis.go

@@ -86,6 +86,37 @@ type NodeInfo struct {
 	IdentifierMapping string         // replacement name for this identifier (e.g., receiver -> "receiver")
 }
 
+// PackageMetadataKey represents a key for looking up package metadata
+type PackageMetadataKey struct {
+	PackagePath string // Full package path (e.g., "github.com/aperturerobotics/util/csync")
+	TypeName    string // Type name (e.g., "Mutex")
+	MethodName  string // Method name (e.g., "Lock")
+}
+
+// MethodMetadata represents metadata about a method
+type MethodMetadata struct {
+	IsAsync bool // Whether the method is async
+}
+
+// GsMetadata represents the structure of a meta.json file in gs/ packages
+type GsMetadata struct {
+	Dependencies []string        `json:"dependencies,omitempty"`
+	AsyncMethods map[string]bool `json:"asyncMethods,omitempty"`
+}
+
+// InterfaceMethodKey uniquely identifies an interface method
+type InterfaceMethodKey struct {
+	InterfaceType string // The string representation of the interface type
+	MethodName    string // The method name
+}
+
+// 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
+}
+
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
 // This data is used to make decisions about how to generate TypeScript code.
 // Analysis is read-only after being built and should not be modified during code generation.
@@ -116,12 +147,24 @@ type Analysis struct {
 	// FunctionAssignments tracks which function literals are assigned to which variables
 	FunctionAssignments map[types.Object]ast.Node
 
-	// PackageMetadata holds package-level metadata
-	PackageMetadata map[string]interface{}
+	// PackageMetadata holds package-level metadata with structured keys
+	PackageMetadata map[PackageMetadataKey]MethodMetadata
+
+	// 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
 
-	// WrapperTypes tracks types that should be implemented as wrapper classes
-	// This includes both local types with methods and imported types that are known wrapper types
-	WrapperTypes map[types.Type]bool
+	// AllPackages stores all loaded packages for dependency analysis
+	// Key: package path, Value: package data
+	AllPackages map[string]*packages.Package
+
+	// InterfaceImplementations tracks which struct types implement which interface methods
+	// 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
 }
 
 // PackageAnalysis holds cross-file analysis data for a package
@@ -143,24 +186,25 @@ type PackageAnalysis struct {
 	TypeCalls map[string]map[string][]string
 }
 
-// GsMetadata represents the structure of a meta.json file in gs/ packages
-type GsMetadata struct {
-	Dependencies []string        `json:"dependencies,omitempty"`
-	AsyncMethods map[string]bool `json:"asyncMethods,omitempty"`
-}
-
 // NewAnalysis creates a new Analysis instance.
-func NewAnalysis() *Analysis {
+func NewAnalysis(allPackages map[string]*packages.Package) *Analysis {
+	if allPackages == nil {
+		allPackages = make(map[string]*packages.Package)
+	}
+
 	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:     make(map[string]interface{}),
-		WrapperTypes:        make(map[types.Type]bool),
+		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:            make(map[PackageMetadataKey]MethodMetadata),
+		NamedBasicTypes:            make(map[types.Type]bool),
+		AllPackages:                allPackages,
+		InterfaceImplementations:   make(map[InterfaceMethodKey][]ImplementationInfo),
+		InterfaceMethodAsyncStatus: make(map[InterfaceMethodKey]bool),
 	}
 }
 
@@ -174,6 +218,28 @@ func NewPackageAnalysis() *PackageAnalysis {
 	}
 }
 
+// ensureNodeData ensures that NodeData exists for a given node and returns it
+func (a *Analysis) ensureNodeData(node ast.Node) *NodeInfo {
+	if node == nil {
+		return nil
+	}
+	if a.NodeData[node] == nil {
+		a.NodeData[node] = &NodeInfo{}
+	}
+	return a.NodeData[node]
+}
+
+// ensureFunctionData ensures that FunctionData exists for a given object and returns it
+func (a *Analysis) ensureFunctionData(obj types.Object) *FunctionInfo {
+	if obj == nil {
+		return nil
+	}
+	if a.FunctionData[obj] == nil {
+		a.FunctionData[obj] = &FunctionInfo{}
+	}
+	return a.FunctionData[obj]
+}
+
 // NeedsDefer returns whether the given node needs defer handling.
 func (a *Analysis) NeedsDefer(node ast.Node) bool {
 	if node == nil {
@@ -387,10 +453,8 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 	}
 
 	// Initialize and store async state for the current node
-	if v.analysis.NodeData[node] == nil {
-		v.analysis.NodeData[node] = &NodeInfo{}
-	}
-	v.analysis.NodeData[node].InAsyncContext = v.inAsyncFunction
+	nodeInfo := v.analysis.ensureNodeData(node)
+	nodeInfo.InAsyncContext = v.inAsyncFunction
 
 	switch n := node.(type) {
 	case *ast.GenDecl:
@@ -463,441 +527,365 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 				}
 			}
 		}
-		// Continue traversal AFTER processing the declaration itself
-		// to handle expressions within initial values if needed.
-		// However, the core usage tracking is done above.
-		// Let standard traversal handle children.
 		return v
 
 	case *ast.FuncDecl:
-		// Save original states to restore after visiting
-		originalInAsync := v.inAsyncFunction
-		originalFuncObj := v.currentFuncObj
-		originalFuncDecl := v.currentFuncDecl
-		originalFuncLit := v.currentFuncLit
-		originalReceiver := v.currentReceiver
-
-		// Reset for current function
-		v.currentFuncName = n.Name.Name
-		v.currentFuncDecl = n
-		v.currentFuncLit = nil
-		v.currentReceiver = nil
-
-		// Determine if this function declaration is async based on its body
-		isAsync := false
-		if n.Body != nil {
-			containsAsyncOps := v.containsAsyncOperations(n.Body)
-			if containsAsyncOps {
-				// Get the object for this function declaration
-				if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
-					v.analysis.FunctionData[obj] = &FunctionInfo{
-						IsAsync:      true,
-						NamedReturns: v.getNamedReturns(n),
-					}
-					isAsync = true
-				}
+		return v.visitFuncDecl(n)
+
+	case *ast.FuncLit:
+		return v.visitFuncLit(n)
+
+	case *ast.BlockStmt:
+		return v.visitBlockStmt(n)
+
+	case *ast.UnaryExpr:
+		// We handle address-of (&) within AssignStmt where it's actually used.
+		return v
+
+	case *ast.CallExpr:
+		return v.visitCallExpr(n)
+
+	case *ast.SelectorExpr:
+		return v.visitSelectorExpr(n)
+
+	case *ast.AssignStmt:
+		return v.visitAssignStmt(n)
+
+	case *ast.ReturnStmt:
+		return v.visitReturnStmt(n)
+
+	case *ast.DeclStmt:
+		return v.visitDeclStmt(n)
+
+	case *ast.IfStmt:
+		return v.visitIfStmt(n)
+
+	case *ast.TypeAssertExpr:
+		return v.visitTypeAssertExpr(n)
+	}
+
+	// For all other nodes, continue traversal
+	return v
+}
+
+// visitFuncDecl handles function declaration analysis
+func (v *analysisVisitor) visitFuncDecl(n *ast.FuncDecl) ast.Visitor {
+	// Save original states to restore after visiting
+	originalInAsync := v.inAsyncFunction
+	originalFuncObj := v.currentFuncObj
+	originalFuncDecl := v.currentFuncDecl
+	originalFuncLit := v.currentFuncLit
+	originalReceiver := v.currentReceiver
+
+	// Reset for current function
+	v.currentFuncName = n.Name.Name
+	v.currentFuncDecl = n
+	v.currentFuncLit = nil
+	v.currentReceiver = nil
+
+	// Determine if this function declaration is async based on its body
+	isAsync := false
+	if n.Body != nil {
+		containsAsyncOps := v.containsAsyncOperations(n.Body)
+		if containsAsyncOps {
+			// Get the object for this function declaration
+			if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
+				funcInfo := v.analysis.ensureFunctionData(obj)
+				funcInfo.IsAsync = true
+				funcInfo.NamedReturns = v.getNamedReturns(n)
+				isAsync = true
 			}
 		}
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
-		}
-		v.analysis.NodeData[n].InAsyncContext = isAsync
-
-		// Set current receiver if this is a method
-		if n.Recv != nil && len(n.Recv.List) > 0 {
-			// Assuming a single receiver for simplicity for now
-			if len(n.Recv.List[0].Names) > 0 {
-				if ident := n.Recv.List[0].Names[0]; ident != nil && ident.Name != "_" {
-					if def := v.pkg.TypesInfo.Defs[ident]; def != nil {
-						if vr, ok := def.(*types.Var); ok {
-							v.currentReceiver = vr
-							// Add the receiver variable to the VariableUsage map
-							// to ensure it is properly analyzed for varRefing
-							v.getOrCreateUsageInfo(v.currentReceiver)
-
-							// Check if receiver is used in method body
-							receiverUsed := false
-							if n.Body != nil {
-								if v.isInterfaceMethod(n) {
-									receiverUsed = true
-								} else {
-									receiverUsed = v.containsReceiverUsage(n.Body, vr)
-								}
+	}
+	nodeInfo := v.analysis.ensureNodeData(n)
+	nodeInfo.InAsyncContext = isAsync
+
+	// Set current receiver if this is a method
+	if n.Recv != nil && len(n.Recv.List) > 0 {
+		// Assuming a single receiver for simplicity for now
+		if len(n.Recv.List[0].Names) > 0 {
+			if ident := n.Recv.List[0].Names[0]; ident != nil && ident.Name != "_" {
+				if def := v.pkg.TypesInfo.Defs[ident]; def != nil {
+					if vr, ok := def.(*types.Var); ok {
+						v.currentReceiver = vr
+						// Add the receiver variable to the VariableUsage map
+						v.getOrCreateUsageInfo(v.currentReceiver)
+
+						// Check if receiver is used in method body
+						receiverUsed := false
+						if n.Body != nil {
+							if v.isInterfaceMethod(n) {
+								receiverUsed = true
+							} else {
+								receiverUsed = v.containsReceiverUsage(n.Body, vr)
 							}
+						}
 
-							// Update function data with receiver usage info
-							if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
-								if v.analysis.FunctionData[obj] == nil {
-									v.analysis.FunctionData[obj] = &FunctionInfo{}
-								}
-								v.analysis.FunctionData[obj].ReceiverUsed = receiverUsed
-							}
+						// Update function data with receiver usage info
+						if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
+							funcInfo := v.analysis.ensureFunctionData(obj)
+							funcInfo.ReceiverUsed = receiverUsed
 						}
 					}
 				}
 			}
 		}
+	}
 
-		// Store named return variables (sanitized for TypeScript)
-		if n.Type != nil && n.Type.Results != nil {
-			var namedReturns []string
-			for _, field := range n.Type.Results.List {
-				for _, name := range field.Names {
-					namedReturns = append(namedReturns, sanitizeIdentifier(name.Name))
-				}
-			}
-			if len(namedReturns) > 0 {
-				if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
-					if v.analysis.FunctionData[obj] == nil {
-						v.analysis.FunctionData[obj] = &FunctionInfo{}
-					}
-					v.analysis.FunctionData[obj].NamedReturns = namedReturns
-				}
+	// Store named return variables (sanitized for TypeScript)
+	if n.Type != nil && n.Type.Results != nil {
+		var namedReturns []string
+		for _, field := range n.Type.Results.List {
+			for _, name := range field.Names {
+				namedReturns = append(namedReturns, sanitizeIdentifier(name.Name))
 			}
 		}
-
-		// Update visitor state for this function
-		v.inAsyncFunction = isAsync
-		v.currentFuncObj = v.pkg.TypesInfo.ObjectOf(n.Name)
-		v.analysis.NodeData[n].InAsyncContext = isAsync // Ensure FuncDecl node itself is marked
-
-		if n.Body != nil {
-			// Check if the body contains any defer statements
-			if v.containsDefer(n.Body) {
-				if v.analysis.NodeData[n] == nil {
-					v.analysis.NodeData[n] = &NodeInfo{}
-				}
-				v.analysis.NodeData[n].NeedsDefer = true
-			}
-
-			// Visit the body with updated state
-			ast.Walk(v, n.Body)
-		}
-
-		// Restore states after visiting
-		defer func() {
-			v.currentFuncName = ""
-			v.inAsyncFunction = originalInAsync
-			v.currentReceiver = originalReceiver
-			v.currentFuncObj = originalFuncObj
-			v.currentFuncDecl = originalFuncDecl
-			v.currentFuncLit = originalFuncLit
-		}()
-		return nil // Stop traversal here, ast.Walk handled the body
-
-	case *ast.FuncLit:
-		// Save original inAsyncFunction state to restore after visiting
-		originalInAsync := v.inAsyncFunction
-		originalFuncDecl := v.currentFuncDecl
-		originalFuncLit := v.currentFuncLit
-
-		// Set current function literal
-		v.currentFuncDecl = nil
-		v.currentFuncLit = n
-
-		// Determine if this function literal is async based on its body
-		isAsync := v.containsAsyncOperations(n.Body)
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
-		}
-		v.analysis.NodeData[n].InAsyncContext = isAsync
-
-		// Store named return variables for function literal
-		if n.Type != nil && n.Type.Results != nil {
-			var namedReturns []string
-			for _, field := range n.Type.Results.List {
-				for _, name := range field.Names {
-					namedReturns = append(namedReturns, name.Name)
-				}
-			}
-			if len(namedReturns) > 0 {
-				v.analysis.FuncLitData[n] = &FunctionInfo{
-					IsAsync:      isAsync,
-					NamedReturns: namedReturns,
-				}
+		if len(namedReturns) > 0 {
+			if obj := v.pkg.TypesInfo.ObjectOf(n.Name); obj != nil {
+				funcInfo := v.analysis.ensureFunctionData(obj)
+				funcInfo.NamedReturns = namedReturns
 			}
 		}
+	}
 
-		v.inAsyncFunction = isAsync
+	// Update visitor state for this function
+	v.inAsyncFunction = isAsync
+	v.currentFuncObj = v.pkg.TypesInfo.ObjectOf(n.Name)
 
+	if n.Body != nil {
 		// Check if the body contains any defer statements
-		if n.Body != nil && v.containsDefer(n.Body) {
-			if v.analysis.NodeData[n] == nil {
-				v.analysis.NodeData[n] = &NodeInfo{}
-			}
-			v.analysis.NodeData[n].NeedsDefer = true
+		if v.containsDefer(n.Body) {
+			nodeInfo.NeedsDefer = true
 		}
 
 		// Visit the body with updated state
 		ast.Walk(v, n.Body)
+	}
 
-		// Restore inAsyncFunction state after visiting
+	// Restore states after visiting
+	defer func() {
+		v.currentFuncName = ""
 		v.inAsyncFunction = originalInAsync
+		v.currentReceiver = originalReceiver
+		v.currentFuncObj = originalFuncObj
 		v.currentFuncDecl = originalFuncDecl
 		v.currentFuncLit = originalFuncLit
-		return nil // Stop traversal here, ast.Walk handled the body
+	}()
+	return nil // Stop traversal here, ast.Walk handled the body
+}
 
-	case *ast.BlockStmt:
-		if n == nil || len(n.List) == 0 {
-			break
+// visitFuncLit handles function literal analysis
+func (v *analysisVisitor) visitFuncLit(n *ast.FuncLit) ast.Visitor {
+	// Save original inAsyncFunction state to restore after visiting
+	originalInAsync := v.inAsyncFunction
+	originalFuncDecl := v.currentFuncDecl
+	originalFuncLit := v.currentFuncLit
+
+	// Set current function literal
+	v.currentFuncDecl = nil
+	v.currentFuncLit = n
+
+	// Determine if this function literal is async based on its body
+	isAsync := v.containsAsyncOperations(n.Body)
+	nodeInfo := v.analysis.ensureNodeData(n)
+	nodeInfo.InAsyncContext = isAsync
+
+	// Store named return variables for function literal
+	if n.Type != nil && n.Type.Results != nil {
+		var namedReturns []string
+		for _, field := range n.Type.Results.List {
+			for _, name := range field.Names {
+				namedReturns = append(namedReturns, name.Name)
+			}
 		}
-
-		// Initialize NodeData for this block
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
+		if len(namedReturns) > 0 {
+			v.analysis.FuncLitData[n] = &FunctionInfo{
+				IsAsync:      isAsync,
+				NamedReturns: namedReturns,
+			}
 		}
+	}
 
-		// Check for defer statements in this block
-		if v.containsDefer(n) {
-			v.analysis.NodeData[n].NeedsDefer = true
-		}
+	v.inAsyncFunction = isAsync
 
-		// Store async state for this block
-		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
+	// Check if the body contains any defer statements
+	if n.Body != nil && v.containsDefer(n.Body) {
+		nodeInfo.NeedsDefer = true
+	}
 
-		return v
+	// Visit the body with updated state
+	ast.Walk(v, n.Body)
 
-	case *ast.UnaryExpr:
-		// We handle address-of (&) within AssignStmt where it's actually used.
-		// Standalone &x doesn't directly assign, but its usage in assignments
-		// or function calls determines varRefing. Assignments are handled below.
-		// Function calls like foo(&x) would require different tracking if needed.
-		// TODO: for now, we focus on assignments
+	// Restore inAsyncFunction state after visiting
+	v.inAsyncFunction = originalInAsync
+	v.currentFuncDecl = originalFuncDecl
+	v.currentFuncLit = originalFuncLit
+	return nil // Stop traversal here, ast.Walk handled the body
+}
+
+// visitBlockStmt handles block statement analysis
+func (v *analysisVisitor) visitBlockStmt(n *ast.BlockStmt) ast.Visitor {
+	if n == nil || len(n.List) == 0 {
 		return v
+	}
 
-	case *ast.CallExpr:
-		// Check if this is a function call that might be async
-		if funcIdent, ok := n.Fun.(*ast.Ident); ok {
-			// Get the object for this function call
-			if obj := v.pkg.TypesInfo.Uses[funcIdent]; obj != nil && v.analysis.IsAsyncFunc(obj) {
-				// We're calling an async function, so mark current function as async if we're in one
-				if v.currentFuncObj != nil {
-					v.analysis.FunctionData[v.currentFuncObj] = &FunctionInfo{
-						IsAsync:      true,
-						NamedReturns: v.getNamedReturns(v.currentFuncDecl),
-					}
-					v.inAsyncFunction = true // Update visitor state
-					// Mark the FuncDecl node itself if possible (might need to store the node too)
-					for nodeAst := range v.analysis.NodeData { // Find the node to update
-						if fd, ok := nodeAst.(*ast.FuncDecl); ok && v.pkg.TypesInfo.ObjectOf(fd.Name) == v.currentFuncObj {
-							if v.analysis.NodeData[nodeAst] == nil {
-								v.analysis.NodeData[nodeAst] = &NodeInfo{}
-							}
-							v.analysis.NodeData[nodeAst].InAsyncContext = true
-						}
+	// Initialize NodeData for this block
+	nodeInfo := v.analysis.ensureNodeData(n)
+
+	// Check for defer statements in this block
+	if v.containsDefer(n) {
+		nodeInfo.NeedsDefer = true
+	}
+
+	return v
+}
+
+// visitCallExpr handles call expression analysis
+func (v *analysisVisitor) visitCallExpr(n *ast.CallExpr) ast.Visitor {
+	// Check if this is a function call that might be async
+	if funcIdent, ok := n.Fun.(*ast.Ident); ok {
+		// Get the object for this function call
+		if obj := v.pkg.TypesInfo.Uses[funcIdent]; obj != nil && v.analysis.IsAsyncFunc(obj) {
+			// We're calling an async function, so mark current function as async if we're in one
+			if v.currentFuncObj != nil {
+				funcInfo := v.analysis.ensureFunctionData(v.currentFuncObj)
+				funcInfo.IsAsync = true
+				funcInfo.NamedReturns = v.getNamedReturns(v.currentFuncDecl)
+				v.inAsyncFunction = true // Update visitor state
+				// Mark the FuncDecl node itself if possible
+				for nodeAst := range v.analysis.NodeData {
+					if fd, ok := nodeAst.(*ast.FuncDecl); ok && v.pkg.TypesInfo.ObjectOf(fd.Name) == v.currentFuncObj {
+						nodeInfo := v.analysis.ensureNodeData(nodeAst)
+						nodeInfo.InAsyncContext = true
 					}
 				}
 			}
 		}
+	}
 
-		// Check for reflect function calls that operate on functions
-		v.checkReflectUsage(n)
+	// Check for reflect function calls that operate on functions
+	v.checkReflectUsage(n)
 
-		// Store async state for this call expression
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
+	return v
+}
+
+// visitSelectorExpr handles selector expression analysis
+func (v *analysisVisitor) visitSelectorExpr(n *ast.SelectorExpr) ast.Visitor {
+	// Check if this is a method value (method being used as a value, not called immediately)
+	if selection := v.pkg.TypesInfo.Selections[n]; selection != nil {
+		if selection.Kind() == types.MethodVal {
+			// This is a method value - mark it for binding during code generation
+			nodeInfo := v.analysis.ensureNodeData(n)
+			nodeInfo.IsMethodValue = true
 		}
-		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
+	}
+	return v
+}
 
-		return v
+// visitAssignStmt handles assignment statement analysis
+func (v *analysisVisitor) visitAssignStmt(n *ast.AssignStmt) ast.Visitor {
+	// Handle variable assignment tracking and generate shadowing information
+	shadowingInfo := v.detectVariableShadowing(n)
 
-	case *ast.SelectorExpr:
-		// Initialize NodeData for this selector expression
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
-		}
-		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
+	// Store shadowing information if needed for code generation
+	if shadowingInfo != nil {
+		nodeInfo := v.analysis.ensureNodeData(n)
+		nodeInfo.ShadowingInfo = shadowingInfo
+	}
 
-		// Check if this is a method value (method being used as a value, not called immediately)
-		if selection := v.pkg.TypesInfo.Selections[n]; selection != nil {
-			if selection.Kind() == types.MethodVal {
-				// This is a method value - mark it for binding during code generation
-				v.analysis.NodeData[n].IsMethodValue = true
-			}
+	// Track assignment relationships for pointer analysis
+	for i, lhsExpr := range n.Lhs {
+		if i < len(n.Rhs) {
+			v.analyzeAssignment(lhsExpr, n.Rhs[i])
 		}
-		return v // Continue traversal
+	}
 
-	case *ast.AssignStmt:
-		// Detect variable shadowing in any := assignment
-		if n.Tok == token.DEFINE {
-			shadowingInfo := v.detectVariableShadowing(n)
-			if shadowingInfo != nil {
-				// Store shadowing info on the assignment statement itself
-				if v.analysis.NodeData[n] == nil {
-					v.analysis.NodeData[n] = &NodeInfo{}
+	// Track interface implementations for assignments to interface variables
+	v.trackInterfaceAssignments(n)
+
+	// Track function assignments (function literals assigned to variables)
+	if len(n.Lhs) == 1 && len(n.Rhs) == 1 {
+		if lhsIdent, ok := n.Lhs[0].(*ast.Ident); ok {
+			if rhsFuncLit, ok := n.Rhs[0].(*ast.FuncLit); ok {
+				// Get the object for the LHS variable
+				if obj := v.pkg.TypesInfo.ObjectOf(lhsIdent); obj != nil {
+					v.analysis.FunctionAssignments[obj] = rhsFuncLit
 				}
-				v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
 			}
 		}
+	}
 
-		// Continue with the existing assignment analysis logic
-		for i, currentLHSExpr := range n.Lhs {
-			if i >= len(n.Rhs) {
-				break // Should not happen in valid Go
-			}
-			currentRHSExpr := n.Rhs[i]
-
-			// --- Analyze RHS to determine assignment type and source object (if any) ---
-			rhsAssignmentType := DirectAssignment
-			var rhsSourceObj types.Object // The variable object on the RHS (e.g., 'y' in x = y or x = &y)
-
-			if unaryExpr, ok := currentRHSExpr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
-				// RHS is &some_expr
-				rhsAssignmentType = AddressOfAssignment
-				if rhsIdent, ok := unaryExpr.X.(*ast.Ident); ok {
-					// RHS is &variable
-					rhsSourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
-				}
-				// If RHS is &structLit{} or &array[0], rhsSourceObj remains nil.
-				// _, ok := unaryExpr.X.(*ast.CompositeLit); ok
-			} else if rhsIdent, ok := currentRHSExpr.(*ast.Ident); ok {
-				// RHS is variable
-				rhsAssignmentType = DirectAssignment
-				rhsSourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
-			}
-			// If RHS is a literal, function call, etc., rhsSourceObj remains nil.
+	return v
+}
 
-			// --- Determine the LHS object (if it's a simple variable or a known field) ---
-			var lhsTrackedObj types.Object // The object on the LHS we might record info *for* (e.g. its sources)
+// visitReturnStmt handles return statement analysis
+func (v *analysisVisitor) visitReturnStmt(n *ast.ReturnStmt) ast.Visitor {
+	nodeInfo := v.analysis.ensureNodeData(n)
 
-			if lhsIdent, ok := currentLHSExpr.(*ast.Ident); ok {
-				if lhsIdent.Name == "_" {
-					continue // Skip blank identifier assignments
-				}
-				lhsTrackedObj = v.pkg.TypesInfo.ObjectOf(lhsIdent)
+	// Record the enclosing function/literal for this return statement
+	if v.currentFuncDecl != nil {
+		nodeInfo.EnclosingFuncDecl = v.currentFuncDecl
+	} else if v.currentFuncLit != nil {
+		nodeInfo.EnclosingFuncLit = v.currentFuncLit
+	}
 
-				// Check if RHS is a function literal and track the assignment
-				if funcLit, ok := currentRHSExpr.(*ast.FuncLit); ok {
-					v.analysis.FunctionAssignments[lhsTrackedObj] = funcLit
-				}
-			} else if selExpr, ok := currentLHSExpr.(*ast.SelectorExpr); ok {
-				// LHS is struct.field or package.Var
-				if selection := v.pkg.TypesInfo.Selections[selExpr]; selection != nil {
-					lhsTrackedObj = selection.Obj() // This is the field or selected var object
-				}
-			} /* else if _, ok := currentLHSExpr.(*ast.StarExpr); ok {
-				// LHS is *pointer.
-				// We don't try to get a types.Object for the dereferenced entity itself to store in VariableUsage.
-				// lhsTrackedObj remains nil. The effect on rhsSourceObj (if its address is taken) is handled below.
-			} */
-			// For other complex LHS (e.g., map_expr[key_expr]), lhsTrackedObj remains nil.
-
-			// --- Record Usage Information ---
-
-			// 1. If LHS is a trackable variable/field, record what's assigned to it (its sources).
-			// We only want to create VariableUsage entries for actual variables/fields.
-			if _, isVar := lhsTrackedObj.(*types.Var); isVar {
-				lhsUsageInfo := v.getOrCreateUsageInfo(lhsTrackedObj)
-				if rhsSourceObj != nil {
-					// Case: var1 = var2  OR  var1 = &var2 OR field1 = var2 OR field1 = &var2
-					lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
-						Object: rhsSourceObj,
-						Type:   rhsAssignmentType,
-					})
-				} else if rhsAssignmentType == AddressOfAssignment {
-					// Case: var1 = &non_ident_expr (e.g., &T{}) OR field1 = &non_ident_expr
-					// lhsTrackedObj is assigned an address, but not of a named variable.
-					lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
-						Object: nil, // No specific source variable object
-						Type:   rhsAssignmentType,
-					})
+	// 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
 				}
-				// If rhsSourceObj is nil and rhsAssignmentType is DirectAssignment (e.g. var1 = 10),
-				// no source object to record for LHS sources.
 			}
-
-			// 2. If RHS involved a source variable (rhsSourceObj is not nil),
-			//    record that this source variable was used (its destinations).
-			//    This is CRITICAL for varRefing analysis (e.g., if &rhsSourceObj was assigned).
-			if rhsSourceObj != nil {
-				sourceUsageInfo := v.getOrCreateUsageInfo(rhsSourceObj)
-				// The 'Object' in DestinationInfo is what/where rhsSourceObj (or its address) was assigned TO.
-				// This can be lhsTrackedObj (if LHS was an ident or field).
-				// If LHS was complex (e.g., *ptr, map[k]), lhsTrackedObj might be nil for that DestinationInfo.Object.
-				// Even if lhsTrackedObj is nil for the DestinationInfo.Object, if rhsAssignmentType is AddressOfAssignment,
-				// it's important to record that rhsSourceObj's address was taken.
-				sourceUsageInfo.Destinations = append(sourceUsageInfo.Destinations, AssignmentInfo{
-					Object: lhsTrackedObj, // This can be nil if LHS is complex (*p, map[k])
-					Type:   rhsAssignmentType,
-				})
-			}
-		}
-		return v // Continue traversal
-
-	case *ast.ReturnStmt:
-		// Initialize NodeData for return statement
-		if v.analysis.NodeData[n] == nil {
-			v.analysis.NodeData[n] = &NodeInfo{}
-		}
-
-		// Record the enclosing function/literal for this return statement
-		if v.currentFuncDecl != nil {
-			v.analysis.NodeData[n].EnclosingFuncDecl = v.currentFuncDecl
 		} else if v.currentFuncLit != nil {
-			v.analysis.NodeData[n].EnclosingFuncLit = v.currentFuncLit
-		}
-
-		// 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 {
-						if v.analysis.NodeData[n] == nil {
-							v.analysis.NodeData[n] = &NodeInfo{}
-						}
-						v.analysis.NodeData[n].IsBareReturn = true
-					}
-				}
-			} else if v.currentFuncLit != nil {
-				// Check if the enclosing function literal has named returns
-				if _, ok := v.analysis.FuncLitData[v.currentFuncLit]; ok {
-					if v.analysis.NodeData[n] == nil {
-						v.analysis.NodeData[n] = &NodeInfo{}
-					}
-					v.analysis.NodeData[n].IsBareReturn = true
-				}
+			// Check if the enclosing function literal has named returns
+			if _, ok := v.analysis.FuncLitData[v.currentFuncLit]; ok {
+				nodeInfo.IsBareReturn = true
 			}
 		}
-		return v // Continue traversal
+	}
+	return v
+}
 
-	case *ast.DeclStmt:
-		// Handle declarations inside functions (const, var, type declarations within function bodies)
-		// These should not have export modifiers in TypeScript
-		if genDecl, ok := n.Decl.(*ast.GenDecl); ok {
-			// 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 {
-					if v.analysis.NodeData[spec] == nil {
-						v.analysis.NodeData[spec] = &NodeInfo{}
-					}
-					v.analysis.NodeData[spec].IsInsideFunction = true
-				}
+// visitDeclStmt handles declaration statement analysis
+func (v *analysisVisitor) visitDeclStmt(n *ast.DeclStmt) ast.Visitor {
+	// Handle declarations inside functions (const, var, type declarations within function bodies)
+	// These should not have export modifiers in TypeScript
+	if genDecl, ok := n.Decl.(*ast.GenDecl); ok {
+		// 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 {
+				nodeInfo := v.analysis.ensureNodeData(spec)
+				nodeInfo.IsInsideFunction = true
 			}
 		}
-		return v // Continue traversal
+	}
+	return v
+}
 
-	case *ast.IfStmt:
-		// Detect variable shadowing in if statement initializations
-		if n.Init != nil {
-			if assignStmt, ok := n.Init.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
-				shadowingInfo := v.detectVariableShadowing(assignStmt)
-				if shadowingInfo != nil {
-					// Initialize NodeData for this if statement
-					if v.analysis.NodeData[n] == nil {
-						v.analysis.NodeData[n] = &NodeInfo{}
-					}
-					v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
-				}
+// visitIfStmt handles if statement analysis
+func (v *analysisVisitor) visitIfStmt(n *ast.IfStmt) ast.Visitor {
+	// Detect variable shadowing in if statement initializations
+	if n.Init != nil {
+		if assignStmt, ok := n.Init.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
+			shadowingInfo := v.detectVariableShadowing(assignStmt)
+			if shadowingInfo != nil {
+				nodeInfo := v.analysis.ensureNodeData(n)
+				nodeInfo.ShadowingInfo = shadowingInfo
 			}
 		}
-		return v // Continue traversal
 	}
+	return v
+}
 
-	// For all other nodes, continue traversal
+// visitTypeAssertExpr handles type assertion expression analysis
+func (v *analysisVisitor) visitTypeAssertExpr(n *ast.TypeAssertExpr) ast.Visitor {
+	// Track interface implementations when we see type assertions
+	v.trackTypeAssertion(n)
 	return v
 }
 
@@ -947,11 +935,11 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 
 								// Check if the type is from an imported package
 								if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != v.pkg.Types {
-									// Use the actual package name from the type information
-									pkgName := typePkg.Name()
+									// Use the full package path from the type information (not just the package name)
+									pkgPath := typePkg.Path()
 
 									// Check if this method is async based on metadata
-									if v.analysis.IsMethodAsync(pkgName, typeName, methodName) {
+									if v.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
 										hasAsync = true
 										return false
 									}
@@ -1057,99 +1045,113 @@ func (v *analysisVisitor) couldImplementInterfaceMethod(methodName string, recei
 	return false
 }
 
-// AnalyzeFile analyzes a Go source file AST and populates the Analysis struct with information
-// that will be used during code generation to properly handle pointers, variables that need varRefing, etc.
-func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap ast.CommentMap) {
-	// Store the comment map in the analysis object
-	analysis.Cmap = cmap
+// AnalyzePackageFiles analyzes all Go source files in a package and populates the Analysis struct
+// with information that will be used during code generation to properly handle pointers,
+// variables that need varRefing, receiver usage, etc. This replaces the old file-by-file analysis.
+func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages.Package) *Analysis {
+	analysis := NewAnalysis(allPackages)
 
 	// Load package metadata for async function detection
 	analysis.LoadPackageMetadata()
 
-	// Process imports from the file
-	for _, imp := range file.Imports {
-		path := ""
-		if imp.Path != nil {
-			path = imp.Path.Value
-			// Remove quotes from the import path string
-			path = path[1 : len(path)-1]
+	// Process imports from all files in the package
+	for _, file := range pkg.Syntax {
+		// Create comment map for each file and store it (we'll merge them if needed)
+		cmap := ast.NewCommentMap(pkg.Fset, file, file.Comments)
+		if len(analysis.Cmap) == 0 {
+			analysis.Cmap = cmap
+		} else {
+			// Merge comment maps from multiple files
+			for node, comments := range cmap {
+				analysis.Cmap[node] = append(analysis.Cmap[node], comments...)
+			}
 		}
 
-		// Store the import in the analysis
-		if path != "" {
-			name := ""
-			if imp.Name != nil {
-				name = imp.Name.Name
+		// Process imports from this file
+		for _, imp := range file.Imports {
+			path := ""
+			if imp.Path != nil {
+				path = imp.Path.Value
+				// Remove quotes from the import path string
+				path = path[1 : len(path)-1]
 			}
 
-			fileImp := &fileImport{
-				importPath: path,
-				importVars: make(map[string]struct{}),
-			}
+			// Store the import in the analysis
+			if path != "" {
+				name := ""
+				if imp.Name != nil {
+					name = imp.Name.Name
+				}
 
-			// Use the import name or the actual package name as the key
-			var key string
-			if name != "" {
-				// Explicit alias provided
-				key = name
-			} else {
-				// No explicit alias, use the actual package name from type information
-				// This handles cases where package name differs from the last path segment
-				if actualName, err := getActualPackageName(path, pkg.Imports); err == nil {
-					key = actualName
+				fileImp := &fileImport{
+					importPath: path,
+					importVars: make(map[string]struct{}),
+				}
+
+				// Use the import name or the actual package name as the key
+				var key string
+				if name != "" {
+					// Explicit alias provided
+					key = name
 				} else {
-					// Fallback to last segment of path if package not found in type information
-					pts := strings.Split(path, "/")
-					key = pts[len(pts)-1]
+					// No explicit alias, use the actual package name from type information
+					// This handles cases where package name differs from the last path segment
+					if actualName, err := getActualPackageName(path, pkg.Imports); err == nil {
+						key = actualName
+					} else {
+						// Fallback to last segment of path if package not found in type information
+						pts := strings.Split(path, "/")
+						key = pts[len(pts)-1]
+					}
 				}
-			}
 
-			analysis.Imports[key] = fileImp
+				analysis.Imports[key] = fileImp
+			}
 		}
 	}
 
-	// Create an analysis visitor to traverse the AST
+	// Create visitor for the entire package
 	visitor := &analysisVisitor{
-		analysis:        analysis,
-		pkg:             pkg,
-		inAsyncFunction: false,
-		currentReceiver: nil, // Initialize currentReceiver
+		analysis: analysis,
+		pkg:      pkg,
 	}
 
-	// Walk the AST with our visitor
-	ast.Walk(visitor, file)
+	// First pass: analyze all declarations and statements across all files
+	for _, file := range pkg.Syntax {
+		ast.Walk(visitor, file)
+	}
 
 	// Post-processing: Find all CallExpr nodes and unmark their Fun SelectorExpr as method values
 	// This distinguishes between method calls (obj.Method()) and method values (obj.Method)
-	ast.Inspect(file, func(n ast.Node) bool {
-		if callExpr, ok := n.(*ast.CallExpr); ok {
-			if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
-				// This SelectorExpr is the function being called, so it's NOT a method value
-				if nodeInfo := analysis.NodeData[selExpr]; nodeInfo != nil {
-					nodeInfo.IsMethodValue = false
+	for _, file := range pkg.Syntax {
+		ast.Inspect(file, func(n ast.Node) bool {
+			if callExpr, ok := n.(*ast.CallExpr); ok {
+				if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+					// This SelectorExpr is the function being called, so it's NOT a method value
+					if nodeInfo := analysis.NodeData[selExpr]; nodeInfo != nil {
+						nodeInfo.IsMethodValue = false
+					}
 				}
 			}
-		}
-		return true
-	})
-}
+			return true
+		})
+	}
 
-// 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)
-			}
-		}
+	// Second pass: analyze interface implementations now that all function async status is determined
+	interfaceVisitor := &interfaceImplementationVisitor{
+		analysis: analysis,
+		pkg:      pkg,
 	}
-	return namedReturns
+	for _, file := range pkg.Syntax {
+		ast.Walk(interfaceVisitor, file)
+	}
+
+	return analysis
 }
 
-// AnalyzePackage performs package-level analysis to collect function definitions
+// AnalyzePackageImports performs package-level analysis to collect function definitions
 // and calls across all files in the package for auto-import generation
-func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
+func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 	analysis := NewPackageAnalysis()
 
 	// First pass: collect all function definitions per file
@@ -1315,10 +1317,6 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 
 // LoadPackageMetadata loads metadata from gs packages using embedded JSON files
 func (a *Analysis) LoadPackageMetadata() {
-	// Use the embedded filesystem from gs.go
-	// The GsOverrides embed.FS should be available but we need to import it
-	// For now, let's iterate through known packages and load their meta.json files
-
 	// Discover all packages in the embedded gs/ directory
 	packagePaths := a.discoverEmbeddedGsPackages()
 
@@ -1336,10 +1334,16 @@ func (a *Analysis) LoadPackageMetadata() {
 					typeName := parts[0]
 					methodName := parts[1]
 					// The key format is "pkgName.TypeNameMethodNameInfo"
-					key := pkgPath + "." + typeName + methodName + "Info"
+					key := PackageMetadataKey{
+						PackagePath: pkgPath,
+						TypeName:    typeName,
+						MethodName:  methodName,
+					}
 
 					// Store the async value directly in PackageMetadata
-					a.PackageMetadata[key] = isAsync
+					a.PackageMetadata[key] = MethodMetadata{
+						IsAsync: isAsync,
+					}
 				}
 			}
 		}
@@ -1391,20 +1395,122 @@ func (a *Analysis) loadGsMetadata(metaFilePath string) *GsMetadata {
 }
 
 // IsMethodAsync checks if a method call is async based on package metadata
-func (a *Analysis) IsMethodAsync(pkgName, typeName, methodName string) bool {
+func (a *Analysis) IsMethodAsync(pkgPath, typeName, methodName string) bool {
+	// First, check existing metadata for internal packages
 	// The metadata keys are stored as "pkgName.TypeNameMethodNameInfo"
 	// e.g., "sync.MutexLockInfo", "sync.WaitGroupWaitInfo", etc.
-	key := pkgName + "." + typeName + methodName + "Info"
+	key := PackageMetadataKey{
+		PackagePath: pkgPath,
+		TypeName:    typeName,
+		MethodName:  methodName,
+	}
 
-	if asyncValue, exists := a.PackageMetadata[key]; exists {
-		if isAsync, ok := asyncValue.(bool); ok {
-			return isAsync
+	if metadata, exists := a.PackageMetadata[key]; exists {
+		return metadata.IsAsync
+	}
+
+	// If no metadata found, check if we can analyze the method from dependency packages
+	return a.analyzeExternalMethodAsync(pkgPath, typeName, methodName)
+}
+
+// analyzeExternalMethodAsync analyzes external package methods to determine if they're async
+// using the same logic we use for internal methods
+func (a *Analysis) analyzeExternalMethodAsync(pkgPath, typeName, methodName string) bool {
+	// Look up the package in our loaded packages
+	pkg, exists := a.AllPackages[pkgPath]
+	if !exists {
+		return false
+	}
+
+	// Find the method definition in the package
+	for _, syntax := range pkg.Syntax {
+		for _, decl := range syntax.Decls {
+			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
+				// Check if this is a method with the right name and receiver type
+				if funcDecl.Name.Name == methodName && funcDecl.Recv != nil {
+					// Check the receiver type
+					if len(funcDecl.Recv.List) > 0 {
+						receiverType := funcDecl.Recv.List[0].Type
+
+						// Handle pointer receivers
+						if starExpr, ok := receiverType.(*ast.StarExpr); ok {
+							receiverType = starExpr.X
+						}
+
+						if ident, ok := receiverType.(*ast.Ident); ok {
+							if ident.Name == typeName {
+								// Found the method! Now check if it's async
+								if funcDecl.Body != nil {
+									return a.containsAsyncOperations(funcDecl.Body, pkg)
+								}
+							}
+						}
+					}
+				}
+			}
 		}
 	}
 
 	return false
 }
 
+// containsAsyncOperations checks if a node contains any async operations for a specific package
+func (a *Analysis) containsAsyncOperations(node ast.Node, pkg *packages.Package) bool {
+	var hasAsync bool
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return false
+		}
+
+		switch s := n.(type) {
+		case *ast.SendStmt:
+			// Channel send operation (ch <- value)
+			hasAsync = true
+			return false
+
+		case *ast.UnaryExpr:
+			// Channel receive operation (<-ch)
+			if s.Op == token.ARROW {
+				hasAsync = true
+				return false
+			}
+
+		case *ast.CallExpr:
+			// Check for select statements and other async operations
+			if ident, ok := s.Fun.(*ast.Ident); ok {
+				// Look for calls to select-related functions or other async operations
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					// Check if this function is from the context package (like context.Background, etc.)
+					if obj.Pkg() != nil && obj.Pkg().Path() == "context" {
+						hasAsync = true
+						return false
+					}
+				}
+			}
+
+			// Check if the method takes a context parameter, which usually indicates async behavior
+			if len(s.Args) > 0 {
+				for _, arg := range s.Args {
+					if argType := pkg.TypesInfo.TypeOf(arg); argType != nil {
+						if named, ok := argType.(*types.Named); ok {
+							if named.Obj() != nil && named.Obj().Pkg() != nil &&
+								named.Obj().Pkg().Path() == "context" && named.Obj().Name() == "Context" {
+								hasAsync = true
+								return false
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return true
+	})
+
+	return hasAsync
+}
+
 // NeedsReflectionMetadata returns whether the given function node needs reflection type metadata
 func (a *Analysis) NeedsReflectionMetadata(node ast.Node) bool {
 	if node == nil {
@@ -1602,117 +1708,106 @@ func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map
 	}
 }
 
-// IsWrapperType returns whether the given type should be implemented as a wrapper class
-// This includes both local types with methods and imported types that are known wrapper types
-func (a *Analysis) IsWrapperType(t types.Type) bool {
-	if t == nil {
-		return false
+// 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) {
+	key := InterfaceMethodKey{
+		InterfaceType: interfaceType.String(),
+		MethodName:    method.Name(),
 	}
 
-	// Check if we've already determined this type is a wrapper type
-	if isWrapper, exists := a.WrapperTypes[t]; exists {
-		return isWrapper
+	implementation := ImplementationInfo{
+		StructType:    structType,
+		Method:        method,
+		IsAsyncByFlow: isAsync,
 	}
 
-	// For named types, check if they have methods and underlying primitive types
-	if namedType, ok := t.(*types.Named); ok {
-		// Exclude struct types - they should remain as classes, not wrapper types
-		if _, isStruct := namedType.Underlying().(*types.Struct); isStruct {
-			a.WrapperTypes[t] = false
-			return false
-		}
+	a.InterfaceImplementations[key] = append(a.InterfaceImplementations[key], implementation)
+}
 
-		// Exclude interface types
-		if _, isInterface := namedType.Underlying().(*types.Interface); isInterface {
-			a.WrapperTypes[t] = false
-			return false
-		}
+// IsInterfaceMethodAsync determines if an interface method should be async based on its implementations
+func (a *Analysis) IsInterfaceMethodAsync(interfaceType *types.Interface, methodName string) bool {
+	key := InterfaceMethodKey{
+		InterfaceType: interfaceType.String(),
+		MethodName:    methodName,
+	}
 
-		// Check if this type has methods defined on it
-		if namedType.NumMethods() > 0 {
-			// Additional check: the underlying type should be a basic type (primitive)
-			// This distinguishes wrapper types from complex types with methods
-			underlying := namedType.Underlying()
+	// Check if we've already computed this
+	if result, exists := a.InterfaceMethodAsyncStatus[key]; exists {
+		return result
+	}
 
-			if isBasicType(underlying) {
-				a.WrapperTypes[t] = true
-				return true
-			}
+	// 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
+	}
 
-			// For non-basic underlying types with methods, still consider them wrapper types
-			// if they're not structs or interfaces (already excluded above)
-			a.WrapperTypes[t] = true
+	// If ANY implementation is async, the interface method is async
+	for _, impl := range implementations {
+		if impl.IsAsyncByFlow {
+			a.InterfaceMethodAsyncStatus[key] = true
 			return true
 		}
 	}
 
-	// Handle type aliases (Go 1.9+)
-	if aliasType, ok := t.(*types.Alias); ok {
-		// For type aliases, we need to check the RHS (right-hand side) type
-		// For example, if we have: type FileMode = fs.FileMode
-		// We need to check if fs.FileMode has methods
-		rhs := aliasType.Rhs()
-
-		if rhsNamed, ok := rhs.(*types.Named); ok {
-			// Check if the RHS named type has methods and a basic underlying type
-			if rhsNamed.NumMethods() > 0 {
-				underlying := rhsNamed.Underlying()
-
-				// Exclude struct types
-				if _, isStruct := underlying.(*types.Struct); isStruct {
-					a.WrapperTypes[t] = false
-					return false
-				}
+	// All implementations are sync
+	a.InterfaceMethodAsyncStatus[key] = false
+	return false
+}
 
-				// Exclude interface types
-				if _, isInterface := underlying.(*types.Interface); isInterface {
-					a.WrapperTypes[t] = false
-					return false
-				}
+// MustBeAsyncDueToInterface checks if a struct method must be async due to interface constraints
+func (a *Analysis) MustBeAsyncDueToInterface(structType *types.Named, methodName string) bool {
+	// Find all interfaces that this struct implements
+	for key, implementations := range a.InterfaceImplementations {
+		if key.MethodName != methodName {
+			continue
+		}
 
-				if isBasicType(underlying) {
-					a.WrapperTypes[t] = true
+		// Check if this struct is among the implementations
+		for _, impl := range implementations {
+			if impl.StructType == structType {
+				// This struct implements this interface method
+				// Check if the interface method is marked as async
+				interfaceType := a.findInterfaceTypeByString(key.InterfaceType)
+				if interfaceType != nil && a.IsInterfaceMethodAsync(interfaceType, methodName) {
 					return true
 				}
-
-				// For non-basic underlying types with methods, still consider them wrapper types
-				// if they're not structs or interfaces (already excluded above)
-				a.WrapperTypes[t] = true
-				return true
-			}
-		}
-
-		// Fallback: check the underlying type for older Go versions or different alias patterns
-		underlying := aliasType.Underlying()
-		if namedUnderlying, ok := underlying.(*types.Named); ok {
-			if namedUnderlying.NumMethods() > 0 && isBasicType(namedUnderlying.Underlying()) {
-				a.WrapperTypes[t] = true
-				return true
 			}
 		}
 	}
 
-	// Cache negative result
-	a.WrapperTypes[t] = false
 	return false
 }
 
-// isBasicType checks if a type is a basic/primitive type
-func isBasicType(t types.Type) bool {
-	if t == nil {
-		return false
-	}
-
-	switch underlying := t.(type) {
-	case *types.Basic:
-		// Basic types like int, string, bool, etc.
-		return true
-	case *types.Pointer:
-		// Pointers to basic types could also be considered for wrapper types
-		return isBasicType(underlying.Elem())
-	default:
-		return false
+// findInterfaceTypeByString finds an interface type by its string representation
+// This is a helper method for MustBeAsyncDueToInterface
+func (a *Analysis) findInterfaceTypeByString(interfaceString string) *types.Interface {
+	// This is a simplified implementation - in practice, we might need to store
+	// the actual interface types in our tracking data structure
+	for _, pkg := range a.AllPackages {
+		for _, syntax := range pkg.Syntax {
+			for _, decl := range syntax.Decls {
+				if genDecl, ok := decl.(*ast.GenDecl); ok {
+					for _, spec := range genDecl.Specs {
+						if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+							if interfaceType, ok := typeSpec.Type.(*ast.InterfaceType); ok {
+								if goType := pkg.TypesInfo.TypeOf(interfaceType); goType != nil {
+									if iface, ok := goType.(*types.Interface); ok {
+										if iface.String() == interfaceString {
+											return iface
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
 	}
+	return nil
 }
 
 // GetReceiverMapping returns the receiver variable mapping for a function declaration
@@ -1742,3 +1837,354 @@ 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 based on control flow analysis
+			isAsync := false
+			if obj := structMethod; obj != nil {
+				if funcInfo := v.analysis.FunctionData[obj]; funcInfo != nil {
+					isAsync = funcInfo.IsAsync
+				}
+			}
+
+			// 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
+	for i := 0; i < namedType.NumMethods(); i++ {
+		method := namedType.Method(i)
+		if method.Name() == methodName {
+			return method
+		}
+	}
+	return nil
+}
+
+// analyzeAssignment analyzes a single assignment for pointer analysis
+func (v *analysisVisitor) analyzeAssignment(lhsExpr, rhsExpr ast.Expr) {
+	// Determine RHS assignment type and source object
+	rhsAssignmentType := DirectAssignment
+	var rhsSourceObj types.Object
+
+	if unaryExpr, ok := rhsExpr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
+		// RHS is &some_expr
+		rhsAssignmentType = AddressOfAssignment
+		if rhsIdent, ok := unaryExpr.X.(*ast.Ident); ok {
+			rhsSourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
+		}
+	} else if rhsIdent, ok := rhsExpr.(*ast.Ident); ok {
+		// RHS is variable
+		rhsAssignmentType = DirectAssignment
+		rhsSourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
+	}
+
+	// Determine LHS object
+	var lhsTrackedObj types.Object
+
+	if lhsIdent, ok := lhsExpr.(*ast.Ident); ok {
+		if lhsIdent.Name != "_" {
+			lhsTrackedObj = v.pkg.TypesInfo.ObjectOf(lhsIdent)
+		}
+	} else if selExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+		if selection := v.pkg.TypesInfo.Selections[selExpr]; selection != nil {
+			lhsTrackedObj = selection.Obj()
+		}
+	}
+
+	// Record usage information
+	if _, isVar := lhsTrackedObj.(*types.Var); isVar {
+		lhsUsageInfo := v.getOrCreateUsageInfo(lhsTrackedObj)
+		if rhsSourceObj != nil {
+			lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
+				Object: rhsSourceObj,
+				Type:   rhsAssignmentType,
+			})
+		} else if rhsAssignmentType == AddressOfAssignment {
+			lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
+				Object: nil,
+				Type:   rhsAssignmentType,
+			})
+		}
+	}
+
+	if rhsSourceObj != nil {
+		sourceUsageInfo := v.getOrCreateUsageInfo(rhsSourceObj)
+		sourceUsageInfo.Destinations = append(sourceUsageInfo.Destinations, AssignmentInfo{
+			Object: lhsTrackedObj,
+			Type:   rhsAssignmentType,
+		})
+	}
+}
+
+// trackInterfaceAssignments tracks interface implementations in assignment statements
+func (v *analysisVisitor) trackInterfaceAssignments(assignStmt *ast.AssignStmt) {
+	// For each assignment, check if we're assigning a struct to an interface variable
+	for i, lhsExpr := range assignStmt.Lhs {
+		if i >= len(assignStmt.Rhs) {
+			continue
+		}
+		rhsExpr := assignStmt.Rhs[i]
+
+		// Get the type of the LHS (destination)
+		lhsType := v.pkg.TypesInfo.TypeOf(lhsExpr)
+		if lhsType == nil {
+			continue
+		}
+
+		// Check if LHS is an interface type
+		interfaceType, isInterface := lhsType.Underlying().(*types.Interface)
+		if !isInterface {
+			continue
+		}
+
+		// Get the type of the RHS (source)
+		rhsType := v.pkg.TypesInfo.TypeOf(rhsExpr)
+		if rhsType == nil {
+			continue
+		}
+
+		// Handle pointer types
+		if ptrType, isPtr := rhsType.(*types.Pointer); isPtr {
+			rhsType = ptrType.Elem()
+		}
+
+		// Check if RHS is a named struct type
+		namedType, isNamed := rhsType.(*types.Named)
+		if !isNamed {
+			continue
+		}
+
+		// Track implementations for all interface methods
+		for j := 0; j < interfaceType.NumExplicitMethods(); j++ {
+			interfaceMethod := interfaceType.ExplicitMethod(j)
+
+			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
+			if structMethod != nil {
+				// Determine if this struct method is async
+				isAsync := false
+				if funcInfo := v.analysis.FunctionData[structMethod]; funcInfo != nil {
+					isAsync = funcInfo.IsAsync
+				}
+
+				v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+			}
+		}
+	}
+}
+
+// IsNamedBasicType returns whether the given type should be implemented as a type alias with standalone functions
+// This applies to named types with basic underlying types (like uint32, string, etc.) that have methods
+// It excludes struct types, which should remain as classes
+func (a *Analysis) IsNamedBasicType(t types.Type) bool {
+	if t == nil {
+		return false
+	}
+
+	// Check if we already have this result cached
+	if result, exists := a.NamedBasicTypes[t]; exists {
+		return result
+	}
+
+	var originalType types.Type = t
+	var foundMethods bool
+
+	// Traverse the type chain to find any type with methods
+	for {
+		switch typed := t.(type) {
+		case *types.Named:
+			// Built-in types cannot be named basic types
+			if typed.Obj().Pkg() == nil {
+				return false
+			}
+
+			// Check if this named type has methods
+			if typed.NumMethods() > 0 {
+				foundMethods = true
+			}
+
+			// Check underlying type
+			underlying := typed.Underlying()
+			switch underlying.(type) {
+			case *types.Struct, *types.Interface:
+				return false
+			}
+			t = underlying
+
+		case *types.Alias:
+			// Built-in types cannot be named basic types
+			if typed.Obj().Pkg() == nil {
+				return false
+			}
+			t = typed.Underlying()
+
+		default:
+			// We've reached a non-named, non-alias type
+			// Check if it's a supported type with methods
+			switch t.(type) {
+			case *types.Basic, *types.Slice, *types.Array, *types.Map:
+				if foundMethods {
+					a.NamedBasicTypes[originalType] = true
+					return true
+				}
+				return false
+			default:
+				return false
+			}
+		}
+	}
+}
+
+// interfaceImplementationVisitor performs a second pass to analyze interface implementations
+type interfaceImplementationVisitor struct {
+	analysis *Analysis
+	pkg      *packages.Package
+}
+
+func (v *interfaceImplementationVisitor) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case *ast.GenDecl:
+		// Look for interface type specifications
+		for _, spec := range n.Specs {
+			if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+				if interfaceType, ok := typeSpec.Type.(*ast.InterfaceType); ok {
+					// This is an interface declaration, find all potential implementations
+					v.findInterfaceImplementations(interfaceType)
+				}
+			}
+		}
+	}
+	return v
+}
+
+// findInterfaceImplementations finds all struct types that implement the given interface
+func (v *interfaceImplementationVisitor) findInterfaceImplementations(interfaceAST *ast.InterfaceType) {
+	// Get the interface type from TypesInfo
+	interfaceGoType := v.pkg.TypesInfo.TypeOf(interfaceAST)
+	if interfaceGoType == nil {
+		return
+	}
+
+	interfaceType, ok := interfaceGoType.(*types.Interface)
+	if !ok {
+		return
+	}
+
+	// Look through all packages for potential implementations
+	for _, pkg := range v.analysis.AllPackages {
+		v.findImplementationsInPackage(interfaceType, pkg)
+	}
+}
+
+// findImplementationsInPackage finds implementations of an interface in a specific package
+func (v *interfaceImplementationVisitor) findImplementationsInPackage(interfaceType *types.Interface, pkg *packages.Package) {
+	// Get all named types in the package
+	scope := pkg.Types.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj == nil {
+			continue
+		}
+
+		// Check if this is a type name
+		typeName, ok := obj.(*types.TypeName)
+		if !ok {
+			continue
+		}
+
+		namedType, ok := typeName.Type().(*types.Named)
+		if !ok {
+			continue
+		}
+
+		// Check if this type implements the interface
+		if types.Implements(namedType, interfaceType) || types.Implements(types.NewPointer(namedType), interfaceType) {
+			v.trackImplementation(interfaceType, namedType)
+		}
+	}
+}
+
+// trackImplementation records that a named type implements an interface
+func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *types.Interface, namedType *types.Named) {
+	// For each method in the interface, find the corresponding implementation
+	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
+		interfaceMethod := interfaceType.ExplicitMethod(i)
+
+		// Find the method in the implementing type
+		structMethod := v.findMethodInType(namedType, interfaceMethod.Name())
+		if structMethod != nil {
+			// Determine if this implementation is async
+			isAsync := false
+			if funcInfo := v.analysis.FunctionData[structMethod]; funcInfo != nil {
+				isAsync = funcInfo.IsAsync
+			}
+
+			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+		}
+	}
+}
+
+// findMethodInType finds a method with the given name in a named type
+func (v *interfaceImplementationVisitor) findMethodInType(namedType *types.Named, methodName string) *types.Func {
+	for i := 0; i < namedType.NumMethods(); i++ {
+		method := namedType.Method(i)
+		if method.Name() == methodName {
+			return method
+		}
+	}
+	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
+}