goscript 0.0.22 → 0.0.24

package/compiler/analysis.go

@@ -41,6 +41,21 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// FunctionInfo consolidates function-related tracking data.
+type FunctionInfo struct {
+	IsAsync      bool
+	NamedReturns []string
+}
+
+// NodeInfo consolidates node-related tracking data.
+type NodeInfo struct {
+	NeedsDefer        bool
+	InAsyncContext    bool
+	IsBareReturn      bool
+	EnclosingFuncDecl *ast.FuncDecl
+	EnclosingFuncLit  *ast.FuncLit
+}
+
 // 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.
@@ -55,25 +70,25 @@ type Analysis struct {
 	// Cmap stores the comment map for the file
 	Cmap ast.CommentMap
 
-	// AsyncFuncs tracks which functions are async using the function's types.Object
-	// as the key to avoid false-positive matches with functions having the same name
-	AsyncFuncs map[types.Object]bool
+	// FunctionData consolidates function-related tracking into one map
+	FunctionData map[types.Object]*FunctionInfo
 
-	// NeedsDeferMap tracks nodes that need defer handling
-	NeedsDeferMap map[ast.Node]bool
+	// NodeData consolidates node-related tracking into one map
+	NodeData map[ast.Node]*NodeInfo
 
-	// IsInAsyncFunctionMap tracks nodes that are inside async functions
-	IsInAsyncFunctionMap map[ast.Node]bool
+	// Keep specialized maps that serve different purposes
+	// FuncLitData tracks function literal specific data since they don't have types.Object
+	FuncLitData map[*ast.FuncLit]*FunctionInfo
 }
 
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
-		VariableUsage:        make(map[types.Object]*VariableUsageInfo),
-		Imports:              make(map[string]*fileImport),
-		AsyncFuncs:           make(map[types.Object]bool),
-		NeedsDeferMap:        make(map[ast.Node]bool),
-		IsInAsyncFunctionMap: make(map[ast.Node]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),
 	}
 }
 
@@ -82,7 +97,11 @@ func (a *Analysis) NeedsDefer(node ast.Node) bool {
 	if node == nil {
 		return false
 	}
-	return a.NeedsDeferMap[node]
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.NeedsDefer
 }
 
 // IsInAsyncFunction returns whether the given node is inside an async function.
@@ -90,7 +109,11 @@ func (a *Analysis) IsInAsyncFunction(node ast.Node) bool {
 	if node == nil {
 		return false
 	}
-	return a.IsInAsyncFunctionMap[node]
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.InAsyncContext
 }
 
 // IsAsyncFunc returns whether the given object represents an async function.
@@ -98,7 +121,11 @@ func (a *Analysis) IsAsyncFunc(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
-	return a.AsyncFuncs[obj]
+	funcInfo := a.FunctionData[obj]
+	if funcInfo == nil {
+		return false
+	}
+	return funcInfo.IsAsync
 }
 
 // IsFuncLitAsync checks if a function literal is async based on our analysis.
@@ -106,17 +133,26 @@ func (a *Analysis) IsFuncLitAsync(funcLit *ast.FuncLit) bool {
 	if funcLit == nil {
 		return false
 	}
-	// Function literals are marked during analysis if they contain async operations
-	return a.IsInAsyncFunctionMap[funcLit]
+	// Check function literal specific data first
+	if funcInfo := a.FuncLitData[funcLit]; funcInfo != nil {
+		return funcInfo.IsAsync
+	}
+	// Fall back to node data for backwards compatibility
+	nodeInfo := a.NodeData[funcLit]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.InAsyncContext
 }
 
-// NeedsBoxed returns whether the given object needs to be boxed.
-// According to the new logic, a variable needs boxing if its address is taken
-// and assigned to another variable (i.e., it appears as a destination with AddressOfAssignment).
-func (a *Analysis) NeedsBoxed(obj types.Object) bool {
+// NeedsVarRef returns whether the given object needs to be variable referenced.
+// This is true when the object's address is taken (e.g., &myVar) in the analyzed code.
+// Variables that have their address taken must be wrapped in VarRef to maintain identity.
+func (a *Analysis) NeedsVarRef(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
+
 	usageInfo, exists := a.VariableUsage[obj]
 	if !exists {
 		return false
@@ -130,156 +166,97 @@ func (a *Analysis) NeedsBoxed(obj types.Object) bool {
 	return false
 }
 
-// NeedsBoxedAccess returns whether accessing the given object requires '.value' access in TypeScript.
-// This function is critical for correctly handling pointer dereferencing by determining when
-// a variable is boxed and needs .value to access its content.
-//
-// Two distinct cases determine when a variable needs .value access:
-//
-//  1. The variable itself is boxed (its address is taken)
-//     Example: let x = $.box(10) => x.value
+// NeedsVarRefAccess returns whether accessing the given object requires '.value' access in TypeScript.
+// This is more nuanced than NeedsVarRef and considers both direct variable references and
+// pointers that may point to variable-referenced values.
 //
-//  2. For pointer variables: it points to a boxed struct variable rather than a direct struct literal
-//     Example: let ptrToVal = val (where val is boxed) => ptrToVal.value
-//     vs.     let ptr = new MyStruct() => ptr (no .value needed)
-//
-// This distinction is crucial for avoiding over-dereferencing or under-dereferencing,
-// which was the root cause of several bugs in our pointer handling.
-func (a *Analysis) NeedsBoxedAccess(obj types.Object) bool {
+// Examples:
+//   - Direct variable reference (NeedsVarRef = true):
+//     Example: let x = $.varRef(10) => x.value
+//   - Pointer pointing to a variable-referenced value:
+//     Example: let p: VarRef<number> | null = x => p!.value
+//   - Regular pointer (NeedsVarRef = false, but points to variable reference):
+//     Example: let q = x => q!.value (where x is VarRef)
+func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
 
-	// First, check if the variable itself is boxed - this always requires .value
-	// A variable is boxed if its address is taken elsewhere in the code
-	if a.NeedsBoxed(obj) {
+	// If the variable itself is variable referenced, it needs .value access
+	if a.NeedsVarRef(obj) {
 		return true
 	}
 
-	// Check if this is a pointer variable pointing to a boxed struct value
-	objType := obj.Type()
-	if ptrType, isPointer := objType.Underlying().(*types.Pointer); isPointer {
-		// Check if it's a pointer to a struct
-		if elemType := ptrType.Elem(); elemType != nil {
-			if _, isStructType := elemType.Underlying().(*types.Struct); isStructType {
-				// For struct pointers, check if it points to a boxed struct variable
-				if usageInfo, exists := a.VariableUsage[obj]; exists {
-					for _, src := range usageInfo.Sources {
-						// Check if this pointer was assigned the address of another variable
-						// (e.g., ptr = &someVar) rather than a direct literal (ptr = &Struct{})
-						if src.Type == AddressOfAssignment && src.Object != nil {
-							// Bug fix: If the source variable is boxed, the pointer needs .value to access it
-							// This distinguishes between:
-							// - ptrToVal := &val (val is boxed, so we need ptrToVal.value)
-							// - ptr := &MyStruct{} (direct literal, no boxing needed)
-							return a.NeedsBoxed(src.Object)
-						}
+	// For pointer variables, check if they point to a variable-referenced value
+	if ptrType, ok := obj.Type().(*types.Pointer); ok {
+		// Check all assignments to this pointer variable
+		for varObj, info := range a.VariableUsage {
+			if varObj == obj {
+				for _, src := range info.Sources {
+					if src.Type == AddressOfAssignment && src.Object != nil {
+						// This pointer was assigned &someVar, check if someVar is variable referenced
+						return a.NeedsVarRef(src.Object)
 					}
 				}
 			}
 		}
+
+		// 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
 }
 
-// NeedsBoxedDeref determines whether a pointer dereference operation (*ptr) needs
-// the .value suffix in TypeScript when used in a direct dereference expression.
+// NeedsVarRefDeref determines whether a pointer dereference operation (*ptr) needs
+// additional .value access beyond the standard !.value pattern.
 //
-// Critical distinction (source of bugs):
+// Standard pattern: ptr!.value  (for *int, *string, etc.)
+// Enhanced pattern: ptr.value!.value  (when ptr itself is variable referenced)
 //
-//  1. For primitive types and pointers-to-primitive: Need .value
-//     *p => p!.value
-//     **p => p!.value!.value
+// This function returns true when the pointer variable itself is variable referenced,
+// meaning we need an extra .value to access the actual pointer before dereferencing.
 //
-//  2. For pointers to structs: No .value needed because structs are references
-//     *p => p!
-//     Where p is a pointer to a struct
+// Examples:
+//   - ptr := &x (ptr not variable referenced): *ptr => ptr!.value
+//   - ptrPtr := &ptr (ptr is variable referenced): *ptr => ptr.value!.value
 //
-// This distinction is essential because in TypeScript:
-// - Primitives are stored inside $.Box with a .value property
-// - Structs are reference types, so dereferencing just removes the null possibility
-func (a *Analysis) NeedsBoxedDeref(ptrType types.Type) bool {
-	// If we don't have a valid pointer type, default to true (safer)
-	if ptrType == nil {
-		return true
-	}
-
-	// Unwrap the pointer to get the element type
-	ptrTypeUnwrapped, ok := ptrType.(*types.Pointer)
-	if !ok {
-		return true // Not a pointer type, default to true
-	}
-
-	// Get the underlying element type
-	elemType := ptrTypeUnwrapped.Elem()
-	if elemType == nil {
-		return true
-	}
-
-	// Check if the element is another pointer - if so, we always need .value
-	// This fixes the bug with multi-level pointer dereferencing like **p
-	if _, isPointer := elemType.(*types.Pointer); isPointer {
-		return true
-	}
-
-	// Check if the element is a struct (directly or via a named type)
-	// Bug fix: Struct pointers in TS don't need .value when dereferenced
-	// because structs are already references in JavaScript/TypeScript
-	if _, isStruct := elemType.Underlying().(*types.Struct); isStruct {
-		return false // Pointers to structs don't need .value suffix in direct dereference (*p)
-	}
-
-	// For all other cases (primitives, pointers-to-pointers, etc.) need .value
-	// This ensures primitives and nested pointers are correctly dereferenced
-	return true
+// Args:
+//
+//	ptrType: The type of the pointer being dereferenced
+//
+// Returns:
+//
+//	true if additional .value access is needed due to the pointer being variable referenced
+func (a *Analysis) NeedsVarRefDeref(ptrType types.Type) bool {
+	// For now, return false - this would need more sophisticated analysis
+	// to track when pointer variables themselves are variable referenced
+	return false
 }
 
-// NeedsBoxedFieldAccess determines whether a pointer variable needs the .value
-// suffix when accessing fields (e.g., ptr.field).
+// NeedsVarRefFieldAccess determines whether a pointer variable needs the .value
+// access when performing field access through the pointer.
 //
-// Bug fix: This function was a major source of issues with struct field access.
-// The critical discovery was that field access through a pointer depends not on the
-// field itself, but on whether the pointer variable is boxed:
+// In Go, field access through pointers is automatically dereferenced:
 //
-//  1. For normal struct pointers (unboxed): No .value needed
-//     Example: let ptr = new MyStruct() => ptr.field
-//     (Common case from &MyStruct{} literals)
+//	ptr.Field  // equivalent to (*ptr).Field
 //
-//  2. For boxed struct pointers: Need .value to access the pointed-to struct
-//     Example: let ptrToVal = val (where val is boxed) => ptrToVal.value.field
+// In TypeScript, we need to determine if the pointer is:
+//  1. A simple pointer: ptr.Field  (no .value needed)
+//  2. A variable-referenced pointer: ptr.value.Field  (needs .value)
 //
-// We ultimately delegated this decision to WriteSelectorExpr which examines
-// the actual variable to determine if it's boxed, rather than just the type.
-func (a *Analysis) NeedsBoxedFieldAccess(ptrType types.Type) bool {
-	// If we don't have a valid pointer type, default to false
-	if ptrType == nil {
-		return false
-	}
-
-	// Unwrap the pointer to get the element type
-	ptrTypeUnwrapped, ok := ptrType.(*types.Pointer)
-	if !ok {
-		return false // Not a pointer type, no dereference needed for field access
-	}
-
-	// Check if the element is a struct (directly or via a named type)
-	elemType := ptrTypeUnwrapped.Elem()
-	if elemType == nil {
-		return false // Not pointing to anything
-	}
-
-	// For pointers to structs, check if it's a struct type first
-	_, isStruct := elemType.Underlying().(*types.Struct)
-	if !isStruct {
-		return false // Not a pointer to a struct
-	}
-
-	// The critical decision: We'll determine if .value is needed in the WriteSelectorExpr function
-	// by checking if the pointer variable itself is boxed.
-	// This allows us to handle both:
-	// - ptr := &MyStruct{} (unboxed, direct access)
-	// - ptrToVal := &val (boxed, needs .value)
+// Args:
+//
+//	ptrType: The pointer type being used for field access
+//
+// Returns:
+//
+//	true if .value access is needed before field access
+func (a *Analysis) NeedsVarRefFieldAccess(ptrType types.Type) bool {
+	// This would require analysis of the specific pointer variable
+	// For now, return false as a conservative default
 	return false
 }
 
@@ -302,6 +279,12 @@ type analysisVisitor struct {
 
 	// currentFuncObj tracks the object of the function declaration we're currently analyzing
 	currentFuncObj types.Object
+
+	// currentFuncDecl tracks the *ast.FuncDecl of the function we're currently analyzing.
+	currentFuncDecl *ast.FuncDecl
+
+	// currentFuncLit tracks the *ast.FuncLit of the function literal we're currently analyzing.
+	currentFuncLit *ast.FuncLit
 }
 
 // getOrCreateUsageInfo retrieves or creates the VariableUsageInfo for a given object.
@@ -324,8 +307,11 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return nil
 	}
 
-	// Store async state for the current node
-	v.analysis.IsInAsyncFunctionMap[node] = v.inAsyncFunction
+	// 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
 
 	switch n := node.(type) {
 	case *ast.GenDecl:
@@ -393,24 +379,40 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v
 
 	case *ast.FuncDecl:
-		// Determine if this function declaration is async based on its body
+		// 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.AsyncFuncs[obj] = true
+					v.analysis.FunctionData[obj] = &FunctionInfo{
+						IsAsync:      true,
+						NamedReturns: v.getNamedReturns(n),
+					}
+					isAsync = true
 				}
-				isAsync = true
 			}
 		}
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync
+		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
-		originalReceiver := v.currentReceiver
-		v.currentReceiver = nil // Reset for current function
 		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 {
@@ -419,7 +421,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 						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 boxing
+							// to ensure it is properly analyzed for varRefing
 							v.getOrCreateUsageInfo(v.currentReceiver)
 						}
 					}
@@ -427,22 +429,41 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 
-		// Save original states to restore after visiting
-		originalInAsync := v.inAsyncFunction
-		originalFuncObj := v.currentFuncObj
+		// Store named return variables
+		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 {
+				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
+				}
+			}
+		}
 
 		// Update visitor state for this function
 		v.inAsyncFunction = isAsync
 		v.currentFuncObj = v.pkg.TypesInfo.ObjectOf(n.Name)
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync // Ensure FuncDecl node itself is marked
+		v.analysis.NodeData[n].InAsyncContext = isAsync // Ensure FuncDecl node itself is marked
 
-		// Check if the body contains any defer statements
-		if n.Body != nil && v.containsDefer(n.Body) {
-			v.analysis.NeedsDeferMap[n.Body] = true
-		}
+		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)
+			// Visit the body with updated state
+			ast.Walk(v, n.Body)
+		}
 
 		// Restore states after visiting
 		defer func() {
@@ -450,21 +471,52 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			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)
-		v.analysis.IsInAsyncFunctionMap[n] = isAsync
+		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,
+				}
+			}
+		}
 
-		// Save original inAsyncFunction state to restore after visiting
-		originalInAsync := v.inAsyncFunction
 		v.inAsyncFunction = isAsync
 
 		// Check if the body contains any defer statements
 		if n.Body != nil && v.containsDefer(n.Body) {
-			v.analysis.NeedsDeferMap[n.Body] = true
+			if v.analysis.NodeData[n] == nil {
+				v.analysis.NodeData[n] = &NodeInfo{}
+			}
+			v.analysis.NodeData[n].NeedsDefer = true
 		}
 
 		// Visit the body with updated state
@@ -472,23 +524,34 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 		// Restore inAsyncFunction state after visiting
 		v.inAsyncFunction = originalInAsync
+		v.currentFuncDecl = originalFuncDecl
+		v.currentFuncLit = originalFuncLit
 		return nil // Stop traversal here, ast.Walk handled the body
 
 	case *ast.BlockStmt:
+		if n == nil || len(n.List) == 0 {
+			break
+		}
+
+		// Initialize NodeData for this block
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+
 		// Check for defer statements in this block
 		if v.containsDefer(n) {
-			v.analysis.NeedsDeferMap[n] = true
+			v.analysis.NodeData[n].NeedsDefer = true
 		}
 
 		// Store async state for this block
-		v.analysis.IsInAsyncFunctionMap[n] = v.inAsyncFunction
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
 
 		return v
 
 	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 boxing. Assignments are handled below.
+		// or function calls determines varRefing. Assignments are handled below.
 		// Function calls like foo(&x) would require different tracking if needed.
 		// For now, we focus on assignments as per the request.
 		return v
@@ -500,12 +563,18 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			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.AsyncFuncs[v.currentFuncObj] = true
+					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.IsInAsyncFunctionMap { // Find the node to update
+					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 {
-							v.analysis.IsInAsyncFunctionMap[nodeAst] = true
+							if v.analysis.NodeData[nodeAst] == nil {
+								v.analysis.NodeData[nodeAst] = &NodeInfo{}
+							}
+							v.analysis.NodeData[nodeAst].InAsyncContext = true
 						}
 					}
 				}
@@ -513,7 +582,10 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		}
 
 		// Store async state for this call expression
-		v.analysis.IsInAsyncFunctionMap[n] = v.inAsyncFunction
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
+		v.analysis.NodeData[n].InAsyncContext = v.inAsyncFunction
 
 		return v
 
@@ -594,7 +666,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 			// 2. If RHS involved a source variable (rhsSourceObj is not nil),
 			//    record that this source variable was used (its destinations).
-			//    This is CRITICAL for boxing analysis (e.g., if &rhsSourceObj was assigned).
+			//    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.
@@ -610,14 +682,46 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		}
 		return v // Continue traversal
 
-	case *ast.CompositeLit:
-		// No need to track private field access in composite literals since all fields are public
-		return v
+	case *ast.ReturnStmt:
+		// Initialize NodeData for return statement
+		if v.analysis.NodeData[n] == nil {
+			v.analysis.NodeData[n] = &NodeInfo{}
+		}
 
-	default:
-		// For all other nodes, continue traversal
-		return v
+		// 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
+				}
+			}
+		}
+		return v // Continue traversal
 	}
+
+	// For all other nodes, continue traversal
+	return v
 }
 
 // containsAsyncOperations checks if a node contains any async operations like channel operations.
@@ -666,6 +770,9 @@ func (v *analysisVisitor) containsDefer(block *ast.BlockStmt) bool {
 	hasDefer := false
 
 	ast.Inspect(block, func(n ast.Node) bool {
+		if n == nil {
+			return true
+		}
 		if _, ok := n.(*ast.DeferStmt); ok {
 			hasDefer = true
 			return false
@@ -677,7 +784,7 @@ func (v *analysisVisitor) containsDefer(block *ast.BlockStmt) bool {
 }
 
 // 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 boxing, etc.
+// 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
@@ -724,3 +831,16 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 	// Walk the AST with our visitor
 	ast.Walk(visitor, file)
 }
+
+// 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
+}