feat: Smart concurrency-based wrapper optimization

Automatically selects between Rc<RefCell<>> (single-threaded) and Arc<Mutex<>> (concurrent) based on code analysis. Despite using theoretically lighter wrappers, no measurable performance improvement observed (44s vs 43s test suite runtime).

- Added concurrency detection system (go/concurrency.go)
- Created stdlib concurrency database (go/stdlib_concurrency.go)
- Updated all wrapper generation to be dynamic
- Fixed numerous bugs (map comma-ok, type assertions, error wrapping)
- 40/132 tests passing (up from 25), 0 failing (down from 9)

Author: tylerlaprade

AGENTS.md

@@ -1,29 +1,27 @@
 # Go2Rust Transpiler Project
 
-## Critical Principles
-
-### Think about what you need to do before rushing to do it
-
-### Don't Hide Problems
+## Development Guidelines
 
+- **No time constraints** - You have an unlimited amount of time to work, so be methodical and thorough. Don't take shortcuts or give up, even if the work seems tedious.
+- **Understand before changing** - if something seems wrong, investigate deeper
 - **Never add generated files to .gitignore** - fix the root cause instead
+- **We're a syntax translator, not a compiler** - no optimization, just translation
+- **Use Go's AST and go/types** - don't reinvent type analysis
+- **Test-driven development** - XFAIL tests auto-promote when passing
+- **Always run tests** before committing or moving to next task
+- **Update README** when adding support for new Go syntax features
+- **Update ROADMAP.md** after implementing features or making progress on phases
+- **Include transpiled Rust files in commits** when transpiler changes affect them (output of test cases)
 - **Preserve test output files** (.rs, Cargo.toml, Cargo.lock) - they're debugging snapshots
-- **Understand before changing** - if something seems wrong, investigate deeper
-
-### Development Guidelines
+- **ENSURE DETERMINISTIC OUTPUT** - Always sort map keys before iterating when generating output. The transpiler MUST produce identical output for identical input
 
-1. **We're a syntax translator, not a compiler** - no optimization, just translation
-2. **Use Go's AST and go/types** - don't reinvent type analysis
-3. **Test-driven development** - XFAIL tests auto-promote when passing
-4. **Always run tests** before committing or moving to next task
-5. **Update README** when adding support for new Go syntax features
-6. **Update ROADMAP.md** after implementing features or making progress on phases
-7. **Include transpiled Rust files in commits** when transpiler changes affect them (output of test cases)
-8. **ENSURE DETERMINISTIC OUTPUT** - Always sort map keys before iterating when generating output. The transpiler MUST produce identical output for identical input
+## Core Philosophy: Conservative Translation with Smart Optimization
 
-## Core Philosophy: Conservative Translation
+**Smart wrapper selection based on concurrency detection:**
 
-**EVERYTHING is `Arc<Mutex<Option<T>>>`. No exceptions.**
+- Single-threaded code uses `Rc<RefCell<Option<T>>>` for better performance
+- Concurrent code uses `Arc<Mutex<Option<T>>>` for thread safety
+- Automatic detection of goroutines, channels, and async operations
 
 This wraps all variables, parameters, returns, and fields because:
 
@@ -33,21 +31,23 @@ This wraps all variables, parameters, returns, and fields because:
 - Uniform mental model
 
 ```go
-// Go
+// Go (no concurrency)
 func add(a, b int) int {
     return a + b
 }
 ```
 
 ```rust
-// Rust translation
-fn add(a: Arc<Mutex<Option<i32>>>, b: Arc<Mutex<Option<i32>>>) -> Arc<Mutex<Option<i32>>> {
-    Arc::new(Mutex::new(Some(
-        (*a.lock().unwrap().as_ref().unwrap()) + (*b.lock().unwrap().as_ref().unwrap())
+// Rust translation (single-threaded)
+fn add(a: Rc<RefCell<Option<i32>>>, b: Rc<RefCell<Option<i32>>>) -> Rc<RefCell<Option<i32>>> {
+    Rc::new(RefCell::new(Some(
+        (*a.borrow().as_ref().unwrap()) + (*b.borrow().as_ref().unwrap())
     )))
 }
 ```
 
+When concurrency is detected (goroutines, channels, async stdlib calls), the transpiler automatically uses `Arc<Mutex<>>` instead.
+
 ## Implementation Status
 
 See `ROADMAP.md` for the detailed implementation phases and progress.
@@ -110,19 +110,19 @@ The test script handles:
 - Limited stdlib support
 - No circular dependencies or build tags
 
-## Recent Progress (2025-08-15)
+## Recent Progress (2025-08-21)
+
+- **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):
 
 - **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
-- **Test suite improvements**: Removed duplicate main functions, auto-promoted closures_basic test
-
-Previous progress:
-- All pointer operations now working correctly
-- **Fixed pointer type wrapping**: Pointers now use single wrapping instead of double
-- **Optimized function calls**: Variables passed as arguments use `.clone()` instead of re-wrapping
-- **Fixed nil pointer handling**: Proper assignment and dereferencing of nil pointers
 
 ## ✅ Type System Integration (COMPLETED)
 
@@ -144,7 +144,7 @@ See `go/typeinfo.go` and `go/README_TYPES.md` for implementation details.
 1. **First, get the TypeInfo**: `typeInfo := GetTypeInfo()`
 2. **Use TypeInfo methods** to query types:
    - `typeInfo.IsMap(expr)` - Check if expression is a map
-   - `typeInfo.IsSlice(expr)` - Check if expression is a slice  
+   - `typeInfo.IsSlice(expr)` - Check if expression is a slice
    - `typeInfo.IsString(expr)` - Check if expression is a string
    - `typeInfo.IsFunction(ident)` - Check if identifier is a function
    - `typeInfo.GetType(expr)` - Get the actual Go type
@@ -183,15 +183,9 @@ If `GetTypeInfo()` returns nil (shouldn't happen in normal operation):
 - Use `unimplemented!()` to make the issue obvious
 - Never fall back to heuristics
 
-## Recent Progress (2025-08-03)
+## Known Issues
 
-- **Constants support improved**: Fixed iota patterns, string concatenation, proper type inference
-- **Basic closures implemented**: Function literals, anonymous functions, closure types
-- **Defer statements working**: LIFO execution order, defer stack management
-- **Capture analysis framework**: Infrastructure for tracking captured variables (needs refinement)
-- **Type-based function detection**: Using go/types instead of name heuristics
-
-## Known Issues with Closures
+### Closures
 
 The closure variable capture is partially working but needs refinement:
 
@@ -202,3 +196,28 @@ The closure variable capture is partially working but needs refinement:
 
 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.
+
+## Recent Progress (2025-08-21)
+
+### ✅ Smart Concurrency-Based Optimization (COMPLETED)
+
+- **Automatic wrapper selection**: Uses `Rc<RefCell<>>` for single-threaded code, `Arc<Mutex<>>` only when needed
+- **Concurrency detection**: Analyzes code for goroutines, channels, and async stdlib functions
+- **40/132 tests passing**: Up from 25, with all optimization-related issues resolved
+
+Key components:
+
+- `go/concurrency.go`: Detects goroutines, channels, async stdlib calls
+- `go/stdlib_concurrency.go`: Database of async vs sync stdlib functions
+- Smart wrapper functions in `go/utils.go`:
+  - `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

NEXT_STEPS.md

@@ -0,0 +1,59 @@
+# Next Steps
+
+Looking at the XFAIL tests, the major features that
+need implementation include:
+
+## Anonymous Structs
+
+• Basic anonymous structs (anonymous_structs_basic)
+• In functions (anonymous_structs_functions)
+• Nested anonymous structs
+(anonymous_structs_nested)
+
+## Const Improvements
+
+• Complex const expressions (const_expressions)
+• Iota in const blocks (const_iota)
+• String concatenation in consts
+(const_string_concat)
+• Typed constants (const_typed)
+
+## Import System
+
+• Package aliases (import_aliases)
+• Blank imports with side effects
+(blank_imports_side_effects)
+• Multiple file packages (package_multiple_files)
+
+## Concurrency
+
+• Goroutines (goroutines_basic, goroutines_simple)
+• Sync primitives (sync_mutex, sync_waitgroup)
+• Atomic operations (atomic_operations)
+• Concurrency patterns (concurrency_patterns)
+
+## Channel Operations (multiple tests)
+
+• Basic channels (channels_basic, channels_simple)
+• Buffered channels (channel_buffering)
+• Channel directions (channel_directions)
+• Channel synchronization (channel_sync)
+• Closing channels (closing_channels)
+• Select statements (select_basic,
+select_statements)
+
+## Advanced Control Flow
+
+• Goto and labels (goto_labels, labeled_statements)
+• Fallthrough in switch (fallthrough_switch)
+• Complex control flow (advanced_control_flow)
+
+## Other Features
+
+• Variadic functions (variadic_functions)
+• Named return values (named_returns)
+• Init functions (init_functions,
+init_order_complex)
+• Panic and recover (panic_recover)
+• Type switches (type_switches)
+• Method value expressions (method_values)

README.md

@@ -40,36 +40,34 @@ func main() {
 }
 ```
 
-**Output (Rust):**
+**Output (Rust) - Single-threaded code:**
 
 ```rust
-use std::sync::{Arc, Mutex};
+use std::rc::Rc;
+use std::cell::RefCell;
 
-fn get_greeting() -> Arc<Mutex<Option<String>>> {
-    return Arc::new(Mutex::new(Some("Hello, World!".to_string())));
+fn get_greeting() -> Rc<RefCell<Option<String>>> {
+    return Rc::new(RefCell::new(Some("Hello, World!".to_string())));
 }
 
-fn get_year() -> Arc<Mutex<Option<i32>>> {
-    return Arc::new(Mutex::new(Some(2024)));
+fn get_year() -> Rc<RefCell<Option<i32>>> {
+    return Rc::new(RefCell::new(Some(2024)));
 }
 
 fn main() {
-    println!("{}", (*get_greeting().lock().unwrap().as_ref().unwrap()));
-    println!("{:?}", (*get_year().lock().unwrap().as_ref().unwrap()));
+    println!("{}", (*get_greeting().borrow().as_ref().unwrap()));
+    println!("{:?}", (*get_year().borrow().as_ref().unwrap()));
 }
 ```
 
-Note: The actual output is more verbose than shown here due to our conservative wrapping approach. Every value is wrapped in `Arc<Mutex<Option<T>>>` to ensure correctness.
+When the transpiler detects concurrency (goroutines, channels, or async stdlib calls), it automatically uses `Arc<Mutex<Option<T>>>` instead for thread safety.
 
 ## Philosophy
 
-This transpiler uses a "make it work first, optimize later" approach. **EVERY Go value** becomes `Arc<Mutex<Option<T>>>` - no exceptions. This includes:
+This transpiler uses a "make it work first, optimize later" approach. **EVERY Go value** is wrapped for safety, but the wrapper type depends on concurrency needs:
 
-- All variables (local, global)
-- All function parameters
-- All return values
-- All struct fields
-- All intermediate expressions
+- **Single-threaded code**: Uses `Rc<RefCell<Option<T>>>` for better performance
+- **Concurrent code**: Uses `Arc<Mutex<Option<T>>>` for thread safety
 
 This ensures semantic correctness for ANY Go program, even edge cases like taking the address of function parameters. The generated code is verbose but correct. Users can optimize later.
 
@@ -244,17 +242,6 @@ For unimplemented features, the transpiler generates TODO comments:
 | **`sort` package** | |
 | └ `sort.Strings` | ✅ |
 
-## Test Suite
-
-### Test Categories
-
-- **Basic Language Features**: Variables, types, operators, control flow
-- **Functions**: Basic functions, multiple returns, parameter handling
-- **Data Structures**: Arrays, slices, maps, structs, pointers
-- **Standard Library**: fmt, strings, strconv, builtin functions
-- **Concurrency**: Goroutines, channels, select statements (planned)
-- **Advanced Features**: Interfaces, generics, error handling (planned)
-
 ### XFAIL Tests (Expected Failures)
 
 The `tests/XFAIL/` directory contains tests for features not yet implemented. These tests: