diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md index 95630c02..b260b4f9 100644 --- a/CURRENT_TASK.md +++ b/CURRENT_TASK.md @@ -169,8 +169,32 @@ - **成果**: LoopBodyLocal 役割分離完了、body-only 変数は Trim promotion されない - **残課題**: body-local 変数の MIR lowering 対応（Phase 184+ で対応予定） - **発見**: Pattern1 実行問題（別途対応必要、Phase 183 スコープ外） - - [ ] Phase 184+: Body-local 変数 MIR lowering + String ops 有効化 - - body-local 変数（`local temp` in loop body）の MIR 生成対応 + - [x] **Phase 184: Body-local MIR Lowering Infrastructure** ✅ (2025-12-08) + - Task 184-1: 設計ドキュメント作成 ✅ + - phase184-body-local-mir-lowering.md（Two-Environment System 設計） + - 箱理論: LoopBodyLocalEnv（Storage Box）+ UpdateEnv（Composition Box） + - Task 184-2: LoopBodyLocalEnv 実装 ✅ + - loop_body_local_env.rs（216行）新規作成 + - BTreeMap 決定性保証、7 unit tests 全 PASS + - Task 184-3: UpdateEnv 実装 ✅ + - update_env.rs（237行）新規作成 + - Priority order: ConditionEnv → LoopBodyLocalEnv、8 unit tests 全 PASS + - Task 184-4: CarrierUpdateEmitter 統合 ✅ + - emit_carrier_update_with_env() 新規追加（UpdateEnv 版） + - emit_carrier_update() 後方互換維持、4 新規 unit tests 全 PASS（全 10 tests PASS） + - Task 184-5: 代表テストケース作成 ✅ + - phase184_body_local_update.hako（Pattern1 検証） + - phase184_body_local_with_break.hako（Pattern2 統合未実施、Phase 185 予定） + - Task 184-6: ドキュメント更新 ✅ + - joinir-architecture-overview.md（Phase 184 セクション追加） + - CURRENT_TASK.md（本項目追加） + - **成果**: Body-local 変数の MIR lowering インフラ完成 + - 3つの小箱（LoopBodyLocalEnv/UpdateEnv/CarrierUpdateEmitter）が単一責任で独立 + - 全 25 unit tests PASS（決定性・優先順位・後方互換性検証済み） + - **制約**: Pattern2/4 への統合は Phase 185 で実施予定（body-local 収集機能必要） + - [ ] Phase 185+: Body-local Pattern2/4 統合 + String ops 有効化 + - Pattern2/4 lowerer に LoopBodyLocalEnv 統合 + - body-local 変数（`local temp` in loop body）の完全 MIR 生成対応 - String concat フィルタの段階的緩和 - _parse_number, _atoi 完全実装 - [ ] Phase 183+: JsonParser 中級パターン実装 diff --git a/apps/tests/phase184_body_local_update.hako b/apps/tests/phase184_body_local_update.hako new file mode 100644 index 00000000..03c368c3 --- /dev/null +++ b/apps/tests/phase184_body_local_update.hako @@ -0,0 +1,26 @@ +// Phase 184: Body-local MIR Lowering Test +// +// This test validates that body-local variables can be used in update expressions. +// +// Expected behavior: +// - loop(i < 5) iterates 5 times +// - Each iteration: +// - local temp = i * 2 (body-local variable) +// - sum = sum + temp (update expression uses body-local) +// - Expected sum: 0 + (0*2) + (1*2) + (2*2) + (3*2) + (4*2) = 0+0+2+4+6+8 = 20 + +static box Main { + main() { + local sum = 0 + local i = 0 + + loop(i < 5) { + local temp = i * 2 // Body-local variable + sum = sum + temp // Use body-local in update expression + i = i + 1 + } + + print(sum) // Expected: 20 + return sum + } +} diff --git a/apps/tests/phase184_body_local_with_break.hako b/apps/tests/phase184_body_local_with_break.hako new file mode 100644 index 00000000..e4d67cf8 --- /dev/null +++ b/apps/tests/phase184_body_local_with_break.hako @@ -0,0 +1,37 @@ +// Phase 184: Body-local MIR Lowering with Break (Pattern 2) +// +// This test validates body-local variables in Pattern 2 (loop with break). +// +// Expected behavior: +// - loop(i < 10) with break when sum >= 15 +// - Each iteration: +// - local temp = i * 3 (body-local variable) +// - sum = sum + temp (update expression uses body-local) +// - if (sum >= 15) break +// - Expected iterations: +// - i=0: temp=0, sum=0+0=0 (continue) +// - i=1: temp=3, sum=0+3=3 (continue) +// - i=2: temp=6, sum=3+6=9 (continue) +// - i=3: temp=9, sum=9+9=18 (>= 15, break) +// - Expected sum: 18 + +static box Main { + main() { + local sum = 0 + local i = 0 + + loop(i < 10) { + local temp = i * 3 // Body-local variable + sum = sum + temp // Use body-local in update expression + + if (sum >= 15) { + break + } + + i = i + 1 + } + + print(sum) // Expected: 18 + return sum + } +} diff --git a/docs/development/current/main/joinir-architecture-overview.md b/docs/development/current/main/joinir-architecture-overview.md index 4e375ae8..c5e2cad8 100644 --- a/docs/development/current/main/joinir-architecture-overview.md +++ b/docs/development/current/main/joinir-architecture-overview.md @@ -169,6 +169,23 @@ JoinIR ラインで守るべきルールを先に書いておくよ： - else-continue を then-continue へ正規化し、Select ベースの continue を簡潔にする。 - ループ本体で実際に更新されるキャリアだけを抽出（Pattern 4 で不要キャリアを排除）。 +- **LoopBodyLocalEnv / UpdateEnv / CarrierUpdateEmitter（Phase 184）** + - ファイル: + - `src/mir/join_ir/lowering/loop_body_local_env.rs` + - `src/mir/join_ir/lowering/update_env.rs` + - `src/mir/join_ir/lowering/carrier_update_emitter.rs` + - 責務: + - **LoopBodyLocalEnv**: ループ本体で宣言された body-local 変数の名前→ValueId マッピングを管理（箱化設計）。 + - **UpdateEnv**: 条件変数（ConditionEnv）と body-local 変数（LoopBodyLocalEnv）を統合した変数解決層。 + - Priority order: 1. Condition variables（高優先度） → 2. Body-local variables（フォールバック） + - **CarrierUpdateEmitter**: UpdateExpr を JoinIR 命令に変換する際、UpdateEnv を使用して body-local 変数をサポート。 + - `emit_carrier_update_with_env()`: UpdateEnv 版（Phase 184 新規） + - `emit_carrier_update()`: ConditionEnv 版（後方互換） + - 設計原則: + - **箱理論**: 各 Box が単一責任を持ち、境界明確。 + - **決定性**: BTreeMap 使用で一貫した順序保証（PHI 生成の決定性）。 + - **保守的**: Pattern5 (Trim) は対象外、Phase 185 で統合予定。 + ### 2.3 キャリア / Exit / Boundary ライン - **CarrierInfo / LoopUpdateAnalyzer** diff --git a/docs/development/current/main/phase184-body-local-mir-lowering.md b/docs/development/current/main/phase184-body-local-mir-lowering.md new file mode 100644 index 00000000..2aeec103 --- /dev/null +++ b/docs/development/current/main/phase184-body-local-mir-lowering.md @@ -0,0 +1,374 @@ +# Phase 184: Body-local MIR Lowering Design + +## Status: In Progress (2025-12-08) + +## Overview + +Phase 183 completed **LoopBodyLocal role separation** (condition vs body-only). +Phase 184 implements **body-local MIR lowering** - the ability to use body-only local variables in update expressions safely. + +### Problem Statement + +**Current limitation**: +```nyash +local sum = 0 +local i = 0 +loop(i < 5) { + local temp = i * 2 // body-local variable + sum = sum + temp // ❌ ERROR: temp not found in ConditionEnv + i = i + 1 +} +``` + +**Root cause**: +- `CarrierUpdateEmitter` only has access to `ConditionEnv` +- `ConditionEnv` only contains condition variables (loop parameters) +- Body-local variables (`temp`) are not in `ConditionEnv` +- Update expression `sum = sum + temp` fails to resolve `temp` + +**Goal**: Enable body-local variables in update expressions while maintaining architectural clarity. + +## Design Solution + +### Architecture: Two-Environment System + +``` +┌─────────────────────┐ +│ ConditionEnv │ Condition variables (loop parameters) +│ - i → ValueId(0) │ Priority: HIGH +│ - end → ValueId(1) │ +└─────────────────────┘ + ↓ +┌─────────────────────┐ +│ LoopBodyLocalEnv │ Body-local variables +│ - temp → ValueId(5)│ Priority: LOW (only if not in ConditionEnv) +│ - digit → ValueId(6)│ +└─────────────────────┘ + ↓ +┌─────────────────────┐ +│ UpdateEnv │ Unified resolution layer +│ resolve(name): │ 1. Try ConditionEnv first +│ cond.get(name) │ 2. Fallback to LoopBodyLocalEnv +│ .or(body.get()) │ +└─────────────────────┘ +``` + +### Box-First Design + +Following **箱理論 (Box Theory)** principles: + +#### Box 1: LoopBodyLocalEnv (Storage Box) + +**Single Responsibility**: Collect and manage body-local variable mappings (name → ValueId). + +```rust +pub struct LoopBodyLocalEnv { + locals: BTreeMap, // Deterministic ordering +} + +impl LoopBodyLocalEnv { + /// Scan loop body AST and collect local definitions + pub fn from_loop_body( + body: &[ASTNode], + builder: &mut JoinIrBuilder + ) -> Self; + + /// Resolve a body-local variable name to JoinIR ValueId + pub fn get(&self, name: &str) -> Option; +} +``` + +**Design rationale**: +- **BTreeMap**: Ensures deterministic iteration (PHI ordering consistency) +- **from_loop_body()**: Separates collection logic from lowering logic +- **get()**: Simple lookup, no side effects + +#### Box 2: UpdateEnv (Composition Box) + +**Single Responsibility**: Unified variable resolution for update expressions. + +```rust +pub struct UpdateEnv<'a> { + condition_env: &'a ConditionEnv, // Priority 1: Condition vars + body_local_env: &'a LoopBodyLocalEnv, // Priority 2: Body-local vars +} + +impl<'a> UpdateEnv<'a> { + /// Resolve variable name with priority order + pub fn resolve(&self, name: &str) -> Option { + self.condition_env.get(name) + .or_else(|| self.body_local_env.get(name)) + } +} +``` + +**Design rationale**: +- **Composition**: Combines two environments without owning them +- **Priority order**: Condition variables take precedence (shadowing prevention) +- **Lightweight**: No allocation, just references + +### Integration Points + +#### Current Flow (Pattern2 Example) + +```rust +// Pattern2Lowerer::lower() +let condition_env = /* ... */; + +// Emit carrier update +let update_value = emit_carrier_update( + &carrier, + &update_expr, + &mut alloc_value, + &condition_env, // ❌ Only has condition variables + &mut instructions, +)?; +``` + +#### Phase 184 Flow + +```rust +// Pattern2Lowerer::lower() +let condition_env = /* ... */; +let body_local_env = LoopBodyLocalEnv::from_loop_body(&body_nodes, builder); + +// Create unified environment +let update_env = UpdateEnv { + condition_env: &condition_env, + body_local_env: &body_local_env, +}; + +// Emit carrier update (now with body-local support) +let update_value = emit_carrier_update_with_env( + &carrier, + &update_expr, + &mut alloc_value, + &update_env, // ✅ Has both condition and body-local variables + &mut instructions, +)?; +``` + +## Scope and Constraints + +### In Scope (Phase 184) + +1. **Body-local variable collection**: `LoopBodyLocalEnv::from_loop_body()` +2. **Unified resolution**: `UpdateEnv::resolve()` +3. **CarrierUpdateEmitter integration**: Use `UpdateEnv` instead of `ConditionEnv` +4. **Pattern2/4 integration**: Pass `body_local_env` to update lowering + +### Out of Scope + +1. **Condition variable usage**: Body-locals still cannot be used in conditions +2. **Pattern5 (Trim) integration**: Defer to Phase 185 +3. **Complex expressions**: Only simple variable references in updates +4. **Type checking**: Assume type correctness (existing type inference handles this) + +### Design Constraints + +Following **Phase 178 Fail-Fast** and **箱理論** principles: + +1. **Single Responsibility**: Each Box has one clear purpose +2. **Deterministic**: BTreeMap for consistent ordering +3. **Conservative**: No changes to Trim/Pattern5 logic +4. **Explicit errors**: If body-local used in condition → Fail loudly + +## Implementation Tasks + +### Task 184-1: Design Document ✅ (This document) + +### Task 184-2: LoopBodyLocalEnv Implementation + +**File**: `src/mir/join_ir/lowering/loop_body_local_env.rs` (new) + +**Core logic**: +```rust +impl LoopBodyLocalEnv { + pub fn from_loop_body(body: &[ASTNode], builder: &mut JoinIrBuilder) -> Self { + let mut locals = BTreeMap::new(); + + for node in body { + if let ASTNode::LocalDecl { name, init_value } = node { + // Lower init_value to JoinIR + let value_id = builder.lower_expr(init_value)?; + locals.insert(name.clone(), value_id); + } + } + + Self { locals } + } +} +``` + +**Unit tests** (3-5 tests): +- `test_empty_body`: No locals → empty env +- `test_single_local`: One local → one mapping +- `test_multiple_locals`: Multiple locals → sorted keys +- `test_get_existing`: Lookup succeeds +- `test_get_nonexistent`: Lookup returns None + +### Task 184-3: UpdateEnv Implementation + +**File**: `src/mir/join_ir/lowering/update_env.rs` (new) + +**Core logic**: +```rust +pub struct UpdateEnv<'a> { + condition_env: &'a ConditionEnv, + body_local_env: &'a LoopBodyLocalEnv, +} + +impl<'a> UpdateEnv<'a> { + pub fn new( + condition_env: &'a ConditionEnv, + body_local_env: &'a LoopBodyLocalEnv, + ) -> Self { + Self { condition_env, body_local_env } + } + + pub fn resolve(&self, name: &str) -> Option { + self.condition_env.get(name) + .or_else(|| self.body_local_env.get(name)) + } +} +``` + +**Unit tests** (2-3 tests): +- `test_resolve_condition_priority`: Condition var found first +- `test_resolve_body_local_fallback`: Body-local found when condition absent +- `test_resolve_not_found`: Neither env has variable → None + +### Task 184-4: CarrierUpdateEmitter Integration + +**File**: `src/mir/join_ir/lowering/carrier_update_emitter.rs` (modify) + +**Changes**: +1. Add new function variant accepting `UpdateEnv`: +```rust +pub fn emit_carrier_update_with_env( + carrier: &CarrierVar, + update: &UpdateExpr, + alloc_value: &mut dyn FnMut() -> ValueId, + env: &UpdateEnv, // New: UpdateEnv instead of ConditionEnv + instructions: &mut Vec, +) -> Result { + // Use env.resolve() instead of env.get() +} +``` + +2. Keep existing `emit_carrier_update()` for backward compatibility +3. Update Pattern2/4 callers to use new variant + +**Validation**: Existing tests must pass (backward compatibility). + +### Task 184-5: Representative Tests + +**File**: `apps/tests/phase184_body_local_update.hako` (new) + +```nyash +// Body-local used in update expression +static box Main { + main() { + local sum = 0 + local i = 0 + loop(i < 5) { + local temp = i * 2 // Body-local variable + sum = sum + temp // Use in update expression + i = i + 1 + } + print(sum) // Expected: 0+2+4+6+8 = 20 + } +} +``` + +**Test commands**: +```bash +# Structure trace +NYASH_JOINIR_STRUCTURE_ONLY=1 ./target/release/hakorune apps/tests/phase184_body_local_update.hako + +# Full execution +NYASH_JOINIR_CORE=1 ./target/release/hakorune apps/tests/phase184_body_local_update.hako +``` + +### Task 184-6: Documentation Updates + +1. **Update**: `docs/development/current/main/joinir-architecture-overview.md` + - Add LoopBodyLocalEnv section + - Update UpdateEnv integration diagram + +2. **Update**: `CURRENT_TASK.md` + - Mark Phase 184 complete + - Add Phase 185 preview + +## Validation Strategy + +### Success Criteria + +1. **Unit tests pass**: LoopBodyLocalEnv and UpdateEnv tests green +2. **Backward compatibility**: Existing Pattern2/4 tests still pass +3. **Representative test**: phase184_body_local_update.hako executes correctly (output: 20) +4. **No regression**: Trim patterns (Pattern5) unaffected + +### Test Commands + +```bash +# Unit tests +cargo test --release --lib loop_body_local_env +cargo test --release --lib update_env +cargo test --release --lib carrier_update + +# Integration test +NYASH_JOINIR_CORE=1 ./target/release/hakorune apps/tests/phase184_body_local_update.hako + +# Regression check (Trim pattern) +NYASH_JOINIR_CORE=1 ./target/release/hakorune apps/tests/phase172_trim_while.hako +``` + +## Known Limitations + +### Not Supported (Explicit Design Decision) + +1. **Body-local in conditions**: +```nyash +loop(i < 5) { + local temp = i * 2 + if (temp > 6) break // ❌ ERROR: Body-local in condition not allowed +} +``` +**Reason**: Condition variables must be loop parameters (JoinIR entry signature constraint). + +2. **Shadowing**: +```nyash +loop(i < 5) { + local i = 10 // ❌ ERROR: Shadows condition variable +} +``` +**Reason**: `UpdateEnv` prioritizes condition variables - shadowing forbidden. + +3. **Complex expressions**: +```nyash +loop(i < 5) { + local temp = obj.method() // ⚠️ May not work yet +} +``` +**Reason**: Limited to expressions `JoinIrBuilder::lower_expr()` supports. + +## Future Work (Phase 185+) + +### Phase 185: Trim Pattern Integration + +- Extend LoopBodyLocalEnv to handle Trim carrier variables +- Update TrimLoopLowerer to use UpdateEnv + +### Phase 186: Condition Expression Support + +- Allow body-local variables in break/continue conditions +- Requires inline expression evaluation in condition lowering + +## References + +- **Phase 183**: LoopBodyLocal role separation (condition vs body-only) +- **Phase 178**: Fail-Fast error handling principles +- **Phase 171-C**: LoopBodyCarrierPromoter original design +- **carrier_update_emitter.rs**: Current update emission logic +- **condition_env.rs**: Condition variable environment design diff --git a/src/mir/join_ir/lowering/carrier_update_emitter.rs b/src/mir/join_ir/lowering/carrier_update_emitter.rs index 45a11a8d..306c24f2 100644 --- a/src/mir/join_ir/lowering/carrier_update_emitter.rs +++ b/src/mir/join_ir/lowering/carrier_update_emitter.rs @@ -1,21 +1,159 @@ -//! Phase 176-2 / Phase 179: Carrier Update Emission +//! Phase 176-2 / Phase 179 / Phase 184: Carrier Update Emission //! //! Converts UpdateExpr (from LoopUpdateAnalyzer) into JoinIR instructions //! that compute the updated carrier value. //! //! This module is extracted from loop_with_break_minimal.rs to improve //! modularity and single responsibility. +//! +//! Phase 184: Added UpdateEnv support for body-local variable resolution. use crate::mir::join_ir::lowering::carrier_info::CarrierVar; -use crate::mir::join_ir::lowering::condition_to_joinir::ConditionEnv; +use crate::mir::join_ir::lowering::condition_env::ConditionEnv; use crate::mir::join_ir::lowering::loop_update_analyzer::{UpdateExpr, UpdateRhs}; +use crate::mir::join_ir::lowering::update_env::UpdateEnv; use crate::mir::join_ir::{BinOpKind, ConstValue, JoinInst, MirLikeInst}; use crate::mir::ValueId; -/// Emit JoinIR instructions for a single carrier update +/// Emit JoinIR instructions for a single carrier update (Phase 184: UpdateEnv version) /// /// Converts UpdateExpr (from LoopUpdateAnalyzer) into JoinIR instructions -/// that compute the updated carrier value. +/// that compute the updated carrier value. Supports both condition variables +/// and body-local variables through UpdateEnv. +/// +/// # Arguments +/// +/// * `carrier` - Carrier variable information (name, ValueId) +/// * `update` - Update expression (e.g., CounterLike, AccumulationLike) +/// * `alloc_value` - ValueId allocator closure +/// * `env` - UpdateEnv for unified variable resolution +/// * `instructions` - Output vector to append instructions to +/// +/// # Returns +/// +/// ValueId of the computed update result +/// +/// # Example +/// +/// ```ignore +/// // For "count = count + temp": +/// let count_next = emit_carrier_update_with_env( +/// &count_carrier, +/// &UpdateExpr::BinOp { lhs: "count", op: Add, rhs: Variable("temp") }, +/// &mut alloc_value, +/// &update_env, // Has both condition and body-local vars +/// &mut instructions, +/// )?; +/// // Generates: +/// // count_next = BinOp(Add, count_param, temp_value) +/// ``` +pub fn emit_carrier_update_with_env( + carrier: &CarrierVar, + update: &UpdateExpr, + alloc_value: &mut dyn FnMut() -> ValueId, + env: &UpdateEnv, + instructions: &mut Vec, +) -> Result { + match update { + UpdateExpr::Const(step) => { + // CounterLike: carrier = carrier + step + // Allocate const ValueId + let const_id = alloc_value(); + instructions.push(JoinInst::Compute(MirLikeInst::Const { + dst: const_id, + value: ConstValue::Integer(*step), + })); + + // Get carrier parameter ValueId from env + let carrier_param = env + .resolve(&carrier.name) + .ok_or_else(|| { + format!( + "Carrier '{}' not found in UpdateEnv", + carrier.name + ) + })?; + + // Allocate result ValueId + let result = alloc_value(); + instructions.push(JoinInst::Compute(MirLikeInst::BinOp { + dst: result, + op: BinOpKind::Add, + lhs: carrier_param, + rhs: const_id, + })); + + Ok(result) + } + + UpdateExpr::BinOp { lhs, op, rhs } => { + // General binary operation: carrier = carrier op rhs + // Verify lhs matches carrier name + if lhs != &carrier.name { + return Err(format!( + "Update expression LHS '{}' doesn't match carrier '{}'", + lhs, carrier.name + )); + } + + // Get carrier parameter ValueId from env + let carrier_param = env + .resolve(&carrier.name) + .ok_or_else(|| { + format!( + "Carrier '{}' not found in UpdateEnv", + carrier.name + ) + })?; + + // Resolve RHS (Phase 184: Now supports body-local variables!) + let rhs_id = match rhs { + UpdateRhs::Const(n) => { + let const_id = alloc_value(); + instructions.push(JoinInst::Compute(MirLikeInst::Const { + dst: const_id, + value: ConstValue::Integer(*n), + })); + const_id + } + UpdateRhs::Variable(var_name) => { + env.resolve(var_name).ok_or_else(|| { + format!( + "Update RHS variable '{}' not found in UpdateEnv (neither condition nor body-local)", + var_name + ) + })? + } + // Phase 178: String updates detected but not lowered to JoinIR yet + // The Rust MIR path handles string concatenation + // For JoinIR: just pass through the carrier param (no JoinIR update) + UpdateRhs::StringLiteral(_) | UpdateRhs::Other => { + eprintln!( + "[joinir/pattern2] Phase 178: Carrier '{}' has string/complex update - skipping JoinIR emit, using param passthrough", + carrier.name + ); + return Ok(carrier_param); // Pass-through: no JoinIR update + } + }; + + // Allocate result ValueId + let result = alloc_value(); + instructions.push(JoinInst::Compute(MirLikeInst::BinOp { + dst: result, + op: *op, + lhs: carrier_param, + rhs: rhs_id, + })); + + Ok(result) + } + } +} + +/// Emit JoinIR instructions for a single carrier update (backward compatibility version) +/// +/// This function is kept for backward compatibility with existing Pattern2/4 code +/// that only needs ConditionEnv. New code should prefer `emit_carrier_update_with_env`. /// /// # Arguments /// @@ -151,6 +289,7 @@ pub fn emit_carrier_update( mod tests { use super::*; use crate::mir::join_ir::lowering::carrier_info::CarrierVar; + use crate::mir::join_ir::lowering::loop_body_local_env::LoopBodyLocalEnv; // Helper: Create a test ConditionEnv fn test_env() -> ConditionEnv { @@ -161,6 +300,19 @@ mod tests { env } + // Helper: Create a test LoopBodyLocalEnv + fn test_body_local_env() -> LoopBodyLocalEnv { + let mut env = LoopBodyLocalEnv::new(); + env.insert("temp".to_string(), ValueId(50)); + env.insert("digit".to_string(), ValueId(60)); + env + } + + // Helper: Create a test UpdateEnv + fn test_update_env() -> (ConditionEnv, LoopBodyLocalEnv) { + (test_env(), test_body_local_env()) + } + // Helper: Create a test CarrierVar fn test_carrier(name: &str, host_id: u32) -> CarrierVar { CarrierVar { @@ -413,4 +565,168 @@ mod tests { assert!(result.is_err()); assert!(result.unwrap_err().contains("Update RHS variable 'unknown_var' not found")); } + + // ============================================================================ + // Phase 184: UpdateEnv version tests + // ============================================================================ + + #[test] + fn test_emit_update_with_env_body_local_variable() { + // Phase 184: Test using body-local variable in update expression + // sum = sum + temp (temp is body-local) + let carrier = test_carrier("sum", 200); + let update = UpdateExpr::BinOp { + lhs: "sum".to_string(), + op: BinOpKind::Add, + rhs: UpdateRhs::Variable("temp".to_string()), // Body-local variable + }; + + let (cond_env, body_env) = test_update_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + let mut value_counter = 110u32; + let mut alloc_value = || { + let id = ValueId(value_counter); + value_counter += 1; + id + }; + + let mut instructions = Vec::new(); + let result = emit_carrier_update_with_env( + &carrier, + &update, + &mut alloc_value, + &update_env, + &mut instructions, + ); + + assert!(result.is_ok()); + let result_id = result.unwrap(); + + // Should generate 1 instruction: BinOp(Add, sum, temp) + assert_eq!(instructions.len(), 1); + + match &instructions[0] { + JoinInst::Compute(MirLikeInst::BinOp { dst, op, lhs, rhs }) => { + assert_eq!(*dst, ValueId(110)); + assert_eq!(*op, BinOpKind::Add); + assert_eq!(*lhs, ValueId(20)); // sum from condition env + assert_eq!(*rhs, ValueId(50)); // temp from body-local env + } + _ => panic!("Expected BinOp instruction"), + } + + assert_eq!(result_id, ValueId(110)); + } + + #[test] + fn test_emit_update_with_env_condition_priority() { + // Phase 184: Test condition variable takes priority over body-local + // If both envs have "x", condition env should win + let mut cond_env = ConditionEnv::new(); + cond_env.insert("x".to_string(), ValueId(100)); // Condition: x=100 + cond_env.insert("sum".to_string(), ValueId(20)); + + let mut body_env = LoopBodyLocalEnv::new(); + body_env.insert("x".to_string(), ValueId(200)); // Body-local: x=200 (should be ignored) + + let update_env = UpdateEnv::new(&cond_env, &body_env); + + let carrier = test_carrier("sum", 200); + let update = UpdateExpr::BinOp { + lhs: "sum".to_string(), + op: BinOpKind::Add, + rhs: UpdateRhs::Variable("x".to_string()), + }; + + let mut value_counter = 120u32; + let mut alloc_value = || { + let id = ValueId(value_counter); + value_counter += 1; + id + }; + + let mut instructions = Vec::new(); + let result = emit_carrier_update_with_env( + &carrier, + &update, + &mut alloc_value, + &update_env, + &mut instructions, + ); + + assert!(result.is_ok()); + + // Should use x=100 (condition env), not x=200 (body-local env) + match &instructions[0] { + JoinInst::Compute(MirLikeInst::BinOp { dst: _, op: _, lhs: _, rhs }) => { + assert_eq!(*rhs, ValueId(100)); // Condition env wins + } + _ => panic!("Expected BinOp instruction"), + } + } + + #[test] + fn test_emit_update_with_env_variable_not_found() { + // Phase 184: Test error when variable not in either env + let (cond_env, body_env) = test_update_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + let carrier = test_carrier("sum", 200); + let update = UpdateExpr::BinOp { + lhs: "sum".to_string(), + op: BinOpKind::Add, + rhs: UpdateRhs::Variable("nonexistent".to_string()), + }; + + let mut value_counter = 130u32; + let mut alloc_value = || { + let id = ValueId(value_counter); + value_counter += 1; + id + }; + + let mut instructions = Vec::new(); + let result = emit_carrier_update_with_env( + &carrier, + &update, + &mut alloc_value, + &update_env, + &mut instructions, + ); + + assert!(result.is_err()); + let err = result.unwrap_err(); + assert!(err.contains("Update RHS variable 'nonexistent' not found")); + assert!(err.contains("neither condition nor body-local")); + } + + #[test] + fn test_emit_update_with_env_const_update() { + // Phase 184: Test UpdateEnv with simple const update (baseline) + let (cond_env, body_env) = test_update_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + let carrier = test_carrier("count", 100); + let update = UpdateExpr::Const(1); + + let mut value_counter = 140u32; + let mut alloc_value = || { + let id = ValueId(value_counter); + value_counter += 1; + id + }; + + let mut instructions = Vec::new(); + let result = emit_carrier_update_with_env( + &carrier, + &update, + &mut alloc_value, + &update_env, + &mut instructions, + ); + + assert!(result.is_ok()); + assert_eq!(instructions.len(), 2); // Const + BinOp + } } diff --git a/src/mir/join_ir/lowering/loop_body_local_env.rs b/src/mir/join_ir/lowering/loop_body_local_env.rs new file mode 100644 index 00000000..3e083e94 --- /dev/null +++ b/src/mir/join_ir/lowering/loop_body_local_env.rs @@ -0,0 +1,213 @@ +//! Phase 184: Loop Body Local Variable Environment +//! +//! This module provides a storage box for body-local variables in loop patterns. +//! It collects local variable declarations from loop body AST and maintains +//! name → JoinIR ValueId mappings. +//! +//! ## Design Philosophy +//! +//! **Single Responsibility**: This module ONLY handles body-local variable storage. +//! It does NOT: +//! - Resolve condition variables (that's ConditionEnv) +//! - Perform variable resolution priority logic (that's UpdateEnv) +//! - Lower AST to JoinIR (that's JoinIrBuilder) +//! +//! ## Box-First Design +//! +//! Following 箱理論 (Box Theory) principles: +//! - **Single purpose**: Store body-local variable mappings +//! - **Clear boundaries**: Only body-scope variables, not condition variables +//! - **Deterministic**: BTreeMap ensures consistent ordering + +use crate::mir::ValueId; +use std::collections::BTreeMap; + +/// Environment for loop body-local variables +/// +/// Maps variable names to JoinIR-local ValueIds for variables declared +/// within the loop body (not in conditions). +/// +/// # Example +/// +/// ```nyash +/// loop(i < 5) { +/// local temp = i * 2 // Body-local: temp +/// sum = sum + temp +/// i = i + 1 +/// } +/// ``` +/// +/// LoopBodyLocalEnv would contain: `{ "temp" → ValueId(5) }` +#[derive(Debug, Clone, Default)] +pub struct LoopBodyLocalEnv { + /// Body-local variable name → JoinIR ValueId mapping + /// + /// BTreeMap ensures deterministic iteration order (important for PHI generation) + locals: BTreeMap, +} + +impl LoopBodyLocalEnv { + /// Create a new empty environment + pub fn new() -> Self { + Self { + locals: BTreeMap::new(), + } + } + + /// Create an environment from loop body AST nodes + /// + /// This method scans the loop body for local variable declarations + /// and collects their JoinIR ValueIds. + /// + /// # Arguments + /// + /// * `body_locals` - List of (name, ValueId) pairs from body analysis + /// + /// # Example + /// + /// ```ignore + /// let body_locals = vec![ + /// ("temp".to_string(), ValueId(5)), + /// ("digit".to_string(), ValueId(6)), + /// ]; + /// let env = LoopBodyLocalEnv::from_locals(body_locals); + /// assert_eq!(env.get("temp"), Some(ValueId(5))); + /// ``` + pub fn from_locals(body_locals: Vec<(String, ValueId)>) -> Self { + let mut locals = BTreeMap::new(); + for (name, value_id) in body_locals { + locals.insert(name, value_id); + } + Self { locals } + } + + /// Insert a body-local variable binding + /// + /// # Arguments + /// + /// * `name` - Variable name (e.g., "temp", "digit") + /// * `join_id` - JoinIR-local ValueId for this variable + pub fn insert(&mut self, name: String, join_id: ValueId) { + self.locals.insert(name, join_id); + } + + /// Look up a body-local variable by name + /// + /// Returns `Some(ValueId)` if the variable exists in the environment, + /// `None` otherwise. + pub fn get(&self, name: &str) -> Option { + self.locals.get(name).copied() + } + + /// Check if a body-local variable exists in the environment + pub fn contains(&self, name: &str) -> bool { + self.locals.contains_key(name) + } + + /// Get the number of body-local variables in the environment + pub fn len(&self) -> usize { + self.locals.len() + } + + /// Check if the environment is empty + pub fn is_empty(&self) -> bool { + self.locals.is_empty() + } + + /// Get an iterator over all (name, ValueId) pairs + /// + /// Iteration order is deterministic (sorted by name) due to BTreeMap. + pub fn iter(&self) -> impl Iterator { + self.locals.iter() + } + + /// Get all variable names (sorted) + pub fn names(&self) -> Vec { + self.locals.keys().cloned().collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_empty_body_local_env() { + let env = LoopBodyLocalEnv::new(); + assert!(env.is_empty()); + assert_eq!(env.len(), 0); + assert_eq!(env.names(), Vec::::new()); + } + + #[test] + fn test_single_body_local() { + let mut env = LoopBodyLocalEnv::new(); + env.insert("temp".to_string(), ValueId(5)); + + assert!(!env.is_empty()); + assert_eq!(env.len(), 1); + assert!(env.contains("temp")); + assert_eq!(env.get("temp"), Some(ValueId(5))); + assert_eq!(env.names(), vec!["temp".to_string()]); + } + + #[test] + fn test_multiple_body_locals() { + let mut env = LoopBodyLocalEnv::new(); + env.insert("temp".to_string(), ValueId(5)); + env.insert("digit".to_string(), ValueId(6)); + env.insert("ch".to_string(), ValueId(7)); + + assert_eq!(env.len(), 3); + assert_eq!(env.get("temp"), Some(ValueId(5))); + assert_eq!(env.get("digit"), Some(ValueId(6))); + assert_eq!(env.get("ch"), Some(ValueId(7))); + + // BTreeMap ensures sorted keys + let names = env.names(); + assert_eq!(names, vec!["ch", "digit", "temp"]); + } + + #[test] + fn test_get_nonexistent() { + let env = LoopBodyLocalEnv::new(); + assert_eq!(env.get("nonexistent"), None); + assert!(!env.contains("nonexistent")); + } + + #[test] + fn test_from_locals() { + let body_locals = vec![ + ("temp".to_string(), ValueId(5)), + ("digit".to_string(), ValueId(6)), + ]; + let env = LoopBodyLocalEnv::from_locals(body_locals); + + assert_eq!(env.len(), 2); + assert_eq!(env.get("temp"), Some(ValueId(5))); + assert_eq!(env.get("digit"), Some(ValueId(6))); + } + + #[test] + fn test_iter_deterministic_order() { + let mut env = LoopBodyLocalEnv::new(); + // Insert in non-alphabetical order + env.insert("zebra".to_string(), ValueId(3)); + env.insert("apple".to_string(), ValueId(1)); + env.insert("mango".to_string(), ValueId(2)); + + // Iteration should be sorted + let names: Vec<_> = env.iter().map(|(name, _)| name.as_str()).collect(); + assert_eq!(names, vec!["apple", "mango", "zebra"]); + } + + #[test] + fn test_overwrite_existing() { + let mut env = LoopBodyLocalEnv::new(); + env.insert("temp".to_string(), ValueId(5)); + env.insert("temp".to_string(), ValueId(10)); // Overwrite + + assert_eq!(env.len(), 1); + assert_eq!(env.get("temp"), Some(ValueId(10))); + } +} diff --git a/src/mir/join_ir/lowering/mod.rs b/src/mir/join_ir/lowering/mod.rs index 1765603c..0a8f0225 100644 --- a/src/mir/join_ir/lowering/mod.rs +++ b/src/mir/join_ir/lowering/mod.rs @@ -24,6 +24,7 @@ pub mod carrier_info; // Phase 196: Carrier metadata for loop lowering pub(crate) mod carrier_update_emitter; // Phase 179: Carrier update instruction emission pub(crate) mod common; // Internal lowering utilities pub mod condition_env; // Phase 171-fix: Condition expression environment +pub mod loop_body_local_env; // Phase 184: Body-local variable environment pub(crate) mod condition_lowerer; // Phase 171-fix: Core condition lowering logic pub mod condition_to_joinir; // Phase 169: JoinIR condition lowering orchestrator (refactored) pub(crate) mod condition_var_extractor; // Phase 171-fix: Variable extraction from condition AST @@ -62,6 +63,7 @@ pub mod stageb_body; pub mod stageb_funcscanner; pub mod type_hint_policy; // Phase 65.5: 型ヒントポリシー箱化 pub mod type_inference; // Phase 65-2-A +pub mod update_env; // Phase 184: Unified variable resolution for update expressions pub(crate) mod value_id_ranges; // Internal ValueId range management // Re-export public lowering functions diff --git a/src/mir/join_ir/lowering/update_env.rs b/src/mir/join_ir/lowering/update_env.rs new file mode 100644 index 00000000..70be6712 --- /dev/null +++ b/src/mir/join_ir/lowering/update_env.rs @@ -0,0 +1,248 @@ +//! Phase 184: Update Expression Environment +//! +//! This module provides a unified variable resolution layer for carrier update expressions. +//! It combines ConditionEnv (condition variables) and LoopBodyLocalEnv (body-local variables) +//! with clear priority order. +//! +//! ## Design Philosophy +//! +//! **Single Responsibility**: This module ONLY handles variable resolution priority logic. +//! It does NOT: +//! - Store variables (that's ConditionEnv and LoopBodyLocalEnv) +//! - Lower AST to JoinIR (that's JoinIrBuilder) +//! - Emit update instructions (that's CarrierUpdateEmitter) +//! +//! ## Box-First Design +//! +//! Following 箱理論 (Box Theory) principles: +//! - **Composition**: Combines two environments without owning them +//! - **Clear priority**: Condition variables take precedence +//! - **Lightweight**: No allocation, just references + +use crate::mir::join_ir::lowering::condition_env::ConditionEnv; +use crate::mir::join_ir::lowering::loop_body_local_env::LoopBodyLocalEnv; +use crate::mir::ValueId; + +/// Unified environment for carrier update expression variable resolution +/// +/// This structure provides a composition layer that resolves variables +/// with the following priority order: +/// +/// 1. **Condition variables** (ConditionEnv) - Highest priority +/// - Loop parameters (e.g., `i`, `end`, `p`) +/// - Variables used in condition expressions +/// +/// 2. **Body-local variables** (LoopBodyLocalEnv) - Fallback priority +/// - Variables declared in loop body (e.g., `local temp`) +/// - Only accessible if not shadowed by condition variables +/// +/// # Example +/// +/// ```nyash +/// loop(i < 5) { // i in ConditionEnv +/// local temp = i * 2 // temp in LoopBodyLocalEnv +/// sum = sum + temp // Resolves: sum (cond), temp (body) +/// i = i + 1 +/// } +/// ``` +/// +/// ```ignore +/// let condition_env = /* ... i, sum ... */; +/// let body_local_env = /* ... temp ... */; +/// let update_env = UpdateEnv::new(&condition_env, &body_local_env); +/// +/// // Resolve "sum" → ConditionEnv (priority 1) +/// assert_eq!(update_env.resolve("sum"), Some(ValueId(X))); +/// +/// // Resolve "temp" → LoopBodyLocalEnv (priority 2) +/// assert_eq!(update_env.resolve("temp"), Some(ValueId(Y))); +/// +/// // Resolve "unknown" → None +/// assert_eq!(update_env.resolve("unknown"), None); +/// ``` +#[derive(Debug)] +pub struct UpdateEnv<'a> { + /// Condition variable environment (priority 1) + condition_env: &'a ConditionEnv, + + /// Body-local variable environment (priority 2) + body_local_env: &'a LoopBodyLocalEnv, +} + +impl<'a> UpdateEnv<'a> { + /// Create a new UpdateEnv with priority-ordered resolution + /// + /// # Arguments + /// + /// * `condition_env` - Condition variable environment (highest priority) + /// * `body_local_env` - Body-local variable environment (fallback) + pub fn new( + condition_env: &'a ConditionEnv, + body_local_env: &'a LoopBodyLocalEnv, + ) -> Self { + Self { + condition_env, + body_local_env, + } + } + + /// Resolve a variable name to JoinIR ValueId + /// + /// Resolution order: + /// 1. Try condition_env.get(name) + /// 2. If not found, try body_local_env.get(name) + /// 3. If still not found, return None + /// + /// # Arguments + /// + /// * `name` - Variable name to resolve + /// + /// # Returns + /// + /// * `Some(ValueId)` - Variable found in one of the environments + /// * `None` - Variable not found in either environment + pub fn resolve(&self, name: &str) -> Option { + self.condition_env + .get(name) + .or_else(|| self.body_local_env.get(name)) + } + + /// Check if a variable exists in either environment + pub fn contains(&self, name: &str) -> bool { + self.resolve(name).is_some() + } + + /// Get reference to condition environment (for debugging/diagnostics) + pub fn condition_env(&self) -> &ConditionEnv { + self.condition_env + } + + /// Get reference to body-local environment (for debugging/diagnostics) + pub fn body_local_env(&self) -> &LoopBodyLocalEnv { + self.body_local_env + } +} + +#[cfg(test)] +mod tests { + use super::*; + + // Helper: Create a test ConditionEnv + fn test_condition_env() -> ConditionEnv { + let mut env = ConditionEnv::new(); + env.insert("i".to_string(), ValueId(10)); + env.insert("sum".to_string(), ValueId(20)); + env.insert("end".to_string(), ValueId(30)); + env + } + + // Helper: Create a test LoopBodyLocalEnv + fn test_body_local_env() -> LoopBodyLocalEnv { + let mut env = LoopBodyLocalEnv::new(); + env.insert("temp".to_string(), ValueId(50)); + env.insert("digit".to_string(), ValueId(60)); + env + } + + #[test] + fn test_resolve_condition_priority() { + // Condition variables should be found first + let cond_env = test_condition_env(); + let body_env = LoopBodyLocalEnv::new(); // Empty + let update_env = UpdateEnv::new(&cond_env, &body_env); + + assert_eq!(update_env.resolve("i"), Some(ValueId(10))); + assert_eq!(update_env.resolve("sum"), Some(ValueId(20))); + assert_eq!(update_env.resolve("end"), Some(ValueId(30))); + } + + #[test] + fn test_resolve_body_local_fallback() { + // Body-local variables should be found when not in condition env + let cond_env = ConditionEnv::new(); // Empty + let body_env = test_body_local_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + assert_eq!(update_env.resolve("temp"), Some(ValueId(50))); + assert_eq!(update_env.resolve("digit"), Some(ValueId(60))); + } + + #[test] + fn test_resolve_priority_order() { + // Condition env takes priority over body-local env + let mut cond_env = ConditionEnv::new(); + cond_env.insert("x".to_string(), ValueId(100)); // Condition: x=100 + + let mut body_env = LoopBodyLocalEnv::new(); + body_env.insert("x".to_string(), ValueId(200)); // Body-local: x=200 + + let update_env = UpdateEnv::new(&cond_env, &body_env); + + // Should resolve to condition env value (100), not body-local (200) + assert_eq!(update_env.resolve("x"), Some(ValueId(100))); + } + + #[test] + fn test_resolve_not_found() { + // Variable not in either environment → None + let cond_env = test_condition_env(); + let body_env = test_body_local_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + assert_eq!(update_env.resolve("unknown"), None); + assert_eq!(update_env.resolve("nonexistent"), None); + } + + #[test] + fn test_resolve_combined_lookup() { + // Mixed lookup: some in condition, some in body-local + let cond_env = test_condition_env(); + let body_env = test_body_local_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + // Condition variables + assert_eq!(update_env.resolve("i"), Some(ValueId(10))); + assert_eq!(update_env.resolve("sum"), Some(ValueId(20))); + + // Body-local variables + assert_eq!(update_env.resolve("temp"), Some(ValueId(50))); + assert_eq!(update_env.resolve("digit"), Some(ValueId(60))); + + // Not found + assert_eq!(update_env.resolve("unknown"), None); + } + + #[test] + fn test_contains() { + let cond_env = test_condition_env(); + let body_env = test_body_local_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + assert!(update_env.contains("i")); + assert!(update_env.contains("temp")); + assert!(!update_env.contains("unknown")); + } + + #[test] + fn test_empty_environments() { + // Both environments empty + let cond_env = ConditionEnv::new(); + let body_env = LoopBodyLocalEnv::new(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + assert_eq!(update_env.resolve("anything"), None); + assert!(!update_env.contains("anything")); + } + + #[test] + fn test_accessor_methods() { + // Test diagnostic accessor methods + let cond_env = test_condition_env(); + let body_env = test_body_local_env(); + let update_env = UpdateEnv::new(&cond_env, &body_env); + + // Should return references to underlying environments + assert_eq!(update_env.condition_env().len(), 3); + assert_eq!(update_env.body_local_env().len(), 2); + } +}