ruchy 1.89.0

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# Backend Transpiler Refactoring Plan

## Critical Issue: statements.rs is 2,694 lines with 46 public functions

### MANDATORY: Split into 5 modules with complexity ≤10 per function

## Proposed Module Structure

### 1. `statements/control_flow.rs` (~500 lines)
**Functions to move**:
- `transpile_if` (complexity: reduce from ~15 to ≤10)
- `transpile_while`
- `transpile_for` 
- `transpile_loop`
- `transpile_if_let`
- `transpile_while_let`
- `transpile_break`
- `transpile_continue`

### 2. `statements/variables.rs` (~400 lines)
**Functions to move**:
- `transpile_let` (complexity: reduce from ~20 to ≤10)
- `transpile_let_pattern`
- `transpile_const`
- `transpile_assignment`
- Variable mutability analysis helpers

### 3. `statements/functions.rs` (~500 lines)
**Functions to move**:
- `transpile_function` (complexity: reduce from ~30 to ≤10)
- `transpile_lambda`
- `transpile_call`
- `transpile_method_call`
- Parameter type inference helpers

### 4. `statements/modules.rs` (~400 lines)
**Functions to move**:
- `transpile_module`
- `transpile_import`
- `transpile_import_inline`
- `transpile_export`
- `transpile_use`

### 5. `statements/blocks.rs` (~300 lines)
**Functions to move**:
- `transpile_block`
- `transpile_pipeline`
- `transpile_list_comprehension`
- Expression sequencing helpers

## Complexity Reduction Strategy

### Current High-Complexity Functions

1. **`transpile_function`** (complexity: ~30)
   - Extract: parameter processing (≤5)
   - Extract: return type inference (≤5)
   - Extract: body transpilation (≤5)
   - Extract: async handling (≤5)
   - Main dispatcher: ≤10

2. **`transpile_let`** (complexity: ~20)
   - Extract: pattern matching (≤5)
   - Extract: type annotation (≤5)
   - Extract: mutability detection (≤5)
   - Main dispatcher: ≤5

3. **`transpile_if`** (complexity: ~15)
   - Extract: condition processing (≤5)
   - Extract: branch handling (≤5)
   - Main dispatcher: ≤5

## TDD Implementation Plan

### Phase 1: Create Module Structure
```rust
// src/backend/transpiler/statements/mod.rs
pub mod control_flow;
pub mod variables;
pub mod functions;
pub mod modules;
pub mod blocks;

// Re-export for compatibility
pub use control_flow::*;
pub use variables::*;
pub use functions::*;
pub use modules::*;
pub use blocks::*;
```

### Phase 2: Move Functions (RED → GREEN)
1. Create failing tests for each module
2. Move functions to new modules
3. Ensure all tests pass
4. Verify complexity ≤10

### Phase 3: Refactor High Complexity (REFACTOR)
1. Identify functions >10 complexity
2. Extract helper functions
3. Re-run tests to ensure no regression
4. Measure coverage improvement

## Success Metrics
- [ ] No function exceeds complexity 10
- [ ] Backend coverage increases from 52.9% to 70%+
- [ ] All existing tests continue to pass
- [ ] Each new module has 80%+ coverage

## Estimated Impact
- **Lines per module**: ~300-500 (manageable)
- **Functions per module**: 8-10 (focused)
- **Complexity per function**: ≤10 (testable)
- **Coverage improvement**: +20-30%