f4ab5ca5f4f04c7c982c6181a80e513546fda98c
6 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
| 3f58f34592 |
feat(llvm): Phase 132-P0 - block_end_values tuple-key fix for cross-function isolation
## Problem `block_end_values` used block ID only as key, causing collisions when multiple functions share the same block IDs (e.g., bb0 in both condition_fn and main). ## Root Cause - condition_fn's bb0 → block_end_values[0] - main's bb0 → block_end_values[0] (OVERWRITES!) - PHI resolution gets wrong snapshot → dominance error ## Solution (Box-First principle) Change key from `int` to `Tuple[str, int]` (func_name, block_id): ```python # Before block_end_values: Dict[int, Dict[int, ir.Value]] # After block_end_values: Dict[Tuple[str, int], Dict[int, ir.Value]] ``` ## Files Modified (Python - 6 files) 1. `llvm_builder.py` - Type annotation update 2. `function_lower.py` - Pass func_name to lower_blocks 3. `block_lower.py` - Use tuple keys for snapshot save/load 4. `resolver.py` - Add func_name parameter to resolve_incoming 5. `wiring.py` - Thread func_name through PHI wiring 6. `phi_manager.py` - Debug traces ## Files Modified (Rust - cleanup) - Removed deprecated `loop_to_join.rs` (297 lines deleted) - Updated pattern lowerers for cleaner exit handling - Added lifecycle management improvements ## Verification - ✅ Pattern 1: VM RC: 3, LLVM Result: 3 (no regression) - ⚠️ Case C: Still has dominance error (separate root cause) - Needs additional scope fixes (phi_manager, resolver caches) ## Design Principles - **Box-First**: Each function is an isolated Box with scoped state - **SSOT**: (func_name, block_id) uniquely identifies block snapshots - **Fail-Fast**: No cross-function state contamination ## Known Issues (Phase 132-P1) Other function-local state needs same treatment: - phi_manager.predeclared - resolver caches (i64_cache, ptr_cache, etc.) - builder._jump_only_blocks ## Documentation - docs/development/current/main/investigations/phase132-p0-case-c-root-cause.md - docs/development/current/main/investigations/phase132-p0-tuple-key-implementation.md 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> |
|||
| 233a49d902 |
feat(joinir): Phase 131-11 A-C - InfiniteEarlyExit パターン追加（検出部分）
## Step A: Feature Detection - LoopPatternKind::InfiniteEarlyExit (Pattern 5) 追加 - LoopFeatures::is_infinite_loop フィールド追加 - detect_infinite_loop() で loop(true) 検出 ## Step B: Classification Logic - classify() を更新: Pattern 5 を Pattern 4 より優先 - Pattern 4 を狭化: has_continue && !has_break のみ - 誤ルーティング完全除去 ## Step C: Pattern Module - pattern5_infinite_early_exit.rs 新規作成 - Fail-Fast 設計: 超狭い shape guard - lowering はスケルトン（Phase 131-11-D で実装） ## 動作確認 - Pattern 5 正常検出 ✅ - Shape guards 動作（1 break, 1 continue, 1 carrier）✅ - Pattern 4 誤ルーティング回避 ✅ 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> |
|||
| af6f95cd4b | Phase 33 NORM canon test: enforce normalized dev route for P1/P2/JP mini | |||
| 3ece6896c4 |
refactor(joinir): Phase 183-1 Unify pattern detection in loop_pattern_detection
Consolidates duplicate pattern detection logic across two routing layers. ## Changes 1. **Unified Detection Documentation**: - Added Phase 183 comments to `loop_pattern_detection::classify()` - Documented that this is the single source of truth for pattern classification - Both routers now reference this centralized function 2. **Router Documentation Updates**: - `patterns/router.rs`: Added Phase 183 comments explaining structure-based routing - `loop_pattern_router.rs`: Added unified detection section - Both routers now explicitly reference shared detection logic 3. **Improved Debug Output**: - Added `pattern_kind` to debug message in `route_loop_pattern()` - Helps diagnose pattern matching failures ## Benefits - **Single source of truth**: Pattern classification logic in one place - **Consistency**: Both routers use same detection algorithm - **Maintainability**: Changes to classification rules only needed once - **Documentation**: Clear references between routers and detection module ## Testing ✅ All loop_pattern_detection tests pass ✅ Pattern 2 tests pass ✅ No behavioral changes, pure documentation/organization refactoring 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> |
|||
| 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> |
|||
| adccfe5a4e |
refactor(joinir): Phase 33-12 Large module modularization complete
Task 1: Split mod.rs into if/loop routers - Created if_lowering_router.rs (172 lines): If-expression routing - Created loop_pattern_router.rs (149 lines): Loop pattern routing - Refactored mod.rs (511 → 221 lines): Thin re-export module Task 2: Modularize loop_patterns per-pattern - Created loop_patterns/ directory with 4 pattern files: - simple_while.rs (225 lines): Pattern 1 implementation - with_break.rs (129 lines): Pattern 2 implementation - with_if_phi.rs (123 lines): Pattern 3 implementation - with_continue.rs (129 lines): Pattern 4 stub - Created mod.rs (178 lines): Dispatcher + shared utilities - Removed old loop_patterns.rs (735 lines → directory) Line count changes: - mod.rs: 511 → 221 lines (57% reduction) - loop_patterns: 735 → 784 lines (modularized) - Total: Net +80 lines for better organization Benefits: - Single responsibility per file - Clear pattern boundaries - Improved testability - Better maintainability - Backward compatibility maintained Testing: - cargo build --release: ✅ Success (0 errors) - Regression test: ✅ Pass (RC: 0) |
