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

feat(control_tree): Phase 132 P0 + P0.5 - loop(true) + post-loop support

Browse Source 
**Phase 132 P0**: Extend loop(true) break-once to support post-loop statements

Goal: Support `loop(true) { x = 1; break }; x = x + 2; return x` → exit code 3

Implementation:
- loop_true_break_once.rs: Add post_k continuation generation
- Reuse Phase 130's lower_assign_stmt for post statements
- ExitMeta uses DirectValue mode (PHI-free)

**Phase 132 P0.5**: Fix StepTree post-loop statement visibility

Root cause: routing.rs created StepTree from Loop node only, losing post statements

Solution:
- New: normalized_shadow_suffix_router_box.rs
- Detects block suffix: Loop + Assign* + Return
- Creates StepTree from entire suffix (Block([Loop, Assign, Return]))
- Modified build_block() to call suffix router (dev-only)

Changes:
- apps/tests/phase132_loop_true_break_once_post_add_min.hako (new fixture)
- tools/smokes/v2/profiles/integration/apps/phase132_loop_true_break_once_post_add_*.sh
- src/mir/control_tree/normalized_shadow/loop_true_break_once.rs (+150 lines)
- src/mir/builder/control_flow/joinir/patterns/policies/normalized_shadow_suffix_router_box.rs (+380 lines)
- src/mir/builder/stmts.rs (build_block modified to support suffix skipping)

Design principles:
- StepTree unchanged: Block is SSOT for statement order
- No data duplication: Loop doesn't hold post_nodes
- Suffix router handles detection + conversion
- build_block() handles wiring only

Test results:
- Phase 132 VM: PASS (exit code 3)
- Phase 131 regression: PASS
- Phase 97 regression: PASS

Related: Phase 132 loop(true) + post-loop minimal support

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

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
nyash-codex
2025-12-18 21:51:33 +09:00
parent 4169da8c33
commit b5d8ace6ab
7 changed files with 690 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/mir/builder/control_flow/joinir/patterns/policies/mod.rs
View File

@ -36,3 +36,4 @@ pub(in crate::mir::builder) mod loop_true_read_digits_policy;
pub(in crate::mir::builder) mod balanced_depth_scan_policy;
pub(in crate::mir::builder) mod balanced_depth_scan_policy_box;
pub(in crate::mir::builder) mod post_loop_early_return_plan;
pub(in crate::mir::builder) mod normalized_shadow_suffix_router_box; // Phase 132 P0.5

375
src/mir/builder/control_flow/joinir/patterns/policies/normalized_shadow_suffix_router_box.rs Normal file
View File

@ -0,0 +1,375 @@
//! Phase 132 P0.5: Suffix router box for loop(true) + post statements
//!
//! ## Responsibility
//!
//! - Detect block suffix starting with loop(true) { ... break } + post statements
//! - Lower the entire suffix to Normalized JoinModule via StepTree
//! - Return consumed count to skip processed statements in build_block()
//!
//! ## Contract
//!
//! - Returns Ok(Some(consumed)): Successfully processed remaining[..consumed]
//! - Returns Ok(None): Pattern not matched, use default behavior
//! - Returns Err(_): Internal error
//!
//! ## Design
//!
//! - Uses existing StepTree infrastructure (no StepNode modification)
//! - Block SSOT: StepTree already supports Block([Loop, Assign, Return])
//! - Responsibility separation: suffix router = detection + conversion, build_block = wiring
use crate::ast::ASTNode;
use crate::mir::builder::MirBuilder;
use crate::mir::control_tree::normalized_shadow::available_inputs_collector::AvailableInputsCollectorBox;
use crate::mir::control_tree::normalized_shadow::StepTreeNormalizedShadowLowererBox;
use crate::mir::control_tree::StepTreeBuilderBox;
use crate::mir::join_ir::lowering::carrier_info::{CarrierRole, ExitReconnectMode};
use crate::mir::join_ir::lowering::inline_boundary::{JoinInlineBoundary, LoopExitBinding};
/// Box-First: Suffix router for normalized shadow lowering
pub struct NormalizedShadowSuffixRouterBox;
impl NormalizedShadowSuffixRouterBox {
/// Try to lower a block suffix starting with loop(true) + post statements
///
/// Returns:
/// - Ok(Some(consumed)): Successfully processed remaining[..consumed]
/// - Ok(None): Pattern not matched, use default behavior
/// - Err(_): Internal error
pub fn try_lower_loop_suffix(
builder: &mut MirBuilder,
remaining: &[ASTNode],
func_name: &str,
debug: bool,
) -> Result<Option<usize>, String> {
// Phase 132 P0.5 CRITICAL: Only match suffixes with POST-loop statements!
//
// This function is called on EVERY remaining block suffix, including:
// - Phase 131: [Loop, Return] ← Should go through normal routing (NOT a suffix)
// - Phase 132: [Loop, Assign, Return] ← This is our target (suffix with post-computation)
//
// We MUST NOT match Phase 131 patterns, as they're already handled correctly
// by try_normalized_shadow() in routing.rs.
// Quick pattern check: need at least loop + assign + return (3 statements minimum)
if remaining.len() < 3 {
return Ok(None);
}
// Check if first statement is a loop
let is_loop = matches!(&remaining[0], ASTNode::Loop { .. });
if !is_loop {
return Ok(None);
}
// Check if there's an assignment after the loop (Phase 132-specific)
let has_post_assignment = matches!(&remaining[1], ASTNode::Assignment { .. });
if !has_post_assignment {
return Ok(None); // Not Phase 132, let normal routing handle it
}
// Suffix requires an explicit return statement (the router consumes it)
let return_stmt = match &remaining[2] {
ASTNode::Return { .. } => remaining[2].clone(),
_ => return Ok(None),
};
// Phase 132 P0 pattern detection:
// - remaining[0]: Loop(true) { ... break }
// - remaining[1]: Assign (post-loop computation)
// - remaining[2]: Return
//
// Let StepTree handle the pattern validation (condition = true, break at end, etc.)
let trace = crate::mir::builder::control_flow::joinir::trace::trace();
trace.routing(
"suffix_router",
func_name,
&format!(
"Detected potential loop suffix: {} statements starting with Loop",
remaining.len()
),
);
// Build StepTree from the reachable suffix (up to and including the return).
//
// Even if the AST block contains extra statements after return, they are unreachable
// and must not affect the structural decision.
let suffix = &remaining[..3];
let step_tree = StepTreeBuilderBox::build_from_block(suffix);
// Collect available inputs from MirBuilder state
let available_inputs = AvailableInputsCollectorBox::collect(builder, None);
trace.routing(
"suffix_router/normalized",
func_name,
&format!(
"Trying Normalized shadow lowering (available_inputs: {})",
available_inputs.len()
),
);
// Try Normalized lowering (loop(true) break-once with post statements)
match StepTreeNormalizedShadowLowererBox::try_lower_if_only(&step_tree, &available_inputs) {
Ok(Some((join_module, join_meta))) => {
trace.routing(
"suffix_router/normalized",
func_name,
&format!(
"Normalized lowering succeeded ({} functions, {} exit bindings)",
join_module.functions.len(),
join_meta.exit_meta.exit_values.len()
),
);
// Phase 132 P0.5: Merge the JoinModule into MIR
Self::merge_normalized_joinir(
builder,
join_module,
join_meta,
func_name,
debug,
)?;
// Phase 132 P1: Emit host-level return for the consumed suffix.
//
// JoinIR merge converts fragment Returns to Jump(exit_block_id) to keep the
// “single-exit block” merge invariant. For suffix routing, we must still
// terminate the host function at this point.
if let ASTNode::Return { value, .. } = return_stmt {
let _ = builder.build_return_statement(value)?;
}
// Return consumed count (loop + post-assign + return)
Ok(Some(3))
}
Ok(None) => {
// Out of scope (not a Normalized pattern)
trace.routing(
"suffix_router/normalized",
func_name,
"Normalized lowering: out of scope",
);
Ok(None)
}
Err(e) => {
// In scope but failed
let msg = format!(
"Phase 132/suffix_router: Failed to lower loop suffix in '{}': {}",
func_name, e
);
if crate::config::env::joinir_dev::strict_enabled() {
use crate::mir::join_ir::lowering::error_tags;
return Err(error_tags::freeze_with_hint(
"phase132/suffix_router/internal",
&e,
"Loop suffix should be supported by Normalized but conversion failed. \
Check that pattern matches loop(true) { ... break } + post statements.",
));
}
trace.routing("suffix_router/normalized/error", func_name, &msg);
Ok(None) // Fallback to default behavior in non-strict mode
}
}
}
/// Merge Normalized JoinModule into MIR builder (Phase 132 P0.5)
///
/// This is the shared merge logic extracted from routing.rs
fn merge_normalized_joinir(
builder: &mut MirBuilder,
join_module: crate::mir::join_ir::JoinModule,
join_meta: crate::mir::join_ir::lowering::carrier_info::JoinFragmentMeta,
func_name: &str,
debug: bool,
) -> Result<(), String> {
use crate::mir::builder::control_flow::joinir::merge;
use crate::mir::join_ir::frontend::JoinFuncMetaMap;
use crate::mir::join_ir_vm_bridge::bridge_joinir_to_mir_with_meta;
use std::collections::BTreeMap;
let trace = crate::mir::builder::control_flow::joinir::trace::trace();
// Build exit_bindings from meta
let exit_bindings: Vec<LoopExitBinding> = join_meta
.exit_meta
.exit_values
.iter()
.map(|(carrier_name, join_exit_value)| {
// Get host_slot from variable_map
let host_slot = builder
.variable_ctx
.variable_map
.get(carrier_name)
.copied()
.unwrap_or_else(|| {
panic!(
"[Phase 132 P0.5] Carrier '{}' not in variable_map (available: {:?})",
carrier_name,
builder.variable_ctx.variable_map.keys().collect::<Vec<_>>()
)
});
LoopExitBinding {
carrier_name: carrier_name.clone(),
join_exit_value: *join_exit_value,
host_slot,
role: CarrierRole::LoopState,
}
})
.collect();
// Create boundary with DirectValue mode
let mut boundary = JoinInlineBoundary::new_with_exit_bindings(
vec![], // No join_inputs for Normalized
vec![], // No host_inputs for Normalized
exit_bindings,
);
boundary.exit_reconnect_mode = ExitReconnectMode::DirectValue; // Phase 132 P0.5: No PHI
boundary.continuation_func_ids = join_meta.continuation_funcs.clone();
// Bridge JoinIR to MIR
let empty_meta: JoinFuncMetaMap = BTreeMap::new();
let mir_module = bridge_joinir_to_mir_with_meta(&join_module, &empty_meta)
.map_err(|e| format!("[suffix_router/normalized] MIR conversion failed: {:?}", e))?;
// Merge with boundary - this populates MergeResult.remapped_exit_values
// and calls ExitLineOrchestrator with DirectValue mode
let _exit_phi_result = merge::merge_joinir_mir_blocks(
builder,
&mir_module,
Some(&boundary),
debug,
)?;
trace.routing(
"suffix_router/normalized",
func_name,
&format!(
"Normalized merge + reconnection completed ({} exit bindings)",
boundary.exit_bindings.len()
),
);
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::{ASTNode, LiteralValue, Span};
#[test]
fn test_try_lower_loop_suffix_phase132_pattern() {
// This is an integration test that would require full MirBuilder setup
// For now, we test the pattern detection logic
let span = Span::unknown();
let remaining = vec![
ASTNode::Loop {
condition: Box::new(ASTNode::Literal {
value: LiteralValue::Bool(true),
span: span.clone(),
}),
body: vec![
ASTNode::Assignment {
target: Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
}),
value: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(1),
span: span.clone(),
}),
span: span.clone(),
},
ASTNode::Break { span: span.clone() },
],
span: span.clone(),
},
ASTNode::Assignment {
target: Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
}),
value: Box::new(ASTNode::BinaryOp {
left: Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
}),
operator: crate::ast::BinaryOperator::Add,
right: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(2),
span: span.clone(),
}),
span: span.clone(),
}),
span: span.clone(),
},
ASTNode::Return {
value: Some(Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
})),
span: span.clone(),
},
];
// Pattern should be detected (at least 2 statements, first is Loop)
assert!(remaining.len() >= 2);
assert!(matches!(&remaining[0], ASTNode::Loop { .. }));
// Full lowering test would require MirBuilder setup
// This validates the pattern structure
}
#[test]
fn test_try_lower_loop_suffix_no_match_too_short() {
// Single statement - should not match
let span = Span::unknown();
let remaining = vec![
ASTNode::Loop {
condition: Box::new(ASTNode::Literal {
value: LiteralValue::Bool(true),
span: span.clone(),
}),
body: vec![ASTNode::Break { span: span.clone() }],
span: span.clone(),
},
];
// Pattern should not match (need at least 2 statements)
assert!(remaining.len() < 2);
}
#[test]
fn test_try_lower_loop_suffix_no_match_not_loop() {
// First statement is not a loop
let span = Span::unknown();
let remaining = vec![
ASTNode::Assignment {
target: Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
}),
value: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(1),
span: span.clone(),
}),
span: span.clone(),
},
ASTNode::Return {
value: Some(Box::new(ASTNode::Variable {
name: "x".to_string(),
span: span.clone(),
})),
span: span.clone(),
},
];
// Pattern should not match (first statement is not Loop)
assert!(!matches!(&remaining[0], ASTNode::Loop { .. }));
}
}