defer statements

Signed-off-by: Tyler Laprade <[email protected]>

Author: tylerlaprade

AGENTS.md

@@ -112,10 +112,12 @@ The test script handles:
 
 ## Recent 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
+  - Defer arguments capture VALUES at defer time, not references that could change
 - **Return statement fixes**: Fixed "cannot move out of mutable reference" errors by properly cloning wrapped values in return statements instead of unwrapping/re-wrapping
 - **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
-- **Test suite progress**: 40/132 tests passing (30%), up from 37/132
 
 Previous progress (2025-08-15):
 
@@ -187,16 +189,19 @@ If `GetTypeInfo()` returns nil (shouldn't happen in normal operation):
 
 ### Closures
 
-The closure variable capture is partially working but needs refinement:
+The closure variable capture is partially working but needs refinement for general closures:
 
 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. **Complex cases fail** - Nested closures, defer with captures, etc.
+4. **Some complex cases fail** - Nested closures in expressions, etc.
 
 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.
 
+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.
+
 ## Recent Progress (2025-08-21)
 
 ### ✅ Smart Concurrency-Based Optimization (COMPLETED)
@@ -213,11 +218,3 @@ Key components:
   - `WriteWrapperPrefix/Suffix()`: Uses appropriate wrapper based on concurrency
   - `WriteBorrowMethod()`: Uses `.borrow()` or `.lock().unwrap()` as needed
 - Helper functions adapt to concurrency (format_map, format_slice)
-
-### Previous Progress (2025-08-15)
-
-- **Closures fully working**: Fixed variable capture, proper unwrapping of return values
-- **Defer statements improved**: Immediate argument evaluation, proper LIFO execution
-- **Basic interface{} support**: Empty interface with Box<dyn Any>
-- **Deterministic output**: Fixed non-deterministic ordering issues
-- **Type system integration**: Full go/types integration for accurate type information

README.md

@@ -110,7 +110,7 @@ For unimplemented features, the transpiler generates TODO comments:
 | **`default` - Default clauses** | |
 | └ Switch default | ✅ |
 | └ Select default | ❌ |
-| **`defer` - Defer statements** | ❌ |
+| **`defer` - Defer statements** | ✅ |
 | **`else` - Else clauses** | ✅ |
 | **`fallthrough` - Fallthrough statements** | ❌ |
 | **`for` - For loops** | |

ROADMAP.md

@@ -26,12 +26,12 @@ Method receivers (value and pointer), multiple returns, method calls
 - 🚧 Struct embedding - method promotion working, field promotion needs wrapper handling fixes
 - 🚧 Anonymous structs - partial support (type generation works, literals need fixing)
 
-### 📋 Phase 5: Core Language Features (50% Complete)
+### 📋 Phase 5: Core Language Features (60% Complete)
 
 - ✅ Basic constants - simple const declarations working
 - 🚧 Complex constants and iota - expressions, iota patterns need work
 - ✅ Closures and function literals - fully working with proper variable capture
-- 🚧 Defer statements - basic LIFO execution working, some edge cases remain
+- ✅ Defer statements - fully working with proper LIFO execution and variable capture
 - ❌ Panic and recover - not implemented
 - 🚧 Interfaces - empty interface{} support added, named interfaces incomplete
 

go/expr.go

@@ -920,9 +920,20 @@ func TranspileFuncLit(out *strings.Builder, funcLit *ast.FuncLit) {
 	// The clones need to be generated at the statement level
 	captureRenames := make(map[string]string)
 	for varName := range captured {
-		// For now, just use the original names
-		// A proper implementation would handle this at statement level
-		captureRenames[varName] = varName
+		// Check if we already have renames set up (e.g., from defer)
+		// This allows statement-level handlers to pre-configure renames
+		if currentCaptureRenames != nil {
+			if existingRename, exists := currentCaptureRenames[varName]; exists && existingRename != "" {
+				// Use the existing rename
+				captureRenames[varName] = existingRename
+			} else {
+				// No existing rename for this variable, use identity
+				captureRenames[varName] = varName
+			}
+		} else {
+			// No existing renames at all, use identity
+			captureRenames[varName] = varName
+		}
 	}
 
 	// Store current capture renames for nested transpilation

go/stmt.go

@@ -1502,13 +1502,20 @@ func TranspileStatement(out *strings.Builder, stmt ast.Stmt, fnType *ast.FuncTyp
 				out.WriteString(" = ")
 
 				// Check if argument needs wrapping
+				// For defer arguments, we need to capture the VALUE at this moment,
+				// not a reference that could change later
 				if ident, ok := arg.(*ast.Ident); ok && ident.Name != "nil" && ident.Name != "_" {
 					// Check if this is a variable (not a constant)
 					if _, isRangeVar := rangeLoopVars[ident.Name]; !isRangeVar {
 						if _, isLocalConst := localConstants[ident.Name]; !isLocalConst {
-							// It's a variable, clone it
+							// It's a variable - capture its current value, not the reference
+							// This ensures each defer gets the value at the time of deferring
+							WriteWrapperPrefix(out)
+							out.WriteString("(*")
 							out.WriteString(ident.Name)
-							out.WriteString(".clone()")
+							WriteBorrowMethod(out, false)
+							out.WriteString(".as_ref().unwrap()).clone()")
+							WriteWrapperSuffix(out)
 						} else {
 							// It's a constant, wrap it
 							WriteWrapperPrefix(out)

tests.bats

@@ -299,6 +299,10 @@ run_xfail_test() {
     run_test "tests/constants_basic"
 }
 
+@test "defer_statements" {
+    run_test "tests/defer_statements"
+}
+
 @test "error_simple" {
     run_test "tests/error_simple"
 }
@@ -507,10 +511,6 @@ run_xfail_test() {
     run_xfail_test "tests/XFAIL/crypto_hash"
 }
 
-@test "XFAIL: defer_statements" {
-    run_xfail_test "tests/XFAIL/defer_statements"
-}
-
 @test "XFAIL: embedded_method_promotion" {
     run_xfail_test "tests/XFAIL/embedded_method_promotion"
 }

tests/XFAIL/panic_recover/main.rs

@@ -33,8 +33,8 @@ pub fn safe_divide(a: Rc<RefCell<Option<f64>>>, b: Rc<RefCell<Option<f64>>>) ->
         (Rc::new(RefCell::new(Some(Box::new(move || {
         let mut r = Rc::new(RefCell::new(None))::<String>));
     if (*r.borrow()).is_some() {
-        { let new_val = Rc::new(RefCell::new(Some(Some(Box::new(format!("panic occurred: {}", (*r.borrow_mut().as_mut().unwrap()))) as Box<dyn Error + Send + Sync>))); *err.borrow_mut() = Some(new_val); };
-        { let new_val = 0; *result.borrow_mut() = Some(new_val); };
+        { let new_val = Rc::new(RefCell::new(Some(Some(Box::new(format!("panic occurred: {}", (*r.borrow_mut().as_mut().unwrap()))) as Box<dyn Error + Send + Sync>))); *err_defer_captured.borrow_mut() = Some(new_val); };
+        { let new_val = 0; *result_defer_captured.borrow_mut() = Some(new_val); };
     }
     }) as Box<dyn Fn() -> ()>))).borrow().as_ref().unwrap())();
     }));
@@ -68,8 +68,8 @@ pub fn process_slice(slice: Rc<RefCell<Option<Vec<i32>>>>, index: Rc<RefCell<Opt
         (Rc::new(RefCell::new(Some(Box::new(move || {
         let mut r = Rc::new(RefCell::new(None))::<String>));
     if (*r.borrow()).is_some() {
-        { let new_val = Rc::new(RefCell::new(Some(Some(Box::new(format!("index out of bounds: {}", (*r.borrow_mut().as_mut().unwrap()))) as Box<dyn Error + Send + Sync>))); *err.borrow_mut() = Some(new_val); };
-        { let new_val = -1; *value.borrow_mut() = Some(new_val); };
+        { let new_val = Rc::new(RefCell::new(Some(Some(Box::new(format!("index out of bounds: {}", (*r.borrow_mut().as_mut().unwrap()))) as Box<dyn Error + Send + Sync>))); *err_defer_captured.borrow_mut() = Some(new_val); };
+        { let new_val = -1; *value_defer_captured.borrow_mut() = Some(new_val); };
     }
     }) as Box<dyn Fn() -> ()>))).borrow().as_ref().unwrap())();
     }));