feat(joinir): Phase 188.3 - Pattern6 (NestedLoopMinimal) 選択ロジック実装
## Phase 188.3 進捗: Phase 2 完了 (6/13 tasks) ### 実装完了 ✅ **Phase 1: Fixture作成** - apps/tests/phase1883_nested_minimal.hako 追加 - Add/Compare のみ（乗算なし） - 期待 exit code: 9 (3×3 nested loops) - 既存 lowering で fallback 動作確認 **Phase 2: 選択ロジック (SSOT)** - LoopPatternContext に step_tree_max_loop_depth フィールド追加 - choose_pattern_kind() に Pattern6 選択ロジック実装: 1. Cheap check (has_inner_loop) 2. StepTree 構築 (max_loop_depth 取得) 3. AST validation (is_pattern6_lowerable) - pattern6_nested_minimal.rs モジュール作成 (stub) - LOOP_PATTERNS に Pattern6 entry 追加 - **検証**: Pattern6 が正しく選択される ✅ ### 設計原則 (確認済み) 1. **Fail-Fast**: Pattern6 選択後は Ok(None) で逃げない 2. **outer 変数 write-back 検出 → validation false** (Phase 188.4+) 3. **最小実装**: inner local だけ、Pattern1 モデル二重化 4. **cfg! 依存なし**: production で動作 ### 検証結果 ``` [choose_pattern_kind] has_inner_loop=true [choose_pattern_kind] max_loop_depth=2 [choose_pattern_kind] is_pattern6_lowerable=true ✅ Pattern6 SELECTED! ``` Stub からの期待エラー: ``` [ERROR] ❌ [Pattern6] Nested loop lowering not yet implemented ``` ### 次: Phase 3 (Lowering 実装 - 推定4時間) 残りタスク: - Phase 3-1: AST 抽出ヘルパー - Phase 3-2: Validation ヘルパー - Phase 3-3: Continuation 生成 (outer_step, inner_step, k_inner_exit) - Phase 3-4: fixture が exit=9 を返すことを検証 ### 変更ファイル **新規**: - apps/tests/phase1883_nested_minimal.hako - src/mir/builder/control_flow/joinir/patterns/pattern6_nested_minimal.rs - docs/development/current/main/phases/phase-188.{1,2,3}/README.md **変更**: - src/mir/builder/control_flow/joinir/routing.rs (Pattern6 選択) - src/mir/builder/control_flow/joinir/patterns/router.rs (Context 拡張) - src/mir/builder/control_flow/joinir/patterns/mod.rs (module 宣言) 🎯 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
@ -34,11 +34,34 @@ pub fn check(tree: &StepTree, func_name: &str, strict: bool, dev: bool) -> Resul
|
||||
return Ok(()); // Default behavior: always pass
|
||||
}
|
||||
|
||||
// Phase 188.2: Check nesting depth BEFORE capability check
|
||||
// Reject max_loop_depth > 2 (only 1-level nesting supported)
|
||||
if tree.features.max_loop_depth > 2 {
|
||||
let tag = "control_tree/nested_loop/depth_exceeded";
|
||||
let msg = format!(
|
||||
"Nesting depth {} exceeds limit (max=2) in '{}' (step_tree_sig={})",
|
||||
tree.features.max_loop_depth,
|
||||
func_name,
|
||||
tree.signature.to_hex()
|
||||
);
|
||||
let hint = "Refactor to avoid 3+ level loop nesting, or run without HAKO_JOINIR_STRICT=1";
|
||||
|
||||
if dev {
|
||||
eprintln!(
|
||||
"[joinir/control_tree] depth exceeded: max_loop_depth={} in {}",
|
||||
tree.features.max_loop_depth, func_name
|
||||
);
|
||||
}
|
||||
|
||||
return Err(error_tags::freeze_with_hint(tag, &msg, hint));
|
||||
}
|
||||
|
||||
// Allowlist (supported capabilities)
|
||||
let allowed: BTreeSet<StepCapability> = [
|
||||
StepCapability::If,
|
||||
StepCapability::NestedIf,
|
||||
StepCapability::Loop,
|
||||
StepCapability::NestedLoop, // Phase 188.1: Pattern 6 minimal support
|
||||
StepCapability::Return,
|
||||
StepCapability::Break,
|
||||
StepCapability::Continue,
|
||||
@ -77,7 +100,8 @@ pub fn check(tree: &StepTree, func_name: &str, strict: bool, dev: bool) -> Resul
|
||||
fn get_hint_for_cap(cap: &StepCapability) -> String {
|
||||
match cap {
|
||||
StepCapability::NestedLoop => {
|
||||
"refactor to avoid nested loops (not supported yet) or run without HAKO_JOINIR_STRICT=1".to_string()
|
||||
// Phase 188.2: NestedLoop (1-level) is now supported
|
||||
"1-level nested loops supported; for 2+ levels use depth check error hint".to_string()
|
||||
}
|
||||
StepCapability::TryCatch => {
|
||||
"try/catch not supported in JoinIR yet, use HAKO_JOINIR_STRICT=0".to_string()
|
||||
@ -134,7 +158,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_nested_loop_strict_rejects() {
|
||||
fn test_nested_loop_1level_strict_passes() {
|
||||
// Phase 188.2: 1-level nested loop (depth=2) should PASS
|
||||
// AST: loop(i < 3) { loop(j < 2) { ... } }
|
||||
let nested_loop_ast = vec![ASTNode::Loop {
|
||||
condition: Box::new(bin_lt(var("i"), int_lit(3))),
|
||||
@ -148,12 +173,37 @@ mod tests {
|
||||
|
||||
let tree = StepTreeBuilderBox::build_from_block(&nested_loop_ast);
|
||||
|
||||
// strict=true should reject NestedLoop
|
||||
// strict=true should PASS (NestedLoop is in allowlist, depth=2 is OK)
|
||||
let result = check(&tree, "test_func", true, false);
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_nested_loop_2level_strict_rejects() {
|
||||
// Phase 188.2: 2+ level nested loop (depth=3) should FAIL
|
||||
// AST: loop { loop { loop { ... } } }
|
||||
let deeply_nested_ast = vec![ASTNode::Loop {
|
||||
condition: Box::new(bin_lt(var("i"), int_lit(3))),
|
||||
body: vec![ASTNode::Loop {
|
||||
condition: Box::new(bin_lt(var("j"), int_lit(2))),
|
||||
body: vec![ASTNode::Loop {
|
||||
condition: Box::new(bin_lt(var("k"), int_lit(1))),
|
||||
body: vec![],
|
||||
span: Span::unknown(),
|
||||
}],
|
||||
span: Span::unknown(),
|
||||
}],
|
||||
span: Span::unknown(),
|
||||
}];
|
||||
|
||||
let tree = StepTreeBuilderBox::build_from_block(&deeply_nested_ast);
|
||||
|
||||
// strict=true should reject depth > 2
|
||||
let result = check(&tree, "test_func", true, false);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert!(err.contains("[joinir/control_tree/cap_missing/NestedLoop]"));
|
||||
assert!(err.contains("Hint:"));
|
||||
assert!(err.contains("[joinir/control_tree/nested_loop/depth_exceeded]"));
|
||||
assert!(err.contains("max=2"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -188,6 +188,7 @@ mod tests {
|
||||
continue_count: 0,
|
||||
is_infinite_loop: false,
|
||||
update_summary: None,
|
||||
..Default::default() // Phase 188.1: Use default for new fields
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
@ -127,8 +127,7 @@ pub(crate) fn extract_features(
|
||||
break_count: if has_break { 1 } else { 0 },
|
||||
continue_count: if has_continue { 1 } else { 0 },
|
||||
is_infinite_loop,
|
||||
// Phase 170-C-2b: AST-based extraction doesn't have carrier names yet
|
||||
update_summary: None,
|
||||
..Default::default() // Phase 188.1: Use Default for nesting fields
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -79,6 +79,7 @@ pub(in crate::mir::builder) mod pattern2_with_break;
|
||||
pub(in crate::mir::builder) mod pattern3_with_if_phi;
|
||||
pub(in crate::mir::builder) mod pattern4_carrier_analyzer;
|
||||
pub(in crate::mir::builder) mod pattern4_with_continue;
|
||||
pub(in crate::mir::builder) mod pattern6_nested_minimal; // Phase 188.3: 1-level nested loop (Pattern1 outer + Pattern1 inner)
|
||||
pub(in crate::mir::builder) mod pattern6_scan_with_init; // Phase 254 P0: index_of/find/contains pattern
|
||||
pub(in crate::mir::builder) mod pattern7_split_scan; // Phase 256 P0: split/tokenization with variable step
|
||||
pub(in crate::mir::builder) mod pattern8_scan_bool_predicate; // Phase 259 P0: boolean predicate scan (is_integer/is_valid)
|
||||
|
||||
@ -0,0 +1,48 @@
|
||||
//! Phase 188.3: Pattern6 NestedLoopMinimal - 1-level nested loop lowering
|
||||
//!
|
||||
//! Handles loops of the form:
|
||||
//! ```nyash
|
||||
//! loop(outer_cond) {
|
||||
//! loop(inner_cond) {
|
||||
//! // inner body
|
||||
//! }
|
||||
//! // outer body (after inner loop)
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! Requirements (Pattern1 for both):
|
||||
//! - Outer loop: no break, no continue (Pattern1)
|
||||
//! - Inner loop: no break, no continue (Pattern1)
|
||||
//! - Exactly 1 inner loop
|
||||
//! - max_loop_depth == 2
|
||||
//!
|
||||
//! Strategy:
|
||||
//! - Generate outer_step continuation (contains inner loop call)
|
||||
//! - Generate inner_step continuation (tail recursion)
|
||||
//! - Generate k_inner_exit (bridges to outer continuation)
|
||||
//! - Wire continuations
|
||||
|
||||
use crate::mir::builder::control_flow::joinir::patterns::LoopPatternContext;
|
||||
use crate::mir::builder::MirBuilder;
|
||||
use crate::mir::loop_pattern_detection::LoopPatternKind;
|
||||
use crate::mir::ValueId;
|
||||
|
||||
/// Detect if this context can be lowered as Pattern6 (NestedLoopMinimal)
|
||||
///
|
||||
/// Pattern selection happens in choose_pattern_kind() (SSOT).
|
||||
/// This function just verifies ctx.pattern_kind matches.
|
||||
pub(crate) fn can_lower(_builder: &MirBuilder, ctx: &LoopPatternContext) -> bool {
|
||||
ctx.pattern_kind == LoopPatternKind::Pattern6NestedLoopMinimal
|
||||
}
|
||||
|
||||
/// Lower Pattern6 (NestedLoopMinimal) to MIR
|
||||
///
|
||||
/// Phase 188.3: Full implementation with continuation generation
|
||||
pub(crate) fn lower(
|
||||
_builder: &mut MirBuilder,
|
||||
_ctx: &LoopPatternContext,
|
||||
) -> Result<Option<ValueId>, String> {
|
||||
// Phase 188.3 stub - full implementation in Phase 3-3
|
||||
// TODO: Implement continuation generation (outer_step, inner_step, k_inner_exit)
|
||||
Err("[Pattern6] Nested loop lowering not yet implemented (Phase 188.3 stub)".to_string())
|
||||
}
|
||||
@ -74,6 +74,11 @@ pub(crate) struct LoopPatternContext<'a> {
|
||||
/// SSOT Principle: Avoid re-detecting ConditionalStep in lowering phase.
|
||||
#[allow(dead_code)]
|
||||
pub skeleton: Option<&'a LoopSkeleton>,
|
||||
|
||||
/// Phase 188.3: Cached StepTree max_loop_depth for Pattern6
|
||||
/// None if not computed, Some(depth) if Pattern6 candidate
|
||||
/// Avoids re-building StepTree in lowering phase
|
||||
pub step_tree_max_loop_depth: Option<u32>,
|
||||
}
|
||||
|
||||
impl<'a> LoopPatternContext<'a> {
|
||||
@ -111,6 +116,7 @@ impl<'a> LoopPatternContext<'a> {
|
||||
pattern_kind,
|
||||
fn_body: None, // Phase 200-C: Default to None
|
||||
skeleton: None, // Phase 92 P0-2: Default to None
|
||||
step_tree_max_loop_depth: None, // Phase 188.3: Default to None
|
||||
}
|
||||
}
|
||||
|
||||
@ -386,6 +392,11 @@ pub(crate) struct LoopPatternEntry {
|
||||
/// Note: func_name is now only used for debug logging, not pattern detection
|
||||
/// Phase 286: Pattern5 removed (migrated to Plan-based routing)
|
||||
pub(crate) static LOOP_PATTERNS: &[LoopPatternEntry] = &[
|
||||
LoopPatternEntry {
|
||||
name: "Pattern6_NestedLoopMinimal", // Phase 188.3: 1-level nested loop
|
||||
detect: super::pattern6_nested_minimal::can_lower,
|
||||
lower: super::pattern6_nested_minimal::lower,
|
||||
},
|
||||
LoopPatternEntry {
|
||||
name: "Pattern4_WithContinue",
|
||||
detect: super::pattern4_with_continue::can_lower,
|
||||
|
||||
@ -43,6 +43,43 @@ pub(in crate::mir::builder) fn choose_pattern_kind(
|
||||
let has_break = ast_features::detect_break_in_body(body);
|
||||
let has_return = ast_features::detect_return_in_body(body);
|
||||
|
||||
// Phase 188.3: Pattern6 selection for 1-level nested loops
|
||||
// SSOT: All Pattern6 detection happens here (no dev dependency)
|
||||
//
|
||||
// Strategy: Cheap check → StepTree → Full AST validation
|
||||
// Only select Pattern6 if lowering is guaranteed to work
|
||||
|
||||
// Step 1: Cheap check - does body contain any Loop node?
|
||||
let has_inner_loop = body.iter().any(|stmt| matches!(stmt, ASTNode::Loop { .. }));
|
||||
|
||||
if has_inner_loop {
|
||||
// Step 2: Build StepTree to get nesting depth (cost: acceptable for nested loops only)
|
||||
use crate::ast::Span;
|
||||
use crate::mir::control_tree::StepTreeBuilderBox;
|
||||
|
||||
let loop_ast = ASTNode::Loop {
|
||||
condition: Box::new(condition.clone()),
|
||||
body: body.to_vec(),
|
||||
span: Span::unknown(),
|
||||
};
|
||||
|
||||
let tree = StepTreeBuilderBox::build_from_ast(&loop_ast);
|
||||
|
||||
// Step 3: Check if exactly 1-level nesting (depth == 2)
|
||||
if tree.features.max_loop_depth == 2 {
|
||||
// Step 4: Full AST validation (Pattern1-compatible requirements)
|
||||
if is_pattern6_lowerable(&tree, body) {
|
||||
// Pattern6 selected - lowering MUST succeed
|
||||
trace::trace().dev(
|
||||
"choose_pattern_kind",
|
||||
"[routing] Pattern6 selected: 1-level nested loop validated"
|
||||
);
|
||||
return loop_pattern_detection::LoopPatternKind::Pattern6NestedLoopMinimal;
|
||||
}
|
||||
// Validation failed - not Pattern6, fall through to router_choice
|
||||
}
|
||||
}
|
||||
|
||||
// Phase 110: StepTree parity check (structure-only SSOT).
|
||||
//
|
||||
// This is dev-only; strict mode turns mismatch into a fail-fast.
|
||||
@ -145,6 +182,56 @@ pub(in crate::mir::builder) fn choose_pattern_kind(
|
||||
router_choice
|
||||
}
|
||||
|
||||
/// Phase 188.3: Validate nested loop meets ALL Pattern6 requirements
|
||||
///
|
||||
/// Returns true ONLY if Pattern6 lowering is guaranteed to succeed.
|
||||
/// False → fall through to other patterns (NOT an error)
|
||||
fn is_pattern6_lowerable(tree: &crate::mir::control_tree::StepTree, body: &[crate::ast::ASTNode]) -> bool {
|
||||
use crate::ast::ASTNode;
|
||||
|
||||
// Requirement 1: Outer loop has no break (Pattern1 requirement)
|
||||
if tree.features.has_break {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Requirement 2: Outer loop has no continue (Pattern1 requirement)
|
||||
if tree.features.has_continue {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Requirement 3: Extract inner loop(s) - must have exactly 1
|
||||
let mut inner_loop: Option<&ASTNode> = None;
|
||||
for stmt in body.iter() {
|
||||
if matches!(stmt, ASTNode::Loop { .. }) {
|
||||
if inner_loop.is_some() {
|
||||
// Multiple inner loops - not supported
|
||||
return false;
|
||||
}
|
||||
inner_loop = Some(stmt);
|
||||
}
|
||||
}
|
||||
|
||||
let inner_loop = match inner_loop {
|
||||
Some(l) => l,
|
||||
None => return false, // No inner loop found (shouldn't happen, but defensive)
|
||||
};
|
||||
|
||||
// Requirement 4: Inner loop has no break (Pattern1 requirement)
|
||||
use crate::mir::control_tree::StepTreeBuilderBox;
|
||||
let inner_tree = StepTreeBuilderBox::build_from_ast(inner_loop);
|
||||
if inner_tree.features.has_break {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Requirement 5: Inner loop has no continue (Pattern1 requirement)
|
||||
if inner_tree.features.has_continue {
|
||||
return false;
|
||||
}
|
||||
|
||||
// All requirements met - Pattern6 lowering will succeed
|
||||
true
|
||||
}
|
||||
|
||||
impl MirBuilder {
|
||||
/// Phase 49: Try JoinIR Frontend for mainline integration
|
||||
///
|
||||
|
||||
@ -132,6 +132,19 @@ pub fn try_lower_loop_pattern_to_joinir(
|
||||
|
||||
// Step 3: Route to appropriate lowerer based on pattern
|
||||
match pattern {
|
||||
LoopPatternKind::Pattern6NestedLoopMinimal => {
|
||||
// Phase 188.2: Pattern 6 lowering stub (infrastructure only)
|
||||
// Currently unreachable: LoopForm has no nesting info, so classify() never returns Pattern6
|
||||
#[cfg(debug_assertions)]
|
||||
eprintln!("[try_lower_loop_pattern] ℹ️ Pattern 6 (NestedLoop) reached (should be unreachable until Phase 188.3)");
|
||||
|
||||
if let Some(inst) =
|
||||
super::loop_patterns::lower_nested_loop_minimal_to_joinir(loop_form, lowerer)
|
||||
{
|
||||
return Some(inst);
|
||||
}
|
||||
// Stub returns None - fallback to existing lowering
|
||||
}
|
||||
LoopPatternKind::Pattern4Continue => {
|
||||
if let Some(inst) =
|
||||
super::loop_patterns::lower_loop_with_continue_to_joinir(loop_form, lowerer)
|
||||
@ -169,7 +182,19 @@ pub fn try_lower_loop_pattern_to_joinir(
|
||||
eprintln!("[try_lower_loop_pattern] ⚠️ Pattern 5 (InfiniteEarlyExit) not implemented in LoopForm router");
|
||||
}
|
||||
LoopPatternKind::Unknown => {
|
||||
eprintln!("[try_lower_loop_pattern] ❌ Unknown pattern, fallback to existing lowering");
|
||||
// Phase 188.1: Check for explicit rejection reasons (depth > 2)
|
||||
if features.max_loop_depth > 2 {
|
||||
eprintln!(
|
||||
"[try_lower_loop_pattern] ❌ EXPLICIT ERROR: max_loop_depth={} exceeds limit (max=2)",
|
||||
features.max_loop_depth
|
||||
);
|
||||
eprintln!(
|
||||
"[try_lower_loop_pattern] Hint: Nested loops with depth > 2 not supported in Phase 188.1"
|
||||
);
|
||||
// Fallback will trigger error (no silent Ok(None))
|
||||
} else {
|
||||
eprintln!("[try_lower_loop_pattern] ❌ Unknown pattern, fallback to existing lowering");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -50,11 +50,13 @@ pub mod simple_while;
|
||||
pub mod with_break;
|
||||
pub mod with_continue;
|
||||
pub mod with_if_phi;
|
||||
pub mod nested_minimal; // Phase 188.1
|
||||
|
||||
pub use simple_while::lower_simple_while_to_joinir;
|
||||
pub use with_break::lower_loop_with_break_to_joinir;
|
||||
pub use with_continue::lower_loop_with_continue_to_joinir;
|
||||
pub use with_if_phi::lower_loop_with_conditional_phi_to_joinir;
|
||||
pub use nested_minimal::lower_nested_loop_minimal_to_joinir; // Phase 188.1
|
||||
|
||||
// ============================================================================
|
||||
// Helper Functions (Shared Utilities)
|
||||
|
||||
369
src/mir/join_ir/lowering/loop_patterns/nested_minimal.rs
Normal file
369
src/mir/join_ir/lowering/loop_patterns/nested_minimal.rs
Normal file
@ -0,0 +1,369 @@
|
||||
//! Pattern 6: Nested Loop Minimal Lowering (Phase 188.1)
|
||||
//!
|
||||
//! Target: 1-level nested simple while loops
|
||||
//! Example: `loop(i < 3) { loop(j < 2) { ... } }`
|
||||
//!
|
||||
//! # Transformation
|
||||
//!
|
||||
//! ```text
|
||||
//! // Outer loop step function
|
||||
//! fn outer_step(outer_i, k_outer_exit):
|
||||
//! exit_cond = !(outer_i < 3)
|
||||
//! Jump(k_outer_exit, [], cond=exit_cond) // exit if condition false
|
||||
//!
|
||||
//! // Initialize inner loop variables
|
||||
//! inner_j = 0
|
||||
//!
|
||||
//! // Inner loop step function (nested)
|
||||
//! fn inner_step(inner_j, k_inner_exit):
|
||||
//! exit_cond = !(inner_j < 2)
|
||||
//! Jump(k_inner_exit, [], cond=exit_cond)
|
||||
//!
|
||||
//! print(inner_j)
|
||||
//! inner_j_next = inner_j + 1
|
||||
//! Call(inner_step, [inner_j_next, k_inner_exit]) // tail recursion
|
||||
//!
|
||||
//! // k_inner_exit continuation (resume outer loop)
|
||||
//! fn k_inner_exit():
|
||||
//! outer_i_next = outer_i + 1
|
||||
//! Call(outer_step, [outer_i_next, k_outer_exit]) // outer tail recursion
|
||||
//!
|
||||
//! // Entry: call inner loop
|
||||
//! Call(inner_step, [inner_j, k_inner_exit])
|
||||
//!
|
||||
//! // Main entry
|
||||
//! Call(outer_step, [0, k_main_exit])
|
||||
//! ```
|
||||
//!
|
||||
//! # Key Design Points
|
||||
//!
|
||||
//! - Outer step function contains inner step function (nested structure)
|
||||
//! - `k_inner_exit` resumes outer loop body after inner completes
|
||||
//! - Outer/inner carriers are isolated (no shared carriers)
|
||||
//! - Both loops use same tail-recursive pattern as Pattern 1
|
||||
//!
|
||||
//! # Supported Forms (Phase 188.1 Scope)
|
||||
//!
|
||||
//! - **Outer loop**: Pattern 1 (simple while, no break/continue)
|
||||
//! - **Inner loop**: Pattern 1 (simple while, no break/continue)
|
||||
//! - **Nesting depth**: EXACTLY 1 level (`max_loop_depth == 2`)
|
||||
//! - **No control flow**: No break/continue in either loop
|
||||
//! - **Sequential execution**: Inner loop completes before outer continues
|
||||
//!
|
||||
//! # Unsupported Forms (Explicit Error)
|
||||
//!
|
||||
//! - Deeper nesting (2+ levels): `max_loop_depth > 2`
|
||||
//! - Inner loop with break/continue
|
||||
//! - Outer loop with break/continue
|
||||
//! - Multiple inner loops (siblings)
|
||||
//!
|
||||
//! # Reference
|
||||
//!
|
||||
//! See `docs/development/current/main/phases/phase-188.1/README.md` for complete specification.
|
||||
|
||||
use crate::mir::join_ir::lowering::loop_to_join::LoopToJoinLowerer;
|
||||
use crate::mir::join_ir::JoinInst;
|
||||
use crate::mir::loop_form::LoopForm;
|
||||
|
||||
/// Lower 1-level nested simple while loops to JoinIR
|
||||
///
|
||||
/// # Pattern 6 Transformation Steps
|
||||
///
|
||||
/// 1. **Detect Outer + Inner Loops**
|
||||
/// - Validate outer loop is LoopForm
|
||||
/// - Find inner loop within outer body
|
||||
/// - Validate both are Pattern 1 (no break/continue)
|
||||
///
|
||||
/// 2. **Extract Outer Loop Variables**
|
||||
/// - Analyze outer header PHI nodes
|
||||
/// - Identify outer carriers (e.g., `outer_i`)
|
||||
///
|
||||
/// 3. **Extract Inner Loop Variables**
|
||||
/// - Analyze inner header PHI nodes
|
||||
/// - Identify inner carriers (e.g., `inner_j`)
|
||||
///
|
||||
/// 4. **Create Outer Step Function**
|
||||
/// - Signature: `fn outer_step(outer_i, k_outer_exit)`
|
||||
/// - Exit condition check: `!(outer_i < 3)`
|
||||
/// - Contains inner loop initialization
|
||||
///
|
||||
/// 5. **Create Inner Step Function (Nested)**
|
||||
/// - Signature: `fn inner_step(inner_j, k_inner_exit)`
|
||||
/// - Exit condition check: `!(inner_j < 2)`
|
||||
/// - Tail recursion: `Call(inner_step, [inner_j_next])`
|
||||
///
|
||||
/// 6. **Create k_inner_exit Continuation**
|
||||
/// - Resumes outer loop after inner completes
|
||||
/// - Updates outer carriers: `outer_i_next = outer_i + 1`
|
||||
/// - Tail call to outer: `Call(outer_step, [outer_i_next])`
|
||||
///
|
||||
/// 7. **Wire Continuations**
|
||||
/// - Inner exit → k_inner_exit
|
||||
/// - Outer exit → k_outer_exit (parent continuation)
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `loop_form` - The outer loop structure (must contain inner loop)
|
||||
/// * `lowerer` - The LoopToJoinLowerer builder (provides ValueId allocation)
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Some(JoinInst)` - Lowering succeeded, returns generated JoinIR instruction
|
||||
/// * `None` - Lowering failed (pattern not matched or unsupported)
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns `None` if:
|
||||
/// - Outer loop has break/continue (not Pattern 1)
|
||||
/// - Inner loop has break/continue (not Pattern 1)
|
||||
/// - Nesting depth > 2 (more than 1 level)
|
||||
/// - Multiple inner loops detected (siblings)
|
||||
/// - Inner loop not found in outer body
|
||||
///
|
||||
/// # Example Usage
|
||||
///
|
||||
/// ```rust,ignore
|
||||
/// use crate::mir::loop_pattern_detection::LoopPatternKind;
|
||||
///
|
||||
/// if pattern == LoopPatternKind::Pattern6NestedLoopMinimal {
|
||||
/// lower_nested_loop_minimal_to_joinir(&loop_form, &mut lowerer)?;
|
||||
/// }
|
||||
/// ```
|
||||
pub fn lower_nested_loop_minimal_to_joinir(
|
||||
_loop_form: &LoopForm,
|
||||
_lowerer: &mut LoopToJoinLowerer,
|
||||
) -> Option<JoinInst> {
|
||||
// TODO: Implement Pattern 6 lowering (Phase 188.1 Task 4)
|
||||
//
|
||||
// Step 1: Detect Outer + Inner Loops
|
||||
// ===================================
|
||||
// Validate loop_form is outer loop, find inner loop in body
|
||||
//
|
||||
// ```rust
|
||||
// let inner_loop = find_inner_loop_in_body(loop_form)?;
|
||||
// validate_nested_structure(loop_form, inner_loop)?;
|
||||
// ```
|
||||
//
|
||||
// Step 2: Extract Outer Loop Variables
|
||||
// =====================================
|
||||
// From outer header PHI: %2 = phi [%1, bb1], [%6, bb_outer_latch]
|
||||
//
|
||||
// ```rust
|
||||
// let outer_carriers = extract_carriers_from_header_phi(loop_form)?;
|
||||
// ```
|
||||
//
|
||||
// Step 3: Extract Inner Loop Variables
|
||||
// =====================================
|
||||
// From inner header PHI: %10 = phi [%9, bb_inner_preheader], [%14, bb_inner_latch]
|
||||
//
|
||||
// ```rust
|
||||
// let inner_carriers = extract_carriers_from_header_phi(inner_loop)?;
|
||||
// ```
|
||||
//
|
||||
// Step 4: Create Outer Step Function
|
||||
// ===================================
|
||||
// Signature: fn outer_step(outer_i: ValueId, k_outer_exit: JoinContId)
|
||||
//
|
||||
// ```rust
|
||||
// let outer_step_id = lowerer.allocate_join_func_id();
|
||||
// let k_outer_exit_id = lowerer.allocate_join_func_id();
|
||||
// let k_inner_exit_id = lowerer.allocate_join_func_id();
|
||||
//
|
||||
// // Outer step function body:
|
||||
// // 1. Exit condition check: exit_cond = !(outer_i < 3)
|
||||
// // 2. Jump(k_outer_exit, [], cond=exit_cond)
|
||||
// // 3. Initialize inner loop: inner_j = 0
|
||||
// // 4. Call(inner_step, [inner_j, k_inner_exit])
|
||||
// ```
|
||||
//
|
||||
// Step 5: Create Inner Step Function (Nested)
|
||||
// ============================================
|
||||
// Signature: fn inner_step(inner_j: ValueId, k_inner_exit: JoinContId)
|
||||
//
|
||||
// ```rust
|
||||
// let inner_step_id = lowerer.allocate_join_func_id();
|
||||
//
|
||||
// // Inner step function body:
|
||||
// // 1. Exit condition check: exit_cond = !(inner_j < 2)
|
||||
// // 2. Jump(k_inner_exit, [], cond=exit_cond)
|
||||
// // 3. Translate inner body instructions
|
||||
// // 4. Update inner carrier: inner_j_next = inner_j + 1
|
||||
// // 5. Tail call: Call(inner_step, [inner_j_next, k_inner_exit])
|
||||
// ```
|
||||
//
|
||||
// Step 6: Create k_inner_exit Continuation
|
||||
// =========================================
|
||||
// Resumes outer loop after inner completes
|
||||
//
|
||||
// ```rust
|
||||
// let k_inner_exit_func = JoinFunction {
|
||||
// id: k_inner_exit_id,
|
||||
// name: "k_inner_exit".to_string(),
|
||||
// params: vec![], // No values passed from inner to outer
|
||||
// body: vec![
|
||||
// // Update outer carrier: outer_i_next = outer_i + 1
|
||||
// // Tail call to outer: Call(outer_step, [outer_i_next, k_outer_exit])
|
||||
// ],
|
||||
// exit_cont: Some(k_outer_exit_id),
|
||||
// };
|
||||
// lowerer.register_join_function(k_inner_exit_func);
|
||||
// ```
|
||||
//
|
||||
// Step 7: Wire Continuations
|
||||
// ===========================
|
||||
// Connect inner/outer exits to appropriate continuations
|
||||
//
|
||||
// ```rust
|
||||
// // Inner step exit → k_inner_exit
|
||||
// // Outer step exit → k_outer_exit (parent continuation)
|
||||
// ```
|
||||
|
||||
// For now, return None (stub implementation)
|
||||
// Actual implementation will be added incrementally
|
||||
None
|
||||
}
|
||||
|
||||
/// Validate nested loop structure meets Pattern 6 requirements
|
||||
///
|
||||
/// # Validation Rules (Phase 188.1)
|
||||
///
|
||||
/// 1. **Outer loop must be Pattern 1**
|
||||
/// - No break statements
|
||||
/// - No continue statements
|
||||
/// - Simple while condition
|
||||
///
|
||||
/// 2. **Inner loop must be Pattern 1**
|
||||
/// - No break statements
|
||||
/// - No continue statements
|
||||
/// - Simple while condition
|
||||
///
|
||||
/// 3. **Nesting depth must be exactly 2**
|
||||
/// - Only 1 level of nesting (max_loop_depth == 2)
|
||||
/// - Deeper nesting (3+ levels) is out-of-scope
|
||||
///
|
||||
/// 4. **No multiple inner loops**
|
||||
/// - Only one inner loop allowed (no siblings)
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `outer_loop` - The outer loop structure
|
||||
/// * `inner_loop` - The inner loop structure
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Ok(())` - Validation passed
|
||||
/// * `Err(String)` - Validation failed with error message
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Uses `error_tags::freeze_with_hint()` format for explicit errors:
|
||||
///
|
||||
/// - `[joinir/nested_loop/outer_control_flow]` - Outer loop has break/continue
|
||||
/// - `[joinir/nested_loop/inner_control_flow]` - Inner loop has break/continue
|
||||
/// - `[joinir/nested_loop/depth_exceeded]` - Nesting depth > 2
|
||||
/// - `[joinir/nested_loop/multiple_inner]` - Multiple inner loops detected
|
||||
#[allow(dead_code)]
|
||||
fn validate_nested_structure(
|
||||
_outer_loop: &LoopForm,
|
||||
_inner_loop: &LoopForm,
|
||||
) -> Result<(), String> {
|
||||
// TODO: Implement validation (Phase 188.1 Task 4)
|
||||
//
|
||||
// Check 1: Outer loop must be Pattern 1
|
||||
// ======================================
|
||||
// if has_break_or_continue(outer_loop) {
|
||||
// return Err(error_tags::freeze_with_hint(
|
||||
// "nested_loop/outer_control_flow",
|
||||
// "Outer loop has break/continue (not supported in Pattern 6)",
|
||||
// "Only simple while loops supported as outer loops (Pattern 1 only)",
|
||||
// ));
|
||||
// }
|
||||
//
|
||||
// Check 2: Inner loop must be Pattern 1
|
||||
// ======================================
|
||||
// if has_break_or_continue(inner_loop) {
|
||||
// return Err(error_tags::freeze_with_hint(
|
||||
// "nested_loop/inner_control_flow",
|
||||
// "Inner loop has break/continue (not supported in Pattern 6)",
|
||||
// "Only simple while loops supported as inner loops (Pattern 1 only)",
|
||||
// ));
|
||||
// }
|
||||
//
|
||||
// Check 3: Nesting depth must be exactly 2
|
||||
// =========================================
|
||||
// (This is validated earlier in classify(), but double-check here)
|
||||
//
|
||||
// Check 4: No multiple inner loops
|
||||
// =================================
|
||||
// let inner_loop_count = count_inner_loops(outer_loop);
|
||||
// if inner_loop_count > 1 {
|
||||
// return Err(error_tags::freeze_with_hint(
|
||||
// "nested_loop/multiple_inner",
|
||||
// &format!("Multiple inner loops detected ({} loops)", inner_loop_count),
|
||||
// "Only one inner loop supported in Pattern 6 (Phase 188.1 scope)",
|
||||
// ));
|
||||
// }
|
||||
|
||||
// For now, return Ok (stub implementation)
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Check if loop has break or continue statements
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `loop_form` - The loop structure to check
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `true` - Loop has break or continue
|
||||
/// * `false` - Loop is Pattern 1 (no break/continue)
|
||||
#[allow(dead_code)]
|
||||
fn has_break_or_continue(_loop_form: &LoopForm) -> bool {
|
||||
// TODO: Check loop_form.break_targets, loop_form.continue_targets
|
||||
// For now, assume no break/continue (conservative)
|
||||
false
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
#[ignore] // TODO: Implement test after lowering logic is complete
|
||||
fn test_pattern6_lowering_success() {
|
||||
// TODO: Add integration test for nested loop pattern lowering
|
||||
// Step 1: Create mock LoopForm for nested loop pattern
|
||||
// Step 2: Create mock LoopToJoinLowerer
|
||||
// Step 3: Call lower_nested_loop_minimal_to_joinir()
|
||||
// Step 4: Assert returns Some(JoinInst)
|
||||
// Step 5: Verify generated JoinIR structure (nested functions)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore] // TODO: Implement test after lowering logic is complete
|
||||
fn test_pattern6_rejects_outer_break() {
|
||||
// TODO: Add test that rejects outer loop with break
|
||||
// Step 1: Create mock LoopForm with break in outer loop
|
||||
// Step 2: Call lower_nested_loop_minimal_to_joinir()
|
||||
// Step 3: Assert returns None (unsupported pattern)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore] // TODO: Implement test after lowering logic is complete
|
||||
fn test_pattern6_rejects_inner_continue() {
|
||||
// TODO: Add test that rejects inner loop with continue
|
||||
// Step 1: Create mock LoopForm with continue in inner loop
|
||||
// Step 2: Call lower_nested_loop_minimal_to_joinir()
|
||||
// Step 3: Assert returns None (unsupported pattern)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore] // TODO: Implement test after lowering logic is complete
|
||||
fn test_pattern6_rejects_2level_nesting() {
|
||||
// TODO: Add test that rejects 2+ level nesting
|
||||
// Step 1: Create mock LoopForm with loop { loop { loop {} } }
|
||||
// Step 2: Call lower_nested_loop_minimal_to_joinir()
|
||||
// Step 3: Assert returns None (depth exceeded)
|
||||
}
|
||||
}
|
||||
@ -307,15 +307,9 @@ impl CaseALoweringShape {
|
||||
|
||||
// Create stub features (Phase 170-B will use real LoopFeatures)
|
||||
let stub_features = crate::mir::loop_pattern_detection::LoopFeatures {
|
||||
has_break: false, // Unknown from LoopScopeShape alone
|
||||
has_continue: false, // Unknown from LoopScopeShape alone
|
||||
has_if: false,
|
||||
has_if_else_phi: false,
|
||||
carrier_count,
|
||||
break_count: 0,
|
||||
continue_count: 0,
|
||||
is_infinite_loop: false, // Phase 131-11: Unknown from LoopScopeShape alone
|
||||
update_summary: Some(update_summary),
|
||||
..Default::default() // Phase 188.1: Use Default for nesting fields
|
||||
};
|
||||
|
||||
Self::detect_with_updates(&stub_features, carrier_count, has_progress_carrier)
|
||||
|
||||
@ -75,15 +75,9 @@ impl LoopViewBuilder {
|
||||
let update_summary = loop_update_summary::analyze_loop_updates_by_name(&carrier_names);
|
||||
|
||||
let stub_features = crate::mir::loop_pattern_detection::LoopFeatures {
|
||||
has_break: false,
|
||||
has_continue: false,
|
||||
has_if: false,
|
||||
has_if_else_phi: false,
|
||||
carrier_count: scope.carriers.len(),
|
||||
break_count: 0,
|
||||
continue_count: 0,
|
||||
is_infinite_loop: false, // Phase 131-11: Unknown from LoopScopeShape alone
|
||||
update_summary: Some(update_summary),
|
||||
..Default::default() // Phase 188.1: Use Default for nesting fields
|
||||
};
|
||||
|
||||
let has_progress_carrier = scope.progress_carrier.is_some();
|
||||
|
||||
@ -58,6 +58,13 @@ pub enum LoopPatternKind {
|
||||
/// - Minimal carrier (1 counter-like variable)
|
||||
InfiniteEarlyExit,
|
||||
|
||||
/// Pattern 6: Nested Loop (1-level, minimal) - Phase 188.1
|
||||
/// - Outer loop: Pattern 1 (simple while)
|
||||
/// - Inner loop: Pattern 1 (simple while)
|
||||
/// - max_loop_depth == 2 exactly
|
||||
/// - No break/continue in either loop
|
||||
Pattern6NestedLoopMinimal,
|
||||
|
||||
/// Pattern not recognized
|
||||
Unknown,
|
||||
}
|
||||
@ -73,6 +80,7 @@ impl LoopPatternKind {
|
||||
LoopPatternKind::Pattern3IfPhi => "Pattern 3: Loop with If-Else PHI",
|
||||
LoopPatternKind::Pattern4Continue => "Pattern 4: Loop with Continue",
|
||||
LoopPatternKind::InfiniteEarlyExit => "Pattern 5: Infinite Loop with Early Exit",
|
||||
LoopPatternKind::Pattern6NestedLoopMinimal => "Pattern 6: Nested Loop (1-level minimal)",
|
||||
LoopPatternKind::Unknown => "Unknown Pattern",
|
||||
}
|
||||
}
|
||||
@ -88,6 +96,7 @@ impl LoopPatternKind {
|
||||
LoopPatternKind::Pattern3IfPhi => 3,
|
||||
LoopPatternKind::Pattern4Continue => 4,
|
||||
LoopPatternKind::InfiniteEarlyExit => 5,
|
||||
LoopPatternKind::Pattern6NestedLoopMinimal => 6,
|
||||
LoopPatternKind::Unknown => 0,
|
||||
}
|
||||
}
|
||||
@ -150,6 +159,12 @@ pub struct LoopFeatures {
|
||||
/// Phase 131-11: Is this an infinite loop? (condition == true)
|
||||
pub is_infinite_loop: bool,
|
||||
|
||||
/// Phase 188.1: Nesting depth (1 = single loop, 2 = 1-level nested, etc.)
|
||||
pub max_loop_depth: u32,
|
||||
|
||||
/// Phase 188.1: Has inner loops?
|
||||
pub has_inner_loops: bool,
|
||||
|
||||
/// Phase 170-C-2b: Carrier update pattern summary
|
||||
///
|
||||
/// Contains UpdateKind (CounterLike/AccumulationLike/Other) for each carrier.
|
||||
@ -159,13 +174,31 @@ pub struct LoopFeatures {
|
||||
Option<crate::mir::join_ir::lowering::loop_update_summary::LoopUpdateSummary>,
|
||||
}
|
||||
|
||||
impl Default for LoopFeatures {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
has_break: false,
|
||||
has_continue: false,
|
||||
has_if: false,
|
||||
has_if_else_phi: false,
|
||||
carrier_count: 0,
|
||||
break_count: 0,
|
||||
continue_count: 0,
|
||||
is_infinite_loop: false,
|
||||
max_loop_depth: 1, // Phase 188.1: Default (no nesting)
|
||||
has_inner_loops: false, // Phase 188.1: Default (no nesting)
|
||||
update_summary: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LoopFeatures {
|
||||
/// Phase 193-3: Get debug statistics string
|
||||
///
|
||||
/// Returns a formatted string showing all feature values for debugging.
|
||||
pub fn debug_stats(&self) -> String {
|
||||
format!(
|
||||
"LoopFeatures {{ break: {}, continue: {}, if: {}, if_else_phi: {}, carriers: {}, break_count: {}, continue_count: {}, infinite: {} }}",
|
||||
"LoopFeatures {{ break: {}, continue: {}, if: {}, if_else_phi: {}, carriers: {}, break_count: {}, continue_count: {}, infinite: {}, depth: {}, inner: {} }}",
|
||||
self.has_break,
|
||||
self.has_continue,
|
||||
self.has_if,
|
||||
@ -173,7 +206,9 @@ impl LoopFeatures {
|
||||
self.carrier_count,
|
||||
self.break_count,
|
||||
self.continue_count,
|
||||
self.is_infinite_loop
|
||||
self.is_infinite_loop,
|
||||
self.max_loop_depth,
|
||||
self.has_inner_loops
|
||||
)
|
||||
}
|
||||
|
||||
@ -271,6 +306,12 @@ pub(crate) fn extract_features(
|
||||
)
|
||||
});
|
||||
|
||||
// Phase 188.1: Nesting detection
|
||||
// TODO: Detect from LoopForm structure (nested LoopForm presence)
|
||||
// For now, default to no nesting (will be detected in lowering phase)
|
||||
let max_loop_depth = 1;
|
||||
let has_inner_loops = false;
|
||||
|
||||
LoopFeatures {
|
||||
has_break,
|
||||
has_continue,
|
||||
@ -280,6 +321,8 @@ pub(crate) fn extract_features(
|
||||
break_count,
|
||||
continue_count,
|
||||
is_infinite_loop: false, // Phase 131-11: LoopForm doesn't have condition info, default to false
|
||||
max_loop_depth,
|
||||
has_inner_loops,
|
||||
update_summary,
|
||||
}
|
||||
}
|
||||
@ -323,6 +366,22 @@ pub(crate) fn extract_features(
|
||||
/// Both routers (`router.rs` and `loop_pattern_router.rs`) use this
|
||||
/// function to avoid duplicate detection logic.
|
||||
pub fn classify(features: &LoopFeatures) -> LoopPatternKind {
|
||||
// Phase 188.1: Pattern 6: NestedLoop (1-level only, check first after depth validation)
|
||||
// Reject 2+ level nesting (explicit error) BEFORE any pattern matching
|
||||
if features.max_loop_depth > 2 {
|
||||
// Return Unknown to trigger explicit error in router
|
||||
return LoopPatternKind::Unknown;
|
||||
}
|
||||
|
||||
// Pattern 6: NestedLoop Minimal (1-level nested, simple while inside simple while)
|
||||
if features.max_loop_depth == 2
|
||||
&& features.has_inner_loops
|
||||
&& !features.has_break
|
||||
&& !features.has_continue
|
||||
{
|
||||
return LoopPatternKind::Pattern6NestedLoopMinimal;
|
||||
}
|
||||
|
||||
// Phase 131-11: Pattern 5: InfiniteEarlyExit (highest priority - most specific)
|
||||
// MUST check before Pattern 4 to avoid misrouting break+continue cases
|
||||
if features.is_infinite_loop && features.has_break && features.has_continue {
|
||||
@ -391,6 +450,12 @@ pub fn classify_with_diagnosis(features: &LoopFeatures) -> (LoopPatternKind, Str
|
||||
LoopPatternKind::Pattern1SimpleWhile => {
|
||||
"Simple while loop with no special control flow".to_string()
|
||||
}
|
||||
LoopPatternKind::Pattern6NestedLoopMinimal => {
|
||||
format!(
|
||||
"Nested loop (1-level, max_loop_depth={}) with no break/continue",
|
||||
features.max_loop_depth
|
||||
)
|
||||
}
|
||||
LoopPatternKind::InfiniteEarlyExit => {
|
||||
format!(
|
||||
"Infinite loop (loop(true)) with both break and continue (break_count={}, continue_count={})",
|
||||
|
||||
@ -118,6 +118,7 @@ fn classify_body(body: &[ASTNode]) -> LoopPatternKind {
|
||||
continue_count: if has_continue_flag { 1 } else { 0 },
|
||||
is_infinite_loop: false, // テストでは通常ループを想定
|
||||
update_summary: None,
|
||||
..Default::default() // Phase 188.1: Use default for new fields
|
||||
};
|
||||
classify(&features)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user