feat: implement comprehensive closure variable capture with two-phase approach

- Add statement preprocessor to analyze closures before transpilation
- Generate clone statements at statement level for captured variables
- Fix closure calling mechanism with proper dereferencing
- Handle nested closures and complex capture scenarios correctly
- Fix double-wrapping issue with function literals in assignments
- Add heuristic filtering to prevent capturing package names/constants
- Fix return statements to use renamed captured variables

Results: 44/132 tests passing (33%), function_literals_closures test now passes

Author: tylerlaprade

AGENTS.md

@@ -110,7 +110,19 @@ The test script handles:
 - Limited stdlib support
 - No circular dependencies or build tags
 
-## Recent Progress (2025-08-21)
+## Recent Progress (2025-08-22)
+
+- **Comprehensive closure capture fix**: Implemented two-phase approach for proper closure variable capture
+  - Created statement preprocessor (`stmt_preprocess.go`) to analyze closures before transpilation
+  - Generates clone statements at statement level, before closures are created
+  - Properly handles nested closures and complex capture scenarios
+  - Fixed closure calling mechanism to properly dereference wrapped closures
+  - Fixed double-wrapping issue with function literals in assignments
+- **Return statement improvements**: Variables in return statements now use renamed captures
+- **Heuristic-based capture filtering**: Prevents capturing package names and constants
+  - All defer and goroutine tests maintained
+
+Previous progress (2025-08-21):
 
 - **Defer statements fully working**: Fixed variable capture and argument evaluation, LIFO execution order correct
   - Closures now respect pre-configured capture renames from defer handlers
@@ -119,13 +131,6 @@ The test script handles:
 - **Map iteration determinism**: Added sorting to ensure deterministic output for map iteration tests
 - **Printf format string handling**: Improved conversion of Go format strings to Rust equivalents
 
-Previous progress (2025-08-15):
-
-- **Closures fully working**: Fixed variable capture, proper unwrapping of return values, correct handling of range loop variables
-- **Defer statements improved**: Immediate argument evaluation for deferred closures, proper LIFO execution
-- **Basic interface{} support**: Empty interface with Box<dyn Any>, format_any helper for printing
-- **Deterministic output**: Fixed non-deterministic ordering in anonymous structs, promoted methods, and interfaces
-
 ## ✅ Type System Integration (COMPLETED)
 
 The transpiler now uses `go/types` for accurate type information instead of brittle heuristics:
@@ -189,18 +194,22 @@ If `GetTypeInfo()` returns nil (shouldn't happen in normal operation):
 
 ### Closures
 
-The closure variable capture is partially working but needs refinement for general closures:
+The general closure capture mechanism is now working through a two-phase approach (implemented 2025-08-22):
+
+1. ✅ **Statement preprocessing** - Analyzes closures before transpilation
+2. ✅ **Clone generation at statement level** - Generates clones before the statement
+3. ✅ **Variable renaming** - Properly renames captured variables in closure bodies
+4. ✅ **Nested closures** - Handles closures within closures correctly
 
-1. **Capture detection works** - We can identify which variables are captured
-2. **Renaming infrastructure exists** - Variables can be renamed in closure bodies
-3. **Clone generation needs work** - Clones need to be generated at statement level, not inline
-4. **Some complex cases fail** - Nested closures in expressions, etc.
+Remaining limitations:
 
-The main challenge is that clones need to be generated before the statement containing the closure,
-not inside the closure expression itself. This requires statement-level analysis and transformation.
+- Some edge cases with variadic functions
+- Cross-file function variables need more work
+- Anonymous struct methods with closures
 
-Note: Defer statements with closures now work correctly as of 2025-08-21, providing a model for how
-statement-level capture could work for other closure use cases.
+The solution uses a statement preprocessor (`stmt_preprocess.go`) that analyzes all closures
+in a statement, generates appropriate clone statements, and sets up variable renames that are
+respected during transpilation.
 
 ## Recent Progress (2025-08-21)
 

go/expr.go

@@ -1452,14 +1452,21 @@ func TranspileCall(out *strings.Builder, call *ast.CallExpr) {
 			out.WriteString(ToSnakeCase(ident.Name))
 		} else {
 			// Likely a closure variable - need to unwrap and call
-			out.WriteString("(")
-			out.WriteString(ident.Name)
+			// Check if this variable has been renamed (captured in closure)
+			varName := ident.Name
+			if currentCaptureRenames != nil {
+				if renamed, exists := currentCaptureRenames[ident.Name]; exists {
+					varName = renamed
+				}
+			}
+			out.WriteString("(*")
+			out.WriteString(varName)
 			WriteBorrowMethod(out, false)
 			out.WriteString(".as_ref().unwrap())")
 		}
 	} else {
 		// Complex expression for the function (e.g., function returning a function)
-		out.WriteString("(")
+		out.WriteString("(*")
 		TranspileExpression(out, call.Fun)
 		WriteBorrowMethod(out, false)
 		out.WriteString(".as_ref().unwrap())")

go/stmt.go

@@ -81,6 +81,23 @@ func TranspileStatement(out *strings.Builder, stmt ast.Stmt, fnType *ast.FuncTyp
 	if stmt != nil && comments != nil && lastPos != nil {
 		outputCommentsBeforePos(out, comments, fileSet, stmt.Pos(), indent, lastPos)
 	}
+
+	// Preprocess the statement to find closures and generate clone statements
+	// Skip defer statements as they handle captures themselves
+	var captureInfo *CaptureInfo
+	if _, isDefer := stmt.(*ast.DeferStmt); !isDefer && statementPreprocessor != nil {
+		captureInfo = statementPreprocessor.PreprocessStatement(stmt, fnType)
+		if captureInfo != nil && len(captureInfo.CapturedVars) > 0 {
+			// Generate clone statements before the actual statement
+			statementPreprocessor.GenerateCloneStatements(out, captureInfo)
+
+			// Set up capture renames for this statement
+			oldCaptureRenames := currentCaptureRenames
+			currentCaptureRenames = captureInfo.CapturedVars
+			defer func() { currentCaptureRenames = oldCaptureRenames }()
+		}
+	}
+
 	switch s := stmt.(type) {
 	case *ast.ExprStmt:
 		TranspileExpression(out, s.X)
@@ -235,7 +252,14 @@ func TranspileStatement(out *strings.Builder, stmt ast.Stmt, fnType *ast.FuncTyp
 
 						if isWrappedVariable {
 							// This is a wrapped variable - clone it to avoid move errors
-							out.WriteString(ident.Name)
+							// Check if this variable has been renamed (captured in closure)
+							varName := ident.Name
+							if currentCaptureRenames != nil {
+								if renamed, exists := currentCaptureRenames[ident.Name]; exists {
+									varName = renamed
+								}
+							}
+							out.WriteString(varName)
 							out.WriteString(".clone()")
 						} else {
 							// This needs wrapping (constants, literals, etc.)
@@ -875,6 +899,9 @@ func TranspileStatement(out *strings.Builder, stmt ast.Stmt, fnType *ast.FuncTyp
 									} else if _, isCall := rhs.(*ast.CallExpr); isCall {
 										// Function calls already return wrapped values, don't wrap again
 										TranspileExpression(out, rhs)
+									} else if _, isFuncLit := rhs.(*ast.FuncLit); isFuncLit {
+										// Function literals are already wrapped by TranspileFuncLit
+										TranspileExpression(out, rhs)
 									} else if compositeLit, isCompositeLit := rhs.(*ast.CompositeLit); isCompositeLit {
 										// Check if it's a struct literal vs array/slice/map literal
 										isStructLiteral := false