tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
1,755 Commits 1 Branch 0 Tags
7a01ffe5220e0a3d1a22eb7f0a22e450d702201b
Commit Graph

20 Commits

Author SHA1 Message Date
nyash-codex
7a01ffe522 fix(joinir): Phase 177-3 ValueId collision fix for multi-carrier loops 
Root cause: JoinIR ValueId collision between function parameters and condition bindings
- Same ValueId used for both `result_init` (carrier param) and `limit` (condition var)
- Phase 33-21 was overwriting condition bindings when remapping carrier PHIs

Fix implemented (Option B - immediate protection):
1. Phase 177-3: Protect condition-only variables from Phase 33-21 override
   - Collect condition_bindings that are NOT carriers (by checking exit_bindings)
   - Skip remapping for these protected ValueIds
2. Phase 177-3-B: Handle body-only carriers explicitly
   - Carriers that appear in condition_bindings (added by Phase 176-5)
   - Map them to correct PHI dsts by name lookup

Investigation tools added:
- [DEBUG-177] trace logs for remapper state tracking
- Phase 177-3 protection logging
- BoundaryInjector PHI collision detection

Test results:
- ✅ Integer multi-carrier test: Output 3 (expected)
- ⚠️ String test: RC=0 but empty output (separate issue - string concat emit)

Design docs created:
- phase177-parse-string-design.md: _parse_string loop analysis
- phase177-carrier-evolution.md: Carrier progression Phase 174-179

Next: Investigate string concatenation emit for full _parse_string support
 2025-12-08 16:34:04 +09:00
nyash-codex
99d329096f feat(joinir): Phase 176 Pattern2 multi-carrier lowering complete 
Task 176-1: Pattern2 limitation investigation
- Identified 10 limitation points where only position carrier was handled
- Added TODO markers for Phase 176-2/3 implementation
- Created phase176-pattern2-limitations.md documentation

Task 176-2: CarrierUpdateLowerer helper implementation
- Implemented emit_carrier_update() helper function
- Supports CounterLike and AccumulationLike UpdateExpr patterns
- Added 6 unit tests (all passing)
- Fail-Fast error handling for carrier/variable not found

Task 176-3: Pattern2 lowerer multi-carrier extension
- Extended header PHI generation for all carriers
- Implemented loop update for all carriers using emit_carrier_update()
- Extended ExitLine/ExitMeta construction for all carriers
- Updated function call/jump args to include all carriers
- 9/10 tests passing (1 pre-existing test issue)

Task 176-4: E2E testing and bug fixes
- Fixed Trim pattern loop_var_name overwrite bug (pattern2_with_break.rs)
- Fixed InstructionRewriter latch_incoming mapping bug
- All E2E tests passing (RC=0): pos + result dual-carrier loops work
- test_jsonparser_parse_string_min2.hako verified

Task 176-5: Documentation updates
- Created phase176-completion-report.md
- Updated phase175-multicarrier-design.md with completion status
- Updated joinir-architecture-overview.md roadmap
- Updated CURRENT_TASK.md with Phase 176 completion + Phase 177 TODO
- Updated loop_pattern_space.md F-axis (multi-carrier support complete)

Technical achievements:
- Pattern2 now handles single/multiple carriers uniformly
- CarrierInfo architecture proven to work end-to-end
- Two critical bugs fixed (loop_var overwrite, latch_incoming mapping)
- No regressions in existing tests

Next: Phase 177 - Apply to JsonParser _parse_string full implementation
 2025-12-08 15:17:53 +09:00
nyash-codex
c63e6deb32 feat(joinir): Task 200-3 - JoinIRVerifier for LoopHeader PHI and ExitLine contracts 
Debug-only verification module to catch JoinIR contract violations early:
- verify_loop_header_phis: Checks loop_var_name → PHI exists in header block
- verify_exit_line: Checks exit_bindings → values exist, exit block in range
- verify_joinir_contracts: Main entry point, runs all checks

Implementation:
- Added verification functions to merge/mod.rs (private module has type access)
- Called from merge_joinir_mir_blocks after exit block setup
- Only active in debug builds (#[cfg(debug_assertions)])

Benefits:
- Catches "动くけど header PHI 無い" bugs immediately
- Validates exit_bindings before variable_map reconnection
- Prevents silent contract violations during development
 2025-12-08 04:33:33 +09:00
nyash-codex
4e32a803a7 feat(joinir): Phase 33-22 CommonPatternInitializer & JoinIRConversionPipeline integration 
Unifies initialization and conversion logic across all 4 loop patterns,
eliminating code duplication and establishing single source of truth.

## Changes

### Infrastructure (New)
- CommonPatternInitializer (117 lines): Unified loop var extraction + CarrierInfo building
- JoinIRConversionPipeline (127 lines): Unified JoinIR→MIR→Merge flow

### Pattern Refactoring
- Pattern 1: Uses CommonPatternInitializer + JoinIRConversionPipeline (-25 lines)
- Pattern 2: Uses CommonPatternInitializer + JoinIRConversionPipeline (-25 lines)
- Pattern 3: Uses CommonPatternInitializer + JoinIRConversionPipeline (-25 lines)
- Pattern 4: Uses CommonPatternInitializer + JoinIRConversionPipeline (-40 lines)

### Code Reduction
- Total reduction: ~115 lines across all patterns
- Zero code duplication in initialization/conversion
- Pattern files: 806 lines total (down from ~920)

### Quality Improvements
- Single source of truth for initialization
- Consistent conversion flow across all patterns
- Guaranteed boundary.loop_var_name setting (prevents SSA-undef bugs)
- Improved maintainability and testability

### Testing
- All 4 patterns tested and passing:
  - Pattern 1 (Simple While): ✅
  - Pattern 2 (With Break): ✅
  - Pattern 3 (If-Else PHI): ✅
  - Pattern 4 (With Continue): ✅

### Documentation
- Phase 33-22 inventory and results document
- Updated joinir-architecture-overview.md with new infrastructure

## Breaking Changes
None - pure refactoring with no API changes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
 2025-12-07 21:02:20 +09:00
nyash-codex
53af63c96c feat(joinir): Phase 33-21 Pattern 4 parameter remapping fix and debug improvements 
## Problem
Pattern 4 (loop with continue) was producing SSA-undef errors due to function_params
key mismatch. function_params uses 'join_func_0'/'join_func_1' format (from join_func_name()),
but code was looking for 'main'/'loop_step'.

## Solution
- Fix mod.rs: Use correct function keys 'join_func_0' and 'join_func_1'
- Add warning logs to detect future key mismatches immediately
- Update pattern4_with_continue.rs: Mark as fully implemented (not stub)
- Remove unused imports: MergeResult, TailCallKind, classify_tail_call, etc.

## Testing
- Pattern 3 (If PHI): sum=9 ✅
- Pattern 4 (Continue): 25 ✅ (1+3+5+7+9)
- No SSA-undef errors
- No new warnings on successful execution

## Debug Improvements
Added pre-flight checks in merge/mod.rs Phase 33-21:
```
[cf_loop/joinir] WARNING: function_params.get('join_func_0') returned None.
Available keys: [...]
```
This will save significant debugging time for future parameter mapping issues.

🤖 Generated with Claude Code

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
 2025-12-07 18:47:24 +09:00
nyash-codex
a6a97b3781 refactor(joinir): Phase 33-17-B LoopHeaderPhiInfo extraction 
## Changes
- Extract LoopHeaderPhiInfo Box (116 lines) from loop_header_phi_builder
- loop_header_phi_builder.rs reduced: 318 → 217 lines (-32%)
- Proper separation of data structures from builder logic

## Module Structure
- loop_header_phi_info.rs: LoopHeaderPhiInfo, CarrierPhiEntry structs + tests
- loop_header_phi_builder.rs: LoopHeaderPhiBuilder implementation

## Box Theory Compliance
- Data structures separated from builder logic
- Each file has clear single responsibility
- Clean re-exports through mod.rs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 12:28:11 +09:00
nyash-codex
8baca953ca refactor(joinir): Phase 33-17-A TailCallClassifier and MergeResult extraction 
## Changes
- Extract TailCallClassifier Box (107 lines) with 4 unit tests
- Extract MergeResult Box (44 lines) for merge result data structure
- instruction_rewriter.rs reduced: 649 → 580 lines (-10.6%)

## Box Theory Compliance
- TailCallClassifier: Single responsibility for tail call classification
- MergeResult: Clean data structure separation
- Both modules follow naming conventions (Classifier, Result)

## Quality
- 4 unit tests added for TailCallClassifier
- Build verified ✅

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 12:23:37 +09:00
nyash-codex
287ceca18d feat(joinir): Phase 33-16 Loop Header PHI SSOT with TailCallKind refactoring 
## Problem
- joinir_min_loop.hako returned 0 instead of expected 2
- Entry block's tail call was redirected to itself (bb4 → bb4 self-loop)
- JoinIR function parameters lack SSA definition when inlined

## Solution
- Distinguish entry calls from back edges using TailCallKind enum
- Entry block (LoopEntry) stays at target, back edges redirect to header PHI
- Added explicit classification: LoopEntry, BackEdge, ExitJump

## Key Changes
- instruction_rewriter.rs: TailCallKind enum + classify_tail_call()
- Renamed is_entry_func_entry_block → is_loop_entry_point (clearer intent)
- loop_header_phi_builder.rs: New module for header PHI generation
- joinir_inline_boundary_injector.rs: Skip loop var Copy when header PHI handles it

## Verified
- joinir_min_loop.hako: returns 2 ✅
- NYASH_SSA_UNDEF_DEBUG: no undefined errors ✅

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 12:01:54 +09:00
nyash-codex
a09ce0cbff feat(joinir): Phase 33-14 JoinFragmentMeta for expr/carrier separation 
Introduces JoinFragmentMeta to distinguish between loop expression results
and carrier variable updates, fixing SSA correctness issues.

## Changes

### New: JoinFragmentMeta struct (carrier_info.rs)
- `expr_result: Option<ValueId>` - Loop as expression (return loop(...))
- `exit_meta: ExitMeta` - Carrier updates for variable_map
- Helper methods: with_expr_result(), carrier_only(), empty()

### Pattern 2 Lowerer Updates
- loop_with_break_minimal.rs: Returns (JoinModule, JoinFragmentMeta)
- pattern2_with_break.rs: Sets boundary.expr_result from fragment_meta

### instruction_rewriter.rs
- Phase 33-14: Only add to exit_phi_inputs when boundary.expr_result is Some
- Phase 33-13: MergeResult struct with carrier_inputs map

### JoinInlineBoundary (inline_boundary.rs)
- New field: expr_result: Option<ValueId>
- All constructors updated with expr_result: None default

## Design Philosophy

Previously, exit_phi_inputs mixed expr results with carrier updates, causing:
- PHI inputs referencing undefined remapped values
- SSA-undef errors in VM execution

With JoinFragmentMeta:
- expr_result → exit_phi_inputs (generates PHI for expr value)
- exit_meta → carrier_inputs (updates variable_map via carrier PHIs)

## Test Results
- Pattern 1 (carrier-only): Works correctly (no exit_phi_inputs)
- Pattern 2 (expr result): Design complete, SSA-undef fix deferred to Phase 33-15

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 05:07:28 +09:00
nyash-codex
35f5a48eb0 docs(joinir): Phase 33 Completion - Box Theory Modularization Summary 
## Phase 33: Complete JoinIR Modularization via Box Theory (3 Phases)

This commit consolidates the comprehensive modularization work across three phases:
- Phase 33-10: Exit Line Modularization (ExitLineReconnector + ExitMetaCollector Boxes)
- Phase 33-11: Quick Wins (Pattern 4 stub clarification, unused imports cleanup)
- Phase 33-12: Large Module Modularization (split mod.rs, loop_patterns.rs restructuring)

### Phase 33-10: Exit Line Modularization (Boxes P0-P1)

**New Files**:
- `exit_line/reconnector.rs` (+130 lines): ExitLineReconnector Box
  - Responsibility: Update host variable_map with remapped exit values
  - Design: Phase 197-B multi-carrier support (each carrier gets specific remapped value)
  - Pure side effects: Only updates builder.variable_map
  - Testing: Independent unit testing possible without full merge machinery

- `exit_line/meta_collector.rs` (+102 lines): ExitMetaCollector Box
  - Responsibility: Construct exit_bindings from ExitMeta + variable_map lookup
  - Design: Pure function philosophy (no side effects except variable_map reads)
  - Reusability: Pattern-agnostic (works for Pattern 1, 2, 3, 4)
  - Algorithm: For each carrier in exit_meta, lookup host ValueId, create binding

- `exit_line/mod.rs` (+58 lines): ExitLineOrchestrator facade
  - Coordination: Orchestrates Phase 6 boundary reconnection
  - Architecture: Delegates to ExitLineReconnector (demonstrates Box composition)
  - Documentation: Comprehensive header explaining Box Theory modularization benefits

**Modified Files**:
- `merge/mod.rs` (-91 lines): Extracted reconnect_boundary() → ExitLineReconnector
  - Made exit_line module public (was mod, now pub mod)
  - Phase 6 delegation: Local function call → ExitLineOrchestrator::execute()
  - Added exit_bindings' join_exit_values to used_values for remapping (Phase 172-3)

- `patterns/pattern2_with_break.rs` (-20 lines): Uses ExitMetaCollector
  - Removed: Manual exit_binding construction loop
  - Added: Delegated ExitMetaCollector::collect() for cleaner caller code
  - Benefit: Reusable collector for all pattern lowerers (Pattern 1-4)

**Design Philosophy** (Exit Line Module):
Each Box handles one concern:
- ExitLineReconnector: Updates host variable_map with exit values
- ExitMetaCollector: Constructs exit_bindings from ExitMeta
- ExitLineOrchestrator: Orchestrates Phase 6 reconnection

### Phase 33-11: Quick Wins

**Pattern 4 Stub Clarification** (+132 lines):
- Added comprehensive header documentation (106 lines)
- Made `lower()` return explicit error (not silent stub)
- Migration guide: Workarounds using Pattern 1-3
- New file: `docs/development/proposals/phase-195-pattern4.md` (implementation plan)
- Status: Formal documentation that Pattern 4 is deferred to Phase 195

**Cleanup**:
- Removed unused imports via `cargo fix` (-10 lines, 11 files)
- Files affected: generic_case_a/ (5 files), if_merge.rs, if_select.rs, etc.

### Phase 33-12: Large Module Modularization

**New Files** (Modularization):
- `if_lowering_router.rs` (172 lines): If-expression routing
  - Extracted from mod.rs lines 201-423
  - Routes if-expressions to appropriate JoinIR lowering strategies
  - Single responsibility: If expression dispatch

- `loop_pattern_router.rs` (149 lines): Loop pattern routing
  - Extracted from mod.rs lines 424-511
  - Routes loop patterns to Pattern 1-4 implementations
  - Design: Dispatcher pattern for pattern selection

- `loop_patterns/mod.rs` (178 lines): Pattern dispatcher + shared utilities
  - Created as coordinator for per-pattern files
  - Exports all pattern functions via pub use
  - Utilities: Shared logic across pattern lowerers

- `loop_patterns/simple_while.rs` (225 lines): Pattern 1 lowering
- `loop_patterns/with_break.rs` (129 lines): Pattern 2 lowering
- `loop_patterns/with_if_phi.rs` (123 lines): Pattern 3 lowering
- `loop_patterns/with_continue.rs` (129 lines): Pattern 4 stub

**Modified Files** (Refactoring):
- `lowering/mod.rs` (511 → 221 lines, -57%):
  - Removed try_lower_if_to_joinir() (223 lines) → if_lowering_router.rs
  - Removed try_lower_loop_pattern_to_joinir() (88 lines) → loop_pattern_router.rs
  - Result: Cleaner core module with routers handling dispatch

- `loop_patterns.rs` → Re-export wrapper (backward compatibility)

**Result**: Clearer code organization
- Monolithic mod.rs split into focused routers
- Large loop_patterns.rs split into per-pattern files
- Better maintainability and testability

### Phase 33: Comprehensive Documentation

**New Architecture Documentation** (+489 lines):
- File: `docs/development/architecture/phase-33-modularization.md`
- Coverage: All three phases (33-10, 33-11, 33-12)
- Content:
  - Box Theory principles applied
  - Complete statistics table (commits, files, lines)
  - Code quality analysis
  - Module structure diagrams
  - Design patterns explanation
  - Testing strategy
  - Future work recommendations
  - References to implementation details

**Source Code Comments** (+165 lines):
- `exit_line/mod.rs`: Box Theory modularization context
- `exit_line/reconnector.rs`: Design notes on multi-carrier support
- `exit_line/meta_collector.rs`: Pure function philosophy
- `pattern4_with_continue.rs`: Comprehensive stub documentation + migration paths
- `if_lowering_router.rs`: Modularization context
- `loop_pattern_router.rs`: Pattern dispatch documentation
- `loop_patterns/mod.rs`: Per-pattern structure benefits

**Project Documentation** (+45 lines):
- CLAUDE.md: Phase 33 completion summary + links
- CURRENT_TASK.md: Current state and next phases

### Metrics Summary

**Phase 33 Total Impact**:
- Commits: 5 commits (P0, P1, Quick Wins×2, P2)
- Files Changed: 15 files modified/created
- Lines Added: ~1,500 lines (Boxes + documentation + comments)
- Lines Removed: ~200 lines (monolithic extractions)
- Code Organization: 2 monolithic files → 7 focused modules
- Documentation: 1 comprehensive architecture guide created

**mod.rs Impact** (Phase 33-12 P2):
- Before: 511 lines (monolithic)
- After: 221 lines (dispatcher + utilities)
- Reduction: -57% (290 lines extracted)

**loop_patterns.rs Impact** (Phase 33-12 P2):
- Before: 735 lines (monolithic)
- After: 5 files in loop_patterns/ (178 + 225 + 129 + 123 + 129)
- Improvement: Per-pattern organization

### Box Theory Principles Applied

1. **Single Responsibility**: Each Box handles one concern
   - ExitLineReconnector: variable_map updates
   - ExitMetaCollector: exit_binding construction
   - if_lowering_router: if-expression dispatch
   - loop_pattern_router: loop pattern dispatch
   - Per-pattern files: Individual pattern lowering

2. **Clear Boundaries**: Public/private visibility enforced
   - Boxes have explicit input/output contracts
   - Module boundaries clearly defined
   - Re-exports for backward compatibility

3. **Replaceability**: Boxes can be swapped/upgraded independently
   - ExitLineReconnector can be optimized without affecting ExitMetaCollector
   - Per-pattern files can be improved individually
   - Router logic decoupled from lowering implementations

4. **Testability**: Smaller modules easier to unit test
   - ExitMetaCollector can be tested independently
   - ExitLineReconnector mockable with simple boundary
   - Pattern lowerers isolated in separate files

### Design Patterns Introduced

1. **Facade Pattern**: ExitLineOrchestrator
   - Single-entry point for Phase 6 reconnection
   - Hides complexity of multi-step process
   - Coordinates ExitLineReconnector + other steps

2. **Dispatcher Pattern**: if_lowering_router + loop_pattern_router
   - Centralized routing logic
   - Easy to add new strategies
   - Separates dispatch from implementation

3. **Pure Function Pattern**: ExitMetaCollector::collect()
   - No side effects (except reading variable_map)
   - Easy to test, reason about, parallelize
   - Reusable across all pattern lowerers

### Testing Strategy

- **Unit Tests**: Can test ExitMetaCollector independently
- **Integration Tests**: Verify boundary reconnection works end-to-end
- **Regression Tests**: Pattern 2 simple loop still passes
- **Backward Compatibility**: All existing imports still work

### Future Work

- **Phase 33-13**: Consolidate whitespace utilities (expected -100 lines)
- **Phase 34**: Extract inline_boundary validators (expected 3h effort)
- **Phase 35**: Mark loop_patterns_old.rs as legacy and remove (Phase 35+)
- **Phase 195**: Implement Pattern 4 (continue) fully
- **Phase 200+**: More complex loop patterns and optimizations

🧱 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 04:03:42 +09:00
nyash-codex
c183557799 chore: cargo fix - remove unused imports 
Phase 33-11 Quick Wins - Task 1

- Removed 10 unused imports across JoinIR lowering modules
- Applied via 'cargo fix --allow-dirty'
- No logic changes, only cleanup
- Build: ✅ Success (0 errors, 44 warnings)

Files modified:
- src/mir/join_ir/lowering/generic_case_a/*.rs (5 files)
- src/mir/join_ir/lowering/{if_merge,if_select,loop_patterns,simple_while_minimal}.rs
- src/mir/join_ir_vm_bridge/joinir_function_converter.rs
- src/mir/builder/control_flow/joinir/merge/exit_line/reconnector.rs
 2025-12-07 03:12:51 +09:00
nyash-codex
eabef39748 feat(joinir/refactor): Phase 33-10-P1 ExitMetaCollector Box modularization 
Box theory refactoring: Extract exit_bindings construction logic from
pattern lowerers into focused, reusable ExitMetaCollector Box.

**Changes**:
1. Created meta_collector.rs (+102 lines):
   - ExitMetaCollector::collect() builds exit_bindings from ExitMeta
   - Pure function (no side effects)
   - Reusable by all pattern lowerers

2. Updated pattern2_with_break.rs (-20 lines):
   - Use ExitMetaCollector::collect() instead of inline filter_map
   - Removed manual binding construction loop
   - Cleaner caller code

3. Made exit_line module public:
   - Allows pattern lowerers to use ExitMetaCollector
   - Clear module visibility boundaries

**Box Design**:
- Single responsibility: Convert ExitMeta + variable_map → exit_bindings
- Pure function: No side effects, testable independently
- Reusable: Can be used by Pattern 3, Pattern 4, etc.

**Testing**:
- Build: ✅ Success (1m 04s)
- Execution: ✅ RC: 0 (Pattern 2 verified)
- Regression: ✅ No issues

**Metrics**:
- New lines: +102 (meta_collector.rs)
- Removed lines: -20 (pattern2_with_break.rs)
- Net change: +82 lines
- Code clarity: Significantly improved

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 02:37:12 +09:00
nyash-codex
547be29a1f feat(joinir/refactor): Phase 33-10-P0 ExitLineReconnector Box modularization 
Box theory application: Extract Phase 6 reconnect_boundary logic into
focused, testable exit_line module with clear responsibilities.

**Changes**:
1. Created exit_line submodule (2 new files):
   - reconnector.rs: ExitLineReconnector Box (+130 lines)
   - mod.rs: ExitLineOrchestrator facade (+58 lines)

2. Simplified merge/mod.rs (-91 lines):
   - Removed reconnect_boundary() function
   - Delegate to ExitLineOrchestrator::execute()
   - Clear separation of concerns

**Box Design**:
- ExitLineReconnector: Single responsibility - update variable_map with
  remapped exit values from JoinIR k_exit parameters
- ExitLineOrchestrator: Facade for Phase 6 orchestration
- Phase 197-B multi-carrier support: Each carrier gets specific exit value

**Testing**:
- Build: ✅ Success (0.11s)
- Execution: ✅ RC: 0 (Pattern 2 simple loop verified)
- Regression: ✅ No regression in existing logic

**Metrics**:
- New lines: +188 (exit_line module)
- Removed lines: -91 (merge/mod.rs)
- Net change: +97 lines
- Maintainability: Significantly improved
- Test coverage ready: Isolated Box can be tested independently

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 02:34:36 +09:00
nyash-codex
41c50e4780 feat(joinir): Phase 172-3 ExitMeta unified return from Pattern2 lowerer 
Implement loop exit contract boxification for JoinIR Pattern2:

- lower_loop_with_break_minimal now returns (JoinModule, ExitMeta)
- ExitMeta contains k_exit parameter ValueId for carrier variables
- Pattern2 caller builds exit_bindings from ExitMeta
- merge/mod.rs adds exit_bindings join_exit_values to used_values for remap
- reconnect_boundary uses remapped exit values for variable_map updates

This completes Phases 172-3 through 172-5 of the Loop Exit Contract
boxification plan, enabling proper loop variable propagation after exit.

Test: joinir_min_loop.hako passes (RC: 0)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 02:03:55 +09:00
nyash-codex
0dde30ceb8 fix(joinir): Phase 172 P0 - Remap PHI incoming Value IDs 
Previously, PHI incoming values were not being remapped from JoinIR-local
ValueIds to Host ValueIds. Only the block IDs were remapped.

This fix ensures both block ID and value ID are remapped for PHI
instructions during JoinIR merge.

Note: trim still fails because condition variable exit values are not
being reflected in variable_map (Phase 172-4/5 work needed).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 01:50:13 +09:00
nyash-codex
e30116f53d feat(joinir): Phase 171-fix ConditionEnv/ConditionBinding architecture 
Proper HOST↔JoinIR ValueId separation for condition variables:

- Add ConditionEnv struct (name → JoinIR-local ValueId mapping)
- Add ConditionBinding struct (HOST/JoinIR ValueId pairs)
- Modify condition_to_joinir to use ConditionEnv instead of builder.variable_map
- Update Pattern2 lowerer to build ConditionEnv and ConditionBindings
- Extend JoinInlineBoundary with condition_bindings field
- Update BoundaryInjector to inject Copy instructions for condition variables

This fixes the undefined ValueId errors where HOST ValueIds were being
used directly in JoinIR instructions. Programs now execute (RC: 0),
though loop variable exit values still need Phase 172 work.

Key invariants established:
1. JoinIR uses ONLY JoinIR-local ValueIds
2. HOST↔JoinIR bridging is ONLY through JoinInlineBoundary
3. condition_to_joinir NEVER accesses builder.variable_map

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-07 01:45:03 +09:00
nyash-codex
ae61226691 feat(joinir): Phase 197 Pattern4 multi-carrier exit fix & AST-based update 
Phase 197-B: Multi-Carrier Exit Mechanism
- Fixed reconnect_boundary() to use remapper for per-carrier exit values
- ExitMeta now uses carrier_param_ids (Jump arguments) instead of
  carrier_exit_ids (k_exit parameters)
- Root cause: k_exit parameters aren't defined when JoinIR functions
  merge into host MIR

Phase 197-C: AST-Based Update Expression
- LoopUpdateAnalyzer extracts update patterns from loop body AST
- Pattern4 lowerer uses UpdateExpr for semantically correct RHS
- sum = sum + i → uses i_next (current iteration value)
- count = count + 1 → uses const_1

Files modified:
- src/mir/builder/control_flow/joinir/merge/mod.rs
- src/mir/join_ir/lowering/loop_with_continue_minimal.rs
- src/mir/join_ir/lowering/loop_update_analyzer.rs (new)

Test results:
- loop_continue_multi_carrier.hako: 25, 5 ✅
- loop_continue_pattern4.hako: 25 ✅

Pattern 1–4 now unified with:
- Structure-based detection (LoopFeatures + classify)
- Carrier/Exit metadata (CarrierInfo + ExitMeta)
- Boundary connection (JoinInlineBoundary + LoopExitBinding)
- AST-based update expressions (LoopUpdateAnalyzer)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-06 14:46:33 +09:00
nyash-codex
318dceebfe fix(joinir): Pattern 4 PHI loss fix with exit_bindings and block reuse 
Two root causes for Pattern 4 outputting 0 instead of 25:

1. instruction_rewriter.rs:92 - BasicBlock::new() was overwriting
   existing blocks that already contained PHI instructions from
   JoinIR Select lowering. Fixed by removing and reusing existing
   blocks instead of creating new ones.

2. pattern4_with_continue.rs - JoinIR exit PHI (ValueId 15) was not
   connected to host's sum variable, causing DCE to eliminate the PHI
   as "unused". Fixed by using new_with_exit_bindings() with explicit
   LoopExitBinding to connect k_exit's sum_exit to host's sum slot.

Test result: loop_continue_pattern4.hako now correctly outputs 25.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-06 01:54:47 +09:00
nyash-codex
abfe0b198b feat(joinir): Phase 195 - Unified JoinLoopTrace for all JoinIR debug output 
Created centralized tracing module for JoinIR loop lowering operations,
consolidating scattered eprintln! calls into a single SSOT interface.

# Implementation

1. **Created trace.rs module** (~233 lines)
   - JoinLoopTrace struct with env var controls
   - Unified API: pattern(), varmap(), joinir_stats(), phi(), merge(), etc.
   - Global singleton via trace() function
   - Supports 5 env vars: NYASH_TRACE_VARMAP, NYASH_JOINIR_DEBUG,
     NYASH_OPTION_C_DEBUG, NYASH_JOINIR_MAINLINE_DEBUG, NYASH_LOOPFORM_DEBUG

2. **Updated debug.rs** - Delegates trace_varmap() to JoinLoopTrace

3. **Updated routing.rs** - All eprintln! replaced with trace calls (10 instances)

4. **Updated pattern routers** - All 3 patterns now use unified trace
   - pattern1_minimal.rs: 6 replacements
   - pattern2_with_break.rs: 6 replacements
   - pattern3_with_if_phi.rs: 6 replacements
   - router.rs: 2 replacements

5. **Updated merge/block_allocator.rs** - 6 eprintln! → trace calls

# Benefits

- **Single Source of Truth**: All trace control through environment variables
- **Consistent Format**: Unified [trace:*] prefix for easy filtering
- **Zero Overhead**: No output when env vars unset
- **Easy Extension**: Add new trace points via existing API
- **Better Debug Experience**: Structured output with clear categories

# Testing

✅ cargo build --release - Success
✅ NYASH_TRACE_VARMAP=1 - Shows varmap traces only
✅ NYASH_JOINIR_DEBUG=1 - Shows joinir + blocks + routing traces
✅ No env vars - No debug output
✅ apps/tests/loop_min_while.hako - All tests pass

# Related

- Phase 191-194 groundwork (modular merge structure)
- NYASH_TRACE_VARMAP added today for variable_map debugging
- Consolidates ~80 scattered eprintln! calls across JoinIR

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-05 22:23:51 +09:00
nyash-codex
9764ca3052 refactor: Break down merge_joinir_mir_blocks into 6 modules (Phase 4) 
Phase 4 Implementation Complete: Successfully modularized the 714-line
merge_joinir_mir_blocks() function into 6 focused, maintainable modules.

## Changes Made

### 1. Created Module Structure
- `src/mir/builder/control_flow/joinir/merge/` directory
- 5 sub-modules + 1 coordinator (6 files total)

### 2. Module Breakdown (848 lines total)
- **mod.rs** (223 lines) - Coordinator function
  - Orchestrates all 6 phases
  - Handles boundary reconnection
  - Manages entry/exit block jumps
- **block_allocator.rs** (70 lines) - Block ID allocation
  - Allocates new BlockIds for all JoinIR functions
  - Maintains determinism via sorted iteration
- **value_collector.rs** (90 lines) - Value collection
  - Collects all ValueIds from JoinIR functions
  - Builds auxiliary maps for Call→Jump conversion
- **instruction_rewriter.rs** (405 lines) - Instruction rewriting
  - Rewrites instructions with remapped IDs
  - Handles tail call optimization
  - Converts Return → Jump to exit block
- **exit_phi_builder.rs** (60 lines) - Exit PHI construction
  - Builds PHI node merging return values
  - Creates exit block

### 3. Updated control_flow/mod.rs
- Replaced 714-line function with 18-line delegation
- Reduced from 904 lines → 312 lines (65% reduction)
- Added documentation explaining Phase 4 refactoring

## Verification Results

✅ **Build**: `cargo build --release` - SUCCESS (23.36s)
✅ **Smoke Test**: loop_min_while.hako - PASS (correct output: 0,1,2)
✅ **Determinism**: 3 consecutive runs - IDENTICAL OUTPUT
✅ **Debug Traces**: NYASH_OPTION_C_DEBUG=1 traces work correctly
✅ **No Regressions**: Behavior preserved 100%

## Benefits

1. **Maintainability**: 714 lines → 6 focused modules (100-150 lines each)
2. **Readability**: Each phase isolated in its own file
3. **Testability**: Individual modules can be tested separately
4. **Future Development**: Easy to modify individual phases
5. **Zero Breaking Changes**: Backward compatible, no API changes

## Technical Notes

- Uses JoinIrIdRemapper (already existed) for ID translation
- Preserves all debug output and trace functionality
- Maintains determinism via BTreeSet/BTreeMap
- All Phase 189 features intact (multi-function support, etc.)

Generated with Claude Code (https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-05 21:00:55 +09:00