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

refactor(joinir): Pattern 4 modularization with CarrierInfo/ExitMeta

Browse Source 
Removes hardcoded "sum" and ValueId(15) from Pattern 4 lowerer by
introducing CarrierInfo and ExitMeta structures.

Changes:
- New carrier_info.rs: CarrierInfo, CarrierVar, ExitMeta structs
- loop_with_continue_minimal.rs: Returns (JoinModule, ExitMeta)
- pattern4_with_continue.rs: Dynamic binding generation from metadata

Design approach: "Thin meta on existing boxes" (ChatGPT proposal)
- CarrierInfo: Built from variable_map, not AST re-analysis
- ExitMeta: Carrier name + JoinIR ValueId pairs from lowerer
- LoopExitBinding: Auto-generated from CarrierInfo + ExitMeta

Test: loop_continue_pattern4.hako outputs 25 (unchanged)

🤖 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-06 02:05:19 +09:00
parent 318dceebfe
commit 60bd5487e6
4 changed files with 146 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/mir/builder/control_flow/joinir/patterns/pattern4_with_continue.rs
View File

@ -100,6 +100,7 @@ impl MirBuilder {
_func_name: &str,
debug: bool,
) -> Result<Option<ValueId>, String> {
use crate::mir::join_ir::lowering::carrier_info::{CarrierInfo, CarrierVar};
use crate::mir::join_ir::lowering::loop_with_continue_minimal::lower_loop_with_continue_minimal;
use crate::mir::join_ir_vm_bridge::convert_join_module_to_mir_with_meta;
use crate::mir::BasicBlockId;
@ -121,14 +122,28 @@ impl MirBuilder {
)
})?;
// Get sum variable from variable_map
let sum_var_id = self
.variable_map
.get("sum")
.copied()
.ok_or_else(|| {
format!("[cf_loop/pattern4] Sum variable 'sum' not found in variable_map")
})?;
// Phase 196: Build CarrierInfo from variable_map
// Collect all non-loop-var variables as potential carriers
let mut carriers = Vec::new();
for (var_name, &var_id) in &self.variable_map {
if var_name != &loop_var_name {
carriers.push(CarrierVar {
name: var_name.clone(),
host_id: var_id,
});
}
}
let carrier_info = CarrierInfo {
loop_var_name: loop_var_name.clone(),
loop_var_id,
carriers: carriers.clone(),
};
eprintln!("[pattern4] CarrierInfo: loop_var={}, carriers={:?}",
carrier_info.loop_var_name,
carrier_info.carriers.iter().map(|c| &c.name).collect::<Vec<_>>()
);
// Phase 195: Use unified trace
trace::trace().varmap("pattern4_start", &self.variable_map);
@ -150,8 +165,8 @@ impl MirBuilder {
};
// Call Pattern 4 lowerer
let join_module = match lower_loop_with_continue_minimal(scope) {
Some(module) => module,
let (join_module, exit_meta) = match lower_loop_with_continue_minimal(scope) {
Some(result) => result,
None => {
// Phase 195: Use unified trace
trace::trace().debug("pattern4", "Pattern 4 lowerer returned None");
@ -159,6 +174,11 @@ impl MirBuilder {
}
};
eprintln!("[pattern4] ExitMeta: {} exit bindings", exit_meta.exit_values.len());
for (carrier_name, join_value) in &exit_meta.exit_values {
eprintln!("[pattern4] {} → ValueId({})", carrier_name, join_value.0);
}
// Phase 195: Use unified trace
trace::trace().joinir_stats(
"pattern4",
@ -181,19 +201,49 @@ impl MirBuilder {
mir_module.functions.values().map(|f| f.blocks.len()).sum(),
);
// Phase 196: Dynamically generate exit_bindings from ExitMeta and CarrierInfo
let mut exit_bindings = Vec::new();
for (carrier_name, join_exit_value) in &exit_meta.exit_values {
// Find the host_slot for this carrier
let host_slot = carrier_info
.carriers
.iter()
.find(|c| &c.name == carrier_name)
.map(|c| c.host_id)
.ok_or_else(|| {
format!(
"[cf_loop/pattern4] Carrier '{}' not found in CarrierInfo",
carrier_name
)
})?;
exit_bindings.push(
crate::mir::join_ir::lowering::inline_boundary::LoopExitBinding {
carrier_name: carrier_name.clone(),
join_exit_value: *join_exit_value,
host_slot,
},
);
eprintln!("[pattern4] Generated binding: {} → JoinIR={} Host={}",
carrier_name, join_exit_value.0, host_slot.0);
}
// Phase 196: Build host_inputs dynamically
// Order: [loop_var, carrier1, carrier2, ...]
let mut host_inputs = vec![carrier_info.loop_var_id];
for carrier in &carrier_info.carriers {
host_inputs.push(carrier.host_id);
}
eprintln!("[pattern4] host_inputs: {:?}", host_inputs.iter().map(|v| v.0).collect::<Vec<_>>());
// Merge JoinIR blocks into current function
// Phase 195 FIX: Use exit_bindings to connect k_exit's sum_exit to host's sum variable
// Pattern 4: k_exit(sum_exit) returns sum_exit, so we bind ValueId(15) to host's sum
// Phase 196: Use dynamically generated exit_bindings and host_inputs
let boundary = crate::mir::join_ir::lowering::inline_boundary::JoinInlineBoundary::new_with_exit_bindings(
vec![ValueId(0), ValueId(1)], // JoinIR's main() parameters (i_init, sum_init)
vec![loop_var_id, sum_var_id], // Host's loop variables
vec![
crate::mir::join_ir::lowering::inline_boundary::LoopExitBinding {
carrier_name: "sum".to_string(),
join_exit_value: ValueId(15), // k_exit's parameter (sum_exit)
host_slot: sum_var_id, // variable_map["sum"]
}
],
host_inputs, // Host's loop variables (dynamic)
exit_bindings,
);
// Phase 195: Capture exit PHI result (Pattern 4 returns sum)
let result_val = self.merge_joinir_mir_blocks(&mir_module, Some(&boundary), debug)?;