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

feat(joinir): Phase 246-EX Part 2 - Exit PHI & step scheduling fixes

Browse Source 
Phase 246-EX Part 2 completes the _atoi JoinIR integration:

Key fixes:
- Exit PHI connection: ExitLineReconnector now correctly uses exit PHI dsts
- Jump args preservation: BasicBlock.jump_args field stores JoinIR exit values
- instruction_rewriter: Reads jump_args, remaps JoinIR→HOST values by carrier order
- step_schedule.rs: New module for body-local init step ordering

Files changed:
- reconnector.rs: Exit PHI connection improvements
- instruction_rewriter.rs: Jump args reading & carrier value mapping
- loop_with_break_minimal.rs: Refactored step scheduling
- step_schedule.rs: NEW - Step ordering logic extracted

Tests: 931/931 PASS (no regression)

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
nyash-codex
2025-12-11 16:46:53 +09:00
parent e356524b0a
commit eb00d97fdb
16 changed files with 802 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/mir/builder/control_flow/joinir/merge/exit_line/meta_collector.rs
View File

@ -81,6 +81,7 @@ impl ExitMetaCollector {
debug: bool,
) -> Vec<LoopExitBinding> {
let mut bindings = Vec::new();
let verbose = debug || crate::config::env::joinir_dev_enabled();
if debug {
eprintln!(
@ -170,6 +171,22 @@ impl ExitMetaCollector {
bindings.push(binding);
}
Some((CarrierRole::LoopState, CarrierInit::LoopLocalZero)) => {
// Loop-local derived carrier: include binding with placeholder host slot
let binding = LoopExitBinding {
carrier_name: carrier_name.clone(),
join_exit_value: *join_exit_value,
host_slot: ValueId(0), // No host slot; used for latch/PHI only
role: CarrierRole::LoopState,
};
eprintln!(
"[cf_loop/exit_line] Phase 247-EX: Collected loop-local carrier '{}' JoinIR {:?} (no host slot)",
carrier_name, join_exit_value
);
bindings.push(binding);
}
_ => {
eprintln!(
"[cf_loop/exit_line] ExitMetaCollector DEBUG: Carrier '{}' not in variable_map and not ConditionOnly/FromHost (skip)",
@ -180,10 +197,11 @@ impl ExitMetaCollector {
}
}
if debug {
if verbose {
eprintln!(
"[cf_loop/exit_line] ExitMetaCollector: Collected {} bindings",
bindings.len()
"[cf_loop/exit_line] ExitMetaCollector: Collected {} bindings: {:?}",
bindings.len(),
bindings
);
}

27
src/mir/builder/control_flow/joinir/merge/exit_line/reconnector.rs
View File

@ -79,6 +79,8 @@ impl ExitLineReconnector {
carrier_phis: &BTreeMap<String, ValueId>,
debug: bool,
) -> Result<(), String> {
let strict = crate::config::env::joinir_strict_enabled();
// Phase 177-STRUCT: Always log for debugging
eprintln!(
"[DEBUG-177/reconnect] ExitLineReconnector: {} exit bindings, {} carrier PHIs",
@ -140,12 +142,26 @@ impl ExitLineReconnector {
"[cf_loop/joinir/exit_line] ExitLineReconnector WARNING: Carrier '{}' not found in variable_map",
binding.carrier_name
);
} else if strict {
return Err(format!(
"[pattern2/exit_line] Missing variable_map entry for carrier '{}' (exit reconnection)",
binding.carrier_name
));
}
} else {
if strict && binding.role != CarrierRole::ConditionOnly {
return Err(format!(
"[pattern2/exit_line] Missing PHI dst for carrier '{}' ({} PHIs available)",
binding.carrier_name,
carrier_phis.len()
));
}
if debug {
eprintln!(
"[cf_loop/joinir/exit_line] ExitLineReconnector WARNING: No PHI dst for carrier '{}' (may be condition-only variable)",
binding.carrier_name
);
}
} else if debug {
eprintln!(
"[cf_loop/joinir/exit_line] ExitLineReconnector WARNING: No PHI dst for carrier '{}' (may be condition-only variable)",
binding.carrier_name
);
}
}
@ -234,7 +250,6 @@ impl ExitLineReconnector {
#[cfg(test)]
mod tests {
#[test]
fn test_empty_exit_bindings() {

240
src/mir/builder/control_flow/joinir/merge/instruction_rewriter.rs
View File

@ -7,13 +7,13 @@
//! Phase 33-17: Further modularization - extracted TailCallClassifier and MergeResult
//! Phase 179-A Step 3: Named constants for magic values
use crate::mir::{BasicBlock, BasicBlockId, MirInstruction, MirModule, ValueId};
use super::loop_header_phi_info::LoopHeaderPhiInfo;
use super::merge_result::MergeResult;
use super::tail_call_classifier::{classify_tail_call, TailCallKind};
use crate::mir::builder::joinir_id_remapper::JoinIrIdRemapper;
use crate::mir::join_ir::lowering::inline_boundary::JoinInlineBoundary;
use super::loop_header_phi_info::LoopHeaderPhiInfo;
use super::tail_call_classifier::{TailCallKind, classify_tail_call};
use super::merge_result::MergeResult;
use std::collections::BTreeMap; // Phase 222.5-E: HashMap → BTreeMap for determinism
use crate::mir::{BasicBlock, BasicBlockId, MirInstruction, MirModule, ValueId};
use std::collections::BTreeMap; // Phase 222.5-E: HashMap → BTreeMap for determinism
/// Phase 179-A: Exit continuation function name (MIR convention)
/// This is the standard name for k_exit continuations in JoinIR → MIR lowering
@ -44,20 +44,24 @@ pub(super) fn merge_and_rewrite(
builder: &mut crate::mir::builder::MirBuilder,
mir_module: &MirModule,
remapper: &mut JoinIrIdRemapper,
value_to_func_name: &BTreeMap<ValueId, String>, // Phase 222.5-E: HashMap → BTreeMap for determinism
function_params: &BTreeMap<String, Vec<ValueId>>, // Phase 222.5-E: HashMap → BTreeMap for determinism
value_to_func_name: &BTreeMap<ValueId, String>, // Phase 222.5-E: HashMap → BTreeMap for determinism
function_params: &BTreeMap<String, Vec<ValueId>>, // Phase 222.5-E: HashMap → BTreeMap for determinism
boundary: Option<&JoinInlineBoundary>,
loop_header_phi_info: &mut LoopHeaderPhiInfo,
exit_block_id: BasicBlockId,
debug: bool,
)-> Result<MergeResult, String> {
) -> Result<MergeResult, String> {
// Phase 177-3: exit_block_id is now passed in from block_allocator
eprintln!("[cf_loop/joinir/instruction_rewriter] Phase 177-3: Using exit_block_id = {:?}", exit_block_id);
eprintln!(
"[cf_loop/joinir/instruction_rewriter] Phase 177-3: Using exit_block_id = {:?}",
exit_block_id
);
// Phase 189 FIX: Build set of boundary join_inputs to skip their Const initializers
let boundary_input_set: std::collections::HashSet<ValueId> = boundary
.map(|b| b.join_inputs.iter().copied().collect())
.unwrap_or_default();
let strict_exit = crate::config::env::joinir_strict_enabled();
// Phase 189-Fix: Collect return values from JoinIR functions for exit PHI
let mut exit_phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
@ -145,7 +149,9 @@ pub(super) fn merge_and_rewrite(
// Phase 195 FIX: Reuse existing block if present (preserves PHI from JoinIR Select lowering)
// ultrathink "finalizer集約案": Don't overwrite blocks with BasicBlock::new()
let mut new_block = if let Some(ref mut current_func) = builder.current_function {
current_func.blocks.remove(&new_block_id)
current_func
.blocks
.remove(&new_block_id)
.unwrap_or_else(|| BasicBlock::new(new_block_id))
} else {
BasicBlock::new(new_block_id)
@ -183,7 +189,8 @@ pub(super) fn merge_and_rewrite(
let mut tail_call_target: Option<(BasicBlockId, Vec<ValueId>)> = None;
// Phase 177-3: Check if this block is the loop header with PHI nodes
let is_loop_header_with_phi = is_loop_entry_point && !loop_header_phi_info.carrier_phis.is_empty();
let is_loop_header_with_phi =
is_loop_entry_point && !loop_header_phi_info.carrier_phis.is_empty();
if is_loop_entry_point {
eprintln!(
@ -196,13 +203,16 @@ pub(super) fn merge_and_rewrite(
// Phase 177-3: Collect PHI dst IDs that will be created for this block
// (if this is the loop header)
let phi_dst_ids_for_block: std::collections::HashSet<ValueId> = if is_loop_header_with_phi {
loop_header_phi_info.carrier_phis.values()
.map(|entry| entry.phi_dst)
.collect()
} else {
std::collections::HashSet::new()
};
let phi_dst_ids_for_block: std::collections::HashSet<ValueId> =
if is_loop_header_with_phi {
loop_header_phi_info
.carrier_phis
.values()
.map(|entry| entry.phi_dst)
.collect()
} else {
std::collections::HashSet::new()
};
if is_loop_header_with_phi && !phi_dst_ids_for_block.is_empty() {
eprintln!(
@ -287,7 +297,8 @@ pub(super) fn merge_and_rewrite(
if let MirInstruction::Copy { dst, src: _ } = inst {
// Check if this Copy's dst (after remapping) matches any header PHI dst
let remapped_dst = remapper.get_value(*dst).unwrap_or(*dst);
let is_header_phi_dst = loop_header_phi_info.carrier_phis
let is_header_phi_dst = loop_header_phi_info
.carrier_phis
.values()
.any(|entry| entry.phi_dst == remapped_dst);
@ -442,8 +453,8 @@ pub(super) fn merge_and_rewrite(
// The current block (new_block_id) is the latch block
loop_header_phi_info.set_latch_incoming(
loop_var_name,
new_block_id, // latch block
latch_value, // updated loop var value (i_next)
new_block_id, // latch block
latch_value, // updated loop var value (i_next)
);
if debug {
@ -459,7 +470,7 @@ pub(super) fn merge_and_rewrite(
// Phase 176-4 FIX: exit_bindings may include the loop variable itself
// We need to skip it since it's already handled above via boundary.loop_var_name
// The remaining non-loop-variable carriers are ordered to match args[1..] (after the loop variable)
let mut carrier_arg_idx = 1; // Start from args[1] (args[0] is loop variable)
let mut carrier_arg_idx = 1; // Start from args[1] (args[0] is loop variable)
for binding in b.exit_bindings.iter() {
// Skip if this binding is for the loop variable (already handled)
if let Some(ref loop_var) = b.loop_var_name {
@ -470,7 +481,7 @@ pub(super) fn merge_and_rewrite(
binding.carrier_name
);
}
continue; // Skip loop variable
continue; // Skip loop variable
}
}
@ -571,64 +582,151 @@ pub(super) fn merge_and_rewrite(
// Convert Return to Jump to exit block
// All functions return to same exit block (Phase 189)
//
// Phase 33-16: Use loop header PHI dst for exit values
// Phase 246-EX: Use Jump args from block metadata for exit values
//
// Instead of referencing undefined parameters, we use the header PHI dst
// which is SSA-defined and tracks the current loop iteration value.
// The JoinIR Jump instruction passes ALL carrier values in its args,
// but the JoinIR→MIR conversion in joinir_block_converter only preserved
// the first arg in the Return value. We now use the jump_args metadata
// to recover all the original Jump args.
//
if let Some(_ret_val) = value {
// Phase 33-16: Collect exit_phi_inputs using header PHI dst
//
// If we have a loop_var_name and corresponding header PHI,
// use the PHI dst instead of the remapped parameter value.
// This is the key fix for the SSA-undef problem!
if let Some(b) = boundary {
if let Some(loop_var_name) = &b.loop_var_name {
if let Some(phi_dst) = loop_header_phi_info.get_carrier_phi(loop_var_name) {
// Use PHI dst (SSA-defined!)
exit_phi_inputs.push((new_block_id, phi_dst));
if debug {
eprintln!(
"[cf_loop/joinir] Phase 33-16: Using header PHI dst {:?} for exit (loop_var='{}')",
phi_dst, loop_var_name
// Phase 246-EX: Check if this block has jump_args metadata
if let Some(ref jump_args) = old_block.jump_args {
eprintln!(
"[DEBUG-177] Phase 246-EX: Block {:?} has jump_args metadata: {:?}",
old_block.id, jump_args
);
// The jump_args are in JoinIR value space, remap them to HOST
let remapped_args: Vec<ValueId> = jump_args
.iter()
.map(|&arg| remapper.remap_value(arg))
.collect();
eprintln!(
"[DEBUG-177] Phase 246-EX: Remapped jump_args: {:?}",
remapped_args
);
// Phase 246-EX: Collect exit values from jump_args
if let Some(b) = boundary {
if let Some(ref carrier_info) = b.carrier_info {
let expected_args = carrier_info.carriers.len() + 1; // loop_var + carriers
if remapped_args.len() < expected_args {
let msg = format!(
"[pattern2/exit_line] jump_args length mismatch: expected at least {} (loop_var + carriers) but got {} in block {:?}",
expected_args,
remapped_args.len(),
old_block.id
);
if strict_exit {
return Err(msg);
} else {
eprintln!("[DEBUG-177] {}", msg);
}
}
} else if debug {
}
// First arg is the loop variable (expr_result)
if let Some(&loop_var_exit) = remapped_args.first() {
exit_phi_inputs.push((new_block_id, loop_var_exit));
eprintln!(
"[cf_loop/joinir] Phase 33-16: No header PHI found for '{}', skipping exit_phi_inputs",
loop_var_name
"[DEBUG-177] Phase 246-EX: exit_phi_inputs from jump_args[0]: ({:?}, {:?})",
new_block_id, loop_var_exit
);
}
}
}
}
// Phase 33-16: Collect carrier exit values using header PHI dsts
//
// For each carrier, use the header PHI dst instead of
// the undefined exit binding value.
//
// Phase 227: Filter out ConditionOnly carriers from exit PHI
if let Some(b) = boundary {
for binding in &b.exit_bindings {
// Phase 227: Skip ConditionOnly carriers (they don't need exit PHI)
if binding.role == crate::mir::join_ir::lowering::carrier_info::CarrierRole::ConditionOnly {
eprintln!(
"[DEBUG-177] Phase 227: Skipping ConditionOnly carrier '{}' from exit PHI",
binding.carrier_name
);
continue;
}
// Phase 246-EX-FIX: jump_args are in carrier_info.carriers order, not exit_bindings order!
//
// jump_args layout: [loop_var, carrier1, carrier2, ...]
// where carriers follow carrier_info.carriers order (NOT exit_bindings order)
//
// We need to:
// 1. Iterate through carrier_info.carriers (to get the right index)
// 2. Skip ConditionOnly carriers (they don't participate in exit PHI)
// 3. Map the jump_args index to the carrier name
if let Some(ref carrier_info) = b.carrier_info {
for (carrier_idx, carrier) in
carrier_info.carriers.iter().enumerate()
{
// Phase 227: Skip ConditionOnly carriers
if carrier.role == crate::mir::join_ir::lowering::carrier_info::CarrierRole::ConditionOnly {
eprintln!(
"[DEBUG-177] Phase 227: Skipping ConditionOnly carrier '{}' from exit PHI",
carrier.name
);
continue;
}
if let Some(phi_dst) = loop_header_phi_info.get_carrier_phi(&binding.carrier_name) {
carrier_inputs.entry(binding.carrier_name.clone())
.or_insert_with(Vec::new)
.push((new_block_id, phi_dst));
// DEBUG-177: Always log carrier collection
eprintln!(
"[DEBUG-177] Phase 33-16: Collecting carrier '{}': from {:?} using header PHI {:?}",
binding.carrier_name, new_block_id, phi_dst
);
// jump_args[0] = loop_var, jump_args[1..] = carriers
let jump_args_idx = carrier_idx + 1;
if let Some(&carrier_exit) =
remapped_args.get(jump_args_idx)
{
carrier_inputs
.entry(carrier.name.clone())
.or_insert_with(Vec::new)
.push((new_block_id, carrier_exit));
eprintln!(
"[DEBUG-177] Phase 246-EX-FIX: Collecting carrier '{}': from {:?} using jump_args[{}] = {:?}",
carrier.name, new_block_id, jump_args_idx, carrier_exit
);
} else {
let msg = format!(
"[pattern2/exit_line] Missing jump_args entry for carrier '{}' at index {} in block {:?}",
carrier.name, jump_args_idx, old_block.id
);
if strict_exit {
return Err(msg);
} else {
eprintln!(
"[DEBUG-177] Phase 246-EX WARNING: No jump_args entry for carrier '{}' at index {}",
carrier.name, jump_args_idx
);
}
}
}
} else {
eprintln!("[DEBUG-177] Phase 246-EX WARNING: No carrier_info in boundary!");
}
}
} else {
// Fallback: Use header PHI dst (old behavior for blocks without jump_args)
eprintln!(
"[DEBUG-177] Phase 246-EX: Block {:?} has NO jump_args, using header PHI fallback",
old_block.id
);
if let Some(b) = boundary {
if let Some(loop_var_name) = &b.loop_var_name {
if let Some(phi_dst) =
loop_header_phi_info.get_carrier_phi(loop_var_name)
{
exit_phi_inputs.push((new_block_id, phi_dst));
if debug {
eprintln!(
"[cf_loop/joinir] Phase 246-EX fallback: Using header PHI dst {:?} for exit (loop_var='{}')",
phi_dst, loop_var_name
);
}
}
}
// Phase 227: Filter out ConditionOnly carriers from exit PHI
for binding in &b.exit_bindings {
if binding.role == crate::mir::join_ir::lowering::carrier_info::CarrierRole::ConditionOnly {
continue;
}
if let Some(phi_dst) = loop_header_phi_info
.get_carrier_phi(&binding.carrier_name)
{
carrier_inputs
.entry(binding.carrier_name.clone())
.or_insert_with(Vec::new)
.push((new_block_id, phi_dst));
}
}
}
}
}

16
src/mir/builder/control_flow/joinir/merge/loop_header_phi_builder.rs
View File

@ -57,6 +57,7 @@ impl LoopHeaderPhiBuilder {
/// Added CarrierInit and CarrierRole to carrier tuples:
/// * `CarrierInit::FromHost` - Use host_id directly as PHI init value
/// * `CarrierInit::BoolConst(val)` - Generate explicit bool constant for ConditionOnly carriers
/// * `CarrierInit::LoopLocalZero` - Generate const 0 for loop-local derived carriers (no host slot)
pub fn build(
builder: &mut crate::mir::builder::MirBuilder,
header_block: BasicBlockId,
@ -121,6 +122,21 @@ impl LoopHeaderPhiBuilder {
}
const_id
}
crate::mir::join_ir::lowering::carrier_info::CarrierInit::LoopLocalZero => {
// Loop-local derived carrier (e.g., digit_value) starts from 0 inside the loop
let const_id = builder.next_value_id();
let _ = builder.emit_instruction(MirInstruction::Const {
dst: const_id,
value: crate::mir::types::ConstValue::Integer(0),
});
if debug {
eprintln!(
"[cf_loop/joinir] Phase 247-EX: Generated const {:?} = Int(0) for loop-local carrier '{}'",
const_id, name
);
}
const_id
}
};
let phi_dst = builder.next_value_id();

157
src/mir/builder/control_flow/joinir/merge/mod.rs
View File

@ -75,6 +75,8 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
boundary: Option<&JoinInlineBoundary>,
debug: bool,
) -> Result<Option<ValueId>, String> {
let verbose = debug || crate::config::env::joinir_dev_enabled();
if debug {
eprintln!(
"[cf_loop/joinir] merge_joinir_mir_blocks called with {} functions",
@ -82,6 +84,54 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
);
}
if verbose {
if let Some(boundary) = boundary {
let exit_summary: Vec<String> = boundary
.exit_bindings
.iter()
.map(|b| {
format!(
"{}: join {:?} → host {:?} ({:?})",
b.carrier_name, b.join_exit_value, b.host_slot, b.role
)
})
.collect();
let cond_summary: Vec<String> = boundary
.condition_bindings
.iter()
.map(|b| format!("{}: host {:?} → join {:?}", b.name, b.host_value, b.join_value))
.collect();
eprintln!(
"[cf_loop/joinir] Boundary join_inputs={:?} host_inputs={:?}",
boundary.join_inputs, boundary.host_inputs
);
eprintln!(
"[cf_loop/joinir] Boundary exit_bindings ({}): {}",
boundary.exit_bindings.len(),
exit_summary.join(", ")
);
if !cond_summary.is_empty() {
eprintln!(
"[cf_loop/joinir] Boundary condition_bindings ({}): {}",
cond_summary.len(),
cond_summary.join(", ")
);
}
if let Some(ci) = &boundary.carrier_info {
let carriers: Vec<String> = ci.carriers.iter().map(|c| c.name.clone()).collect();
eprintln!(
"[cf_loop/joinir] Boundary carrier_info: loop_var='{}', carriers={:?}",
ci.loop_var_name,
carriers
);
}
} else {
eprintln!("[cf_loop/joinir] No boundary provided");
}
}
// Phase 1: Allocate block IDs for all functions
// Phase 177-3: block_allocator now returns exit_block_id to avoid conflicts
let (mut remapper, exit_block_id) = block_allocator::allocate_blocks(builder, mir_module, debug)?;
@ -529,7 +579,8 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
// Phase 5: Build exit PHI (expr result only, not carrier PHIs)
// Phase 33-20: Carrier PHIs are now taken from header PHI info, not exit block
let (exit_phi_result_id, _exit_carrier_phis) = exit_phi_builder::build_exit_phi(
// Phase 246-EX: REVERT Phase 33-20 - Use EXIT PHI dsts, not header PHI dsts!
let (exit_phi_result_id, exit_carrier_phis) = exit_phi_builder::build_exit_phi(
builder,
merge_result.exit_block_id,
&merge_result.exit_phi_inputs,
@ -537,18 +588,32 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
debug,
)?;
// Phase 33-20: Build carrier_phis from header PHI info instead of exit PHI builder
// The header PHI dst IS the current value of each carrier, and it's SSA-valid
// because it's defined at the loop header and dominates the exit block.
let carrier_phis: std::collections::BTreeMap<String, ValueId> = loop_header_phi_info
.carrier_phis
.iter()
.map(|(name, entry)| (name.clone(), entry.phi_dst))
.collect();
// Phase 246-EX: CRITICAL FIX - Use exit PHI dsts for variable_map reconnection
//
// **Why EXIT PHI, not HEADER PHI?**
//
// Header PHI represents the value at the BEGINNING of each iteration.
// Exit PHI represents the FINAL value when leaving the loop (from any exit path).
//
// For Pattern 2 loops with multiple exit paths (natural exit + break):
// - Header PHI: `%15 = phi [%3, bb7], [%42, bb14]` (loop variable at iteration start)
// - Exit PHI: `%5 = phi [%15, bb11], [%15, bb13]` (final value from exit paths)
//
// When we exit the loop, we want the FINAL value (%5), not the iteration-start value (%15).
// Phase 33-20 incorrectly used header PHI, causing loops to return initial values (e.g., 0 instead of 42).
//
// Example (_atoi):
// - Initial: result=0 (header PHI)
// - After iteration 1: result=4 (updated in loop body)
// - After iteration 2: result=42 (updated in loop body)
// - Exit: Should return 42 (exit PHI), not 0 (header PHI initial value)
//
// The exit PHI correctly merges values from both exit paths, giving us the final result.
let carrier_phis = &exit_carrier_phis;
if debug && !carrier_phis.is_empty() {
eprintln!(
"[cf_loop/joinir] Phase 33-20: Using header PHI dsts for variable_map: {:?}",
"[cf_loop/joinir] Phase 246-EX: Using EXIT PHI dsts for variable_map (not header): {:?}",
carrier_phis.iter().map(|(n, v)| (n.as_str(), v)).collect::<Vec<_>>()
);
}
@ -556,9 +621,9 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
// Phase 6: Reconnect boundary (if specified)
// Phase 197-B: Pass remapper to enable per-carrier exit value lookup
// Phase 33-10-Refactor-P3: Delegate to ExitLineOrchestrator
// Phase 33-20: Now uses header PHI dsts instead of exit PHI dsts
// Phase 246-EX: Now uses EXIT PHI dsts (reverted Phase 33-20)
if let Some(boundary) = boundary {
exit_line::ExitLineOrchestrator::execute(builder, boundary, &carrier_phis, debug)?;
exit_line::ExitLineOrchestrator::execute(builder, boundary, carrier_phis, debug)?;
}
let exit_block_id = merge_result.exit_block_id;
@ -624,19 +689,69 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
builder.reserved_value_ids.clear();
}
// Phase 221-R: Use ExprResultResolver Box
let expr_result_value = expr_result_resolver::ExprResultResolver::resolve(
boundary.and_then(|b| b.expr_result),
boundary.map(|b| b.exit_bindings.as_slice()).unwrap_or(&[]),
&carrier_phis,
&remapper,
debug,
)?;
// Phase 246-EX-FIX: Handle loop variable expr_result separately from carrier expr_result
//
// The loop variable (e.g., 'i') is returned via exit_phi_result_id, not carrier_phis.
// Other carriers use carrier_phis. We need to check which case we're in.
let expr_result_value = if let Some(b) = boundary {
if let Some(expr_result_id) = b.expr_result {
// Check if expr_result is the loop variable
if let Some(loop_var_name) = &b.loop_var_name {
// Find the exit binding for the loop variable
let loop_var_binding = b.exit_bindings.iter()
.find(|binding| binding.carrier_name == *loop_var_name);
if let Some(binding) = loop_var_binding {
if binding.join_exit_value == expr_result_id {
// expr_result is the loop variable! Use exit_phi_result_id
if debug {
eprintln!(
"[cf_loop/joinir] Phase 246-EX-FIX: expr_result {:?} is loop variable '{}', using exit_phi_result_id {:?}",
expr_result_id, loop_var_name, exit_phi_result_id
);
}
exit_phi_result_id
} else {
// expr_result is not the loop variable, resolve as carrier
expr_result_resolver::ExprResultResolver::resolve(
Some(expr_result_id),
b.exit_bindings.as_slice(),
&carrier_phis,
&remapper,
debug,
)?
}
} else {
// No loop variable binding, resolve normally
expr_result_resolver::ExprResultResolver::resolve(
Some(expr_result_id),
b.exit_bindings.as_slice(),
&carrier_phis,
&remapper,
debug,
)?
}
} else {
// No loop variable name, resolve normally
expr_result_resolver::ExprResultResolver::resolve(
Some(expr_result_id),
b.exit_bindings.as_slice(),
&carrier_phis,
&remapper,
debug,
)?
}
} else {
None
}
} else {
None
};
// Return expr_result if present, otherwise fall back to exit_phi_result_id
if let Some(resolved) = expr_result_value {
if debug {
eprintln!("[cf_loop/joinir] Phase 221-R: Returning expr_result_value {:?}", resolved);
eprintln!("[cf_loop/joinir] Phase 246-EX-FIX: Returning expr_result_value {:?}", resolved);
}
Ok(Some(resolved))
} else {

26
src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs
View File

@ -5,6 +5,7 @@ use crate::mir::builder::MirBuilder;
use crate::mir::ValueId;
use super::super::trace;
use crate::mir::loop_pattern_detection::error_messages;
use crate::mir::join_ir::lowering::carrier_info::CarrierInit;
/// Phase 185-2: Collect body-local variable declarations from loop body
///
@ -511,6 +512,7 @@ impl MirBuilder {
carrier_updates.contains_key(&carrier.name)
|| carrier.role == CarrierRole::ConditionOnly
|| carrier.init == CarrierInit::FromHost // Phase 247-EX
|| carrier.init == CarrierInit::LoopLocalZero // Phase 247-EX: Derived carrier (digit_value)
});
eprintln!(
@ -524,18 +526,28 @@ impl MirBuilder {
// need to be added to ConditionEnv with their initial values.
for carrier in &carrier_info.carriers {
if env.get(&carrier.name).is_none() {
// Allocate a new JoinIR ValueId for this carrier
let join_value = alloc_join_value();
// Use the carrier's assigned param ID when available to keep IDs aligned
let join_value = carrier
.join_id
.unwrap_or_else(|| alloc_join_value());
// Add to ConditionEnv
env.insert(carrier.name.clone(), join_value);
// Add to condition_bindings for later processing
condition_bindings.push(ConditionBinding {
name: carrier.name.clone(),
host_value: carrier.host_id,
join_value,
});
// Loop-local carriers (e.g., digit_value) have no host slot; skip binding to avoid bogus copies.
if carrier.init != CarrierInit::LoopLocalZero {
condition_bindings.push(ConditionBinding {
name: carrier.name.clone(),
host_value: carrier.host_id,
join_value,
});
} else {
eprintln!(
"[cf_loop/pattern2] Phase 247-EX: Skipping host binding for loop-local carrier '{}' (init=LoopLocalZero)",
carrier.name
);
}
eprintln!(
"[cf_loop/pattern2] Phase 176-5: Added body-only carrier '{}' to ConditionEnv: HOST {:?} → JoinIR {:?}",