tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(joinir): Phase 188-Impl-2 Pattern 2 (Loop with Conditional Break) implementation

Browse Source 
Add Pattern 2 lowerer for `loop { if cond { break } body }` pattern.

New files:
- loop_with_break_minimal.rs (291 lines): JoinIR lowerer for Pattern 2
  - Exit PHI receives values from both natural exit and break path
  - Tail-recursive loop_step function design

Modified files:
- loop_pattern_detection.rs: Add is_loop_with_break_pattern() detection
- mod.rs: Router integration (Pattern 1 → Pattern 2 ordering)
- control_flow.rs: Add cf_loop_pattern2_with_break() helper
- loop_patterns.rs: Simplified skeleton (defer until patterns stabilize)

Test results:
- Pattern 1 (loop_min_while.hako): ✅ PASS
- Pattern 2 (joinir_min_loop.hako): ✅ PASS

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
nyash-codex
2025-12-05 15:28:54 +09:00
parent 4e4a56f8c9
commit 87e477b13e
5 changed files with 519 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
src/mir/join_ir/lowering/mod.rs
View File

@ -34,6 +34,7 @@ pub mod loop_form_intake;
pub mod loop_patterns; // Phase 188: Pattern-based loop lowering (3 patterns)
pub mod loop_scope_shape;
pub mod loop_to_join;
pub mod loop_with_break_minimal; // Phase 188-Impl-2: Pattern 2 minimal lowerer
pub mod simple_while_minimal; // Phase 188-Impl-1: Pattern 1 minimal lowerer
pub mod min_loop;
pub mod skip_ws;
@ -414,63 +415,49 @@ pub fn try_lower_if_to_joinir(
///
/// **Total Estimated Effort**: 18-28 hours
pub fn try_lower_loop_pattern_to_joinir(
_loop_form: &LoopForm,
_lowerer: &mut LoopToJoinLowerer,
loop_form: &LoopForm,
lowerer: &mut LoopToJoinLowerer,
) -> Option<JoinInst> {
// TODO: Implement pattern routing logic
//
// Phase 188: Pattern-based loop lowering router
// Tries patterns in order: Pattern 1 → Pattern 2 → Pattern 3
use crate::mir::loop_pattern_detection::{
is_loop_with_break_pattern, is_simple_while_pattern,
};
// Pattern 1: Simple While Loop (easiest, most common)
// ====================================================
//
// ```rust
// use crate::mir::loop_pattern_detection::is_simple_while_pattern;
// use crate::mir::join_ir::lowering::loop_patterns::lower_simple_while_to_joinir;
//
// if is_simple_while_pattern(loop_form) {
// if let Some(inst) = lower_simple_while_to_joinir(loop_form, lowerer) {
// return Some(inst);
// }
// }
// ```
//
if is_simple_while_pattern(loop_form) {
if let Some(inst) = loop_patterns::lower_simple_while_to_joinir(loop_form, lowerer) {
eprintln!("[try_lower_loop_pattern] ✅ Pattern 1 (Simple While) matched");
return Some(inst);
}
}
// Pattern 2: Loop with Conditional Break (medium complexity)
// ===========================================================
//
// ```rust
// use crate::mir::loop_pattern_detection::is_loop_with_break_pattern;
// use crate::mir::join_ir::lowering::loop_patterns::lower_loop_with_break_to_joinir;
//
// if is_loop_with_break_pattern(loop_form) {
// if let Some(inst) = lower_loop_with_break_to_joinir(loop_form, lowerer) {
// return Some(inst);
// }
// }
// ```
//
if is_loop_with_break_pattern(loop_form) {
if let Some(inst) = loop_patterns::lower_loop_with_break_to_joinir(loop_form, lowerer) {
eprintln!("[try_lower_loop_pattern] ✅ Pattern 2 (Loop with Break) matched");
return Some(inst);
}
}
// Pattern 3: Loop with If-Else PHI (leverages existing If lowering)
// ==================================================================
//
// ```rust
// TODO: Implement Pattern 3 detection and lowering
// use crate::mir::loop_pattern_detection::is_loop_with_conditional_phi_pattern;
// use crate::mir::join_ir::lowering::loop_patterns::lower_loop_with_conditional_phi_to_joinir;
//
// if is_loop_with_conditional_phi_pattern(loop_form) {
// if let Some(inst) = lower_loop_with_conditional_phi_to_joinir(loop_form, lowerer) {
// if let Some(inst) = loop_patterns::lower_loop_with_conditional_phi_to_joinir(loop_form, lowerer) {
// eprintln!("[try_lower_loop_pattern] ✅ Pattern 3 (Loop with If-Else PHI) matched");
// return Some(inst);
// }
// }
// ```
//
// No Pattern Matched (fallback to existing lowering)
// ===================================================
//
// ```rust
// // No pattern matched, return None to trigger fallback
// None
// ```
// For now, return None (no pattern matched)
// This allows existing lowering to continue working
eprintln!("[try_lower_loop_pattern] ❌ No pattern matched, fallback to existing lowering");
None
}