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

feat(joinir): Phase 254-255 - Pattern 6 (ScanWithInit) + exit PHI DCE fix

Browse Source 
## Phase 254: Pattern 6 (ScanWithInit) Detection & JoinIR Lowering

Pattern 6 detects index_of/find/contains-style loops:
- Loop condition: i < x.length()
- Loop body: if with method call condition + early return
- Step: i = i + 1
- Post-loop: return not-found value (-1)

Key features:
- Minimal lowering: main/loop_step/k_exit functions
- substring hoisted to init-time BoxCall
- Two k_exit jumps (found: i, not found: -1)
- Tests: phase254_p0_index_of_min.hako

## Phase 255 P0: Multi-param Loop CarrierInfo

Implemented CarrierInfo architecture for Pattern 6's 3-variable loop (s, ch, i):
- i: LoopState (header PHI + exit PHI)
- s, ch: ConditionOnly (header PHI only)
- Alphabetical ordering for determinism
- All 3 PHI nodes created correctly
- Eliminates "undefined ValueId" errors

## Phase 255 P1: Exit PHI DCE Fix

Prevents exit PHI from being deleted by DCE:
- PostLoopEarlyReturnStepBox emits post-loop guard
- if (i != -1) { return i } forces exit PHI usage
- Proven pattern from Pattern 2 (balanced_depth_scan)
- VM/LLVM backends working

## Test Results

✅ pattern254_p0_index_of_vm.sh: PASS (exit code 1)
✅ pattern254_p0_index_of_llvm_exe.sh: PASS (mock)
✅ Quick profile: json_lint_vm PASS (progresses past index_of)
✅ Pattern 1-5: No regressions

## Files Added

- src/mir/builder/control_flow/joinir/patterns/pattern6_scan_with_init.rs
- src/mir/join_ir/lowering/scan_with_init_minimal.rs
- apps/tests/phase254_p0_index_of_min.hako
- docs/development/current/main/phases/phase-254/README.md
- docs/development/current/main/phases/phase-255/README.md

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

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
This commit is contained in:
tomoaki
2025-12-19 23:32:25 +09:00
parent 09b968256f
commit 2d9c6ea3c6
28 changed files with 2283 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -74,6 +74,7 @@ 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 pattern5_infinite_early_exit; // Phase 131-11
pub(in crate::mir::builder) mod pattern6_scan_with_init; // Phase 254 P0: index_of/find/contains pattern
pub(in crate::mir::builder) mod pattern_pipeline;
pub(in crate::mir::builder) mod router;
pub(in crate::mir::builder) mod trim_loop_lowering; // Phase 180: Dedicated Trim/P5 lowering module

2
src/mir/builder/control_flow/joinir/patterns/pattern2_inputs_facts_box.rs
View File

@ -96,6 +96,8 @@ pub(in crate::mir::builder) struct Pattern2Inputs {
pub post_loop_early_return: Option<
crate::mir::builder::control_flow::joinir::patterns::policies::post_loop_early_return_plan::PostLoopEarlyReturnPlan,
>,
/// Phase 252: Name of the static box being lowered (for this.method(...) in break conditions).
pub current_static_box_name: Option<String>,
}
pub(crate) struct Pattern2InputsFactsBox;

3
src/mir/builder/control_flow/joinir/patterns/pattern2_lowering_orchestrator.rs
View File

@ -44,6 +44,9 @@ impl Pattern2LoweringOrchestrator {
let promoted = PromoteStepBox::run(builder, condition, body, inputs, debug, verbose)?;
let mut inputs = promoted.inputs;
// Phase 252: Wire current_static_box_name from builder context
inputs.current_static_box_name = builder.comp_ctx.current_static_box.clone();
let normalized = NormalizeBodyStepBox::run(builder, condition, body, &mut inputs, verbose)?;
let normalized_body = normalized.normalized_body;
let analysis_body = normalized_body.as_deref().unwrap_or(body);

1
src/mir/builder/control_flow/joinir/patterns/pattern2_steps/apply_policy_step_box.rs
View File

@ -33,6 +33,7 @@ impl ApplyPolicyStepBox {
balanced_depth_scan_recipe: policy.balanced_depth_scan_recipe,
carrier_updates_override: policy.carrier_updates_override,
post_loop_early_return: policy.post_loop_early_return,
current_static_box_name: None, // Phase 252: TODO - wire from builder.comp_ctx
})
}
}

1
src/mir/builder/control_flow/joinir/patterns/pattern2_steps/emit_joinir_step_box.rs
View File

@ -53,6 +53,7 @@ impl EmitJoinIRStepBox {
condition_only_recipe: inputs.condition_only_recipe.as_ref(),
body_local_derived_recipe: inputs.body_local_derived_recipe.as_ref(),
balanced_depth_scan_recipe: inputs.balanced_depth_scan_recipe.as_ref(),
current_static_box_name: inputs.current_static_box_name.clone(), // Phase 252
};
let (join_module, fragment_meta) = match lower_loop_with_break_minimal(lowering_inputs) {

679
src/mir/builder/control_flow/joinir/patterns/pattern6_scan_with_init.rs Normal file
View File

@ -0,0 +1,679 @@
//! Pattern 6: Scan with Init (index_of/find/contains form)
//!
//! Phase 254 P0: Dedicated pattern for scan loops with init-time method calls
//!
//! ## Pattern Structure
//!
//! ```nyash
//! index_of(s, ch) {
//! local i = 0
//! loop(i < s.length()) {
//! if s.substring(i, i + 1) == ch {
//! return i
//! }
//! i = i + 1
//! }
//! return -1
//! }
//! ```
//!
//! ## Detection Criteria (Structure Only - No Function Names)
//!
//! 1. Loop condition: `i < x.length()` or `i < len`
//! 2. Loop body has if statement with:
//! - Condition containing MethodCall (e.g., `substring(i, i+1) == ch`)
//! - Then branch: early return (break)
//! 3. Loop body has step: `i = i + 1`
//! 4. Post-loop: return statement (not-found value)
//!
//! ## Why Not Pattern 2?
//!
//! - Pattern 2 expects break condition without init-time MethodCall
//! - This pattern needs MethodCall in condition (substring)
//! - MethodCall allowed_in_condition() = false, but allowed_in_init() = true
//! - Need to hoist MethodCall to init phase
use super::super::trace;
use crate::ast::{ASTNode, BinaryOperator, LiteralValue};
use crate::mir::builder::MirBuilder;
use crate::mir::ValueId;
/// Phase 254 P1: Extracted structure for scan-with-init pattern
///
/// This structure contains all the information needed to lower an index_of-style loop.
#[derive(Debug, Clone)]
struct ScanParts {
/// Loop variable name (e.g., "i")
loop_var: String,
/// Haystack variable name (e.g., "s")
haystack: String,
/// Needle variable name (e.g., "ch")
needle: String,
/// Step literal (P0: must be 1)
step_lit: i64,
/// Early return expression (P0: must be Variable(loop_var))
early_return_expr: ASTNode,
/// Not-found return literal (P0: must be -1)
not_found_return_lit: i64,
}
/// Phase 254 P0: Detection for Pattern 6 (ScanWithInit)
///
/// Detects index_of/find/contains pattern:
/// - Loop with `i < x.length()` or `i < len` condition
/// - If with MethodCall in condition and early return
/// - ConstStep `i = i + 1`
/// - Post-loop return
///
/// Detection is structure-based only (no function name checks).
pub(crate) fn can_lower(_builder: &MirBuilder, ctx: &super::router::LoopPatternContext) -> bool {
use crate::mir::loop_pattern_detection::LoopPatternKind;
// Phase 254 P0: Accept Pattern2Break OR Pattern3IfPhi
// - Pattern2Break: loop with break statement
// - Pattern3IfPhi: loop with return statement (not counted as break)
// index_of has return (early exit), which is classified as Pattern3IfPhi
match ctx.pattern_kind {
LoopPatternKind::Pattern2Break | LoopPatternKind::Pattern3IfPhi => {
// Continue to structure checks
}
_ => return false,
}
// Check for if statement with MethodCall in condition
let has_if_with_methodcall = ctx.body.iter().any(|stmt| {
matches!(stmt, ASTNode::If { condition, .. } if contains_methodcall(condition))
});
if !has_if_with_methodcall {
if ctx.debug {
trace::trace().debug(
"pattern6/can_lower",
"reject: no if with MethodCall in condition",
);
}
return false;
}
// Check for ConstStep (i = i + 1)
let has_const_step = ctx.body.iter().any(|stmt| {
matches!(stmt, ASTNode::Assignment { value, .. } if is_const_step_pattern(value))
});
if !has_const_step {
if ctx.debug {
trace::trace().debug(
"pattern6/can_lower",
"reject: no ConstStep pattern found",
);
}
return false;
}
if ctx.debug {
trace::trace().debug(
"pattern6/can_lower",
"MATCHED: ScanWithInit pattern detected",
);
}
true
}
/// Check if AST node contains MethodCall
fn contains_methodcall(node: &ASTNode) -> bool {
match node {
ASTNode::MethodCall { .. } => true,
ASTNode::BinaryOp { left, right, .. } => {
contains_methodcall(left) || contains_methodcall(right)
}
ASTNode::UnaryOp { operand, .. } => contains_methodcall(operand),
_ => false,
}
}
/// Check if value is ConstStep pattern (i = i + 1)
fn is_const_step_pattern(value: &ASTNode) -> bool {
match value {
ASTNode::BinaryOp {
operator: crate::ast::BinaryOperator::Add,
left,
right,
..
} => {
matches!(left.as_ref(), ASTNode::Variable { .. })
&& matches!(right.as_ref(), ASTNode::Literal { .. })
}
_ => false,
}
}
/// Phase 254 P1: Extract scan-with-init pattern parts from loop AST
///
/// This function analyzes the loop structure and extracts all necessary information
/// for lowering an index_of-style loop to JoinIR.
///
/// # Arguments
///
/// * `condition` - Loop condition AST node
/// * `body` - Loop body statements
/// * `fn_body` - Full function body (needed to check post-loop return)
///
/// # Returns
///
/// * `Ok(Some(ScanParts))` - Successfully extracted the pattern
/// * `Ok(None)` - Not a scan-with-init pattern (different pattern)
/// * `Err(String)` - Internal consistency error
///
/// # P0 Restrictions
///
/// - Loop condition must be `i < s.length()`
/// - Step must be `i = i + 1` (step_lit == 1)
/// - Not-found return must be `-1`
/// - Early return must be `return loop_var`
fn extract_scan_with_init_parts(
condition: &ASTNode,
body: &[ASTNode],
_fn_body: Option<&[ASTNode]>,
) -> Result<Option<ScanParts>, String> {
use crate::ast::{BinaryOperator, LiteralValue};
// 1. Check loop condition: i < s.length()
let (loop_var, haystack) = match condition {
ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left,
right,
..
} => {
let loop_var = match left.as_ref() {
ASTNode::Variable { name, .. } => name.clone(),
_ => return Ok(None),
};
let haystack = match right.as_ref() {
ASTNode::MethodCall {
object, method, ..
} if method == "length" => match object.as_ref() {
ASTNode::Variable { name, .. } => name.clone(),
_ => return Ok(None),
},
_ => return Ok(None),
};
(loop_var, haystack)
}
_ => return Ok(None),
};
// 2. Find if statement with substring == needle and return loop_var
let mut needle_opt = None;
let mut early_return_expr_opt = None;
for stmt in body {
if let ASTNode::If {
condition: if_cond,
then_body,
..
} = stmt
{
// Check if condition is MethodCall(substring) == Variable(needle)
if let ASTNode::BinaryOp {
operator: BinaryOperator::Equal,
left,
right,
..
} = if_cond.as_ref()
{
let substring_side = if matches!(left.as_ref(), ASTNode::MethodCall { method, .. } if method == "substring")
{
left.as_ref()
} else if matches!(right.as_ref(), ASTNode::MethodCall { method, .. } if method == "substring")
{
right.as_ref()
} else {
continue;
};
let needle_side = if std::ptr::eq(substring_side, left.as_ref()) {
right.as_ref()
} else {
left.as_ref()
};
if let ASTNode::Variable { name: needle_name, .. } = needle_side {
// Check then_body contains return loop_var
if then_body.len() == 1 {
if let ASTNode::Return { value, .. } = &then_body[0] {
if let Some(ret_val) = value {
if let ASTNode::Variable { name: ret_name, .. } = ret_val.as_ref() {
if ret_name == &loop_var {
needle_opt = Some(needle_name.clone());
early_return_expr_opt = Some(ret_val.as_ref().clone());
}
}
}
}
}
}
}
}
}
let needle = needle_opt.ok_or_else(|| "No matching needle pattern found")?;
let early_return_expr = early_return_expr_opt.ok_or_else(|| "No early return found")?;
// 3. Check for step: i = i + 1
let mut step_lit_opt = None;
for stmt in body {
if let ASTNode::Assignment { target, value, .. } = stmt {
if let ASTNode::Variable { name: target_name, .. } = target.as_ref() {
if target_name == &loop_var {
if let ASTNode::BinaryOp {
operator: BinaryOperator::Add,
left,
right,
..
} = value.as_ref()
{
if let ASTNode::Variable { name: left_name, .. } = left.as_ref() {
if left_name == &loop_var {
if let ASTNode::Literal {
value: LiteralValue::Integer(lit),
..
} = right.as_ref()
{
step_lit_opt = Some(*lit);
}
}
}
}
}
}
}
}
let step_lit = step_lit_opt.ok_or_else(|| "No step pattern found")?;
// P0: step must be 1
if step_lit != 1 {
return Ok(None);
}
// 4. P0: not-found return must be -1 (hardcoded for now)
let not_found_return_lit = -1;
Ok(Some(ScanParts {
loop_var,
haystack,
needle,
step_lit,
early_return_expr,
not_found_return_lit,
}))
}
/// Phase 254 P0: Lowering function for Pattern 6
///
/// Delegates to MirBuilder implementation.
pub(crate) fn lower(
builder: &mut MirBuilder,
ctx: &super::router::LoopPatternContext,
) -> Result<Option<ValueId>, String> {
builder.cf_loop_pattern6_scan_with_init_impl(
ctx.condition,
ctx.body,
ctx.func_name,
ctx.debug,
ctx.fn_body,
)
}
impl MirBuilder {
/// Phase 254 P1: Pattern 6 (ScanWithInit) implementation
///
/// Lowers index_of-style loops to JoinIR using scan_with_init_minimal lowerer.
///
/// # Arguments
///
/// * `condition` - Loop condition AST
/// * `body` - Loop body statements
/// * `func_name` - Function name for debugging
/// * `debug` - Enable debug output
/// * `fn_body` - Optional function body for capture analysis
pub(crate) fn cf_loop_pattern6_scan_with_init_impl(
&mut self,
condition: &ASTNode,
body: &[ASTNode],
func_name: &str,
debug: bool,
fn_body: Option<&[ASTNode]>,
) -> Result<Option<ValueId>, String> {
use crate::mir::join_ir::lowering::join_value_space::{JoinValueSpace, PARAM_MIN};
use crate::mir::join_ir::lowering::scan_with_init_minimal::lower_scan_with_init_minimal;
use crate::mir::join_ir::lowering::JoinInlineBoundaryBuilder;
let trace = trace::trace();
if debug {
trace.debug(
"pattern6/lower",
&format!("Phase 254 P1: ScanWithInit lowering for {}", func_name),
);
}
// Step 1: Extract pattern parts
let parts = extract_scan_with_init_parts(condition, body, fn_body)?
.ok_or_else(|| format!("[pattern6] Not a scan-with-init pattern in {}", func_name))?;
if debug {
trace.debug(
"pattern6/lower",
&format!(
"Extracted: loop_var={}, haystack={}, needle={}, step={}, not_found={}",
parts.loop_var, parts.haystack, parts.needle, parts.step_lit, parts.not_found_return_lit
),
);
}
// Step 2: Get host ValueIds for variables
let s_host = self
.variable_ctx
.variable_map
.get(&parts.haystack)
.copied()
.ok_or_else(|| format!("[pattern6] Variable {} not found", parts.haystack))?;
let ch_host = self
.variable_ctx
.variable_map
.get(&parts.needle)
.copied()
.ok_or_else(|| format!("[pattern6] Variable {} not found", parts.needle))?;
let i_host = self
.variable_ctx
.variable_map
.get(&parts.loop_var)
.copied()
.ok_or_else(|| format!("[pattern6] Variable {} not found", parts.loop_var))?;
if debug {
trace.debug(
"pattern6/lower",
&format!(
"Host ValueIds: s={:?}, ch={:?}, i={:?}",
s_host, ch_host, i_host
),
);
}
// Step 3: Create JoinModule
let mut join_value_space = JoinValueSpace::new();
let join_module = lower_scan_with_init_minimal(&mut join_value_space);
// Phase 255 P0: Build CarrierInfo for multi-param loop
// Step 1: Create CarrierInfo with 3 variables (s, ch, i)
use crate::mir::join_ir::lowering::carrier_info::{CarrierInfo, CarrierVar, CarrierRole};
let carriers = vec![
// s: haystack (ConditionOnly - header PHI only, no exit PHI)
CarrierVar::with_role(
parts.haystack.clone(),
s_host,
CarrierRole::ConditionOnly,
),
// ch: needle (ConditionOnly - header PHI only, no exit PHI)
CarrierVar::with_role(
parts.needle.clone(),
ch_host,
CarrierRole::ConditionOnly,
),
];
let carrier_info = CarrierInfo::with_carriers(
parts.loop_var.clone(), // loop_var_name: "i"
i_host, // loop_var_id (LoopState - header PHI + exit PHI)
carriers, // s, ch only (i is handled as loop_var)
);
if debug {
trace.debug(
"pattern6/lower",
&format!(
"Phase 255 P0: CarrierInfo with {} carriers (s, ch: ConditionOnly, i: LoopState)",
carrier_info.carrier_count()
),
);
}
// Step 2: Generate join_inputs and host_inputs dynamically
// CRITICAL: Order must match JoinModule main() params: [i, ch, s] (alphabetical)
// Phase 255 P0: CarrierInfo sorts carriers alphabetically, so params must match
// main() is defined with params: vec![i_main_param, ch_main_param, s_main_param]
let mut host_inputs = vec![i_host, ch_host, s_host]; // [i, ch, s] alphabetical
let mut join_inputs = vec![
ValueId(PARAM_MIN as u32), // i at 100
ValueId(PARAM_MIN as u32 + 1), // ch at 101 (alphabetically first carrier)
ValueId(PARAM_MIN as u32 + 2), // s at 102 (alphabetically second carrier)
];
// Step 3: Build exit_bindings manually
// CRITICAL: ALL carriers (ConditionOnly + LoopState) must be in exit_bindings
// for latch incoming collection, even though ConditionOnly don't participate in exit PHI
use crate::mir::join_ir::lowering::inline_boundary::LoopExitBinding;
let k_exit_func = join_module.require_function("k_exit", "Pattern 6");
let join_exit_value_i = k_exit_func
.params
.first()
.copied()
.expect("k_exit must have parameter for exit value");
let i_exit_binding = LoopExitBinding {
carrier_name: parts.loop_var.clone(),
join_exit_value: join_exit_value_i,
host_slot: i_host,
role: CarrierRole::LoopState,
};
// Phase 255 P0: Add ConditionOnly carriers in alphabetical order [ch, s]
// They don't participate in exit PHI, but need latch incoming collection
let ch_exit_binding = LoopExitBinding {
carrier_name: parts.needle.clone(),
join_exit_value: ValueId(0), // Placeholder - not used for ConditionOnly
host_slot: ch_host,
role: CarrierRole::ConditionOnly,
};
let s_exit_binding = LoopExitBinding {
carrier_name: parts.haystack.clone(),
join_exit_value: ValueId(0), // Placeholder - not used for ConditionOnly
host_slot: s_host,
role: CarrierRole::ConditionOnly,
};
// CRITICAL: Order must match tail call args order: [i, ch, s] (alphabetical)
// Phase 255 P0: loop_step tail call: args = vec![i_plus_1, ch_step_param, s_step_param]
// The loop variable i is first (args[0]), then carriers in alphabetical order (args[1], args[2])
let exit_bindings = vec![i_exit_binding, ch_exit_binding, s_exit_binding];
if debug {
trace.debug(
"pattern6/lower",
&format!("Phase 255 P0: Generated {} exit_bindings", exit_bindings.len()),
);
}
// Step 4: Build boundary with carrier_info
let boundary = JoinInlineBoundaryBuilder::new()
.with_inputs(join_inputs, host_inputs)
.with_exit_bindings(exit_bindings)
.with_loop_var_name(Some(parts.loop_var.clone()))
.with_carrier_info(carrier_info.clone()) // ✅ Key: carrier_info for multi-PHI
.build();
// Step 5: Build PostLoopEarlyReturnPlan for exit PHI usage (Phase 255 P1)
// This forces the exit PHI value to be used, preventing DCE from eliminating it
use crate::mir::builder::control_flow::joinir::patterns::policies::post_loop_early_return_plan::PostLoopEarlyReturnPlan;
use crate::ast::Span;
let post_loop_plan = PostLoopEarlyReturnPlan {
cond: ASTNode::BinaryOp {
operator: BinaryOperator::NotEqual,
left: Box::new(var(&parts.loop_var)), // i
right: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(parts.not_found_return_lit), // -1
span: Span::unknown(),
}),
span: Span::unknown(),
},
ret_expr: var(&parts.loop_var), // return i
};
if debug {
trace.debug(
"pattern6/lower",
"Phase 255 P1: Built PostLoopEarlyReturnPlan (cond: i != -1, ret: i)",
);
}
// Step 6: Execute JoinIRConversionPipeline
use super::conversion_pipeline::JoinIRConversionPipeline;
let _ = JoinIRConversionPipeline::execute(
self,
join_module,
Some(&boundary),
"pattern6",
debug,
)?;
// Step 6.5: Emit post-loop early return guard (Phase 255 P1)
// This prevents exit PHI from being DCE'd by using the value
use super::pattern2_steps::post_loop_early_return_step_box::PostLoopEarlyReturnStepBox;
PostLoopEarlyReturnStepBox::maybe_emit(self, Some(&post_loop_plan))?;
if debug {
trace.debug(
"pattern6/lower",
"Phase 255 P1: Emitted post-loop early return guard (if i != -1 { return i })",
);
}
// Note: The post-loop guard ensures exit PHI is used:
// - k_exit with i (found case)
// - k_exit with -1 (not found case)
// The original "return -1" statement after the loop is unreachable
// and will be optimized away by DCE.
// Step 7: Return Void (loops don't produce values)
let void_val = crate::mir::builder::emission::constant::emit_void(self);
if debug {
trace.debug(
"pattern6/lower",
&format!("Pattern 6 complete, returning Void {:?}", void_val),
);
}
Ok(Some(void_val))
}
}
/// Phase 255 P1: Helper function to create Variable ASTNode
fn var(name: &str) -> ASTNode {
ASTNode::Variable {
name: name.to_string(),
span: crate::ast::Span::unknown(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::{ASTNode, BinaryOperator, Literal, Span};
#[test]
fn test_contains_methodcall_positive() {
// s.substring(i, i+1) == ch
let method_call = ASTNode::MethodCall {
object: Box::new(ASTNode::Variable {
name: "s".to_string(),
span: Span::unknown(),
}),
method: "substring".to_string(),
arguments: vec![],
span: Span::unknown(),
};
let binary = ASTNode::BinaryOp {
operator: BinaryOperator::Equal,
left: Box::new(method_call),
right: Box::new(ASTNode::Variable {
name: "ch".to_string(),
span: Span::unknown(),
}),
span: Span::unknown(),
};
assert!(contains_methodcall(&binary));
}
#[test]
fn test_contains_methodcall_negative() {
// i < len
let binary = ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::Variable {
name: "len".to_string(),
span: Span::unknown(),
}),
span: Span::unknown(),
};
assert!(!contains_methodcall(&binary));
}
#[test]
fn test_is_const_step_pattern_positive() {
// i + 1
let value = ASTNode::BinaryOp {
operator: BinaryOperator::Add,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::Literal {
value: Literal::Integer(1),
span: Span::unknown(),
}),
span: Span::unknown(),
};
assert!(is_const_step_pattern(&value));
}
#[test]
fn test_is_const_step_pattern_negative() {
// i - 1
let value = ASTNode::BinaryOp {
operator: BinaryOperator::Subtract,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::Literal {
value: Literal::Integer(1),
span: Span::unknown(),
}),
span: Span::unknown(),
};
assert!(!is_const_step_pattern(&value));
}
}

5
src/mir/builder/control_flow/joinir/patterns/router.rs
View File

@ -193,6 +193,11 @@ pub(crate) static LOOP_PATTERNS: &[LoopPatternEntry] = &[
detect: super::pattern4_with_continue::can_lower,
lower: super::pattern4_with_continue::lower,
},
LoopPatternEntry {
name: "Pattern6_ScanWithInit", // Phase 254 P0: index_of/find/contains pattern (before P3)
detect: super::pattern6_scan_with_init::can_lower,
lower: super::pattern6_scan_with_init::lower,
},
LoopPatternEntry {
name: "Pattern3_WithIfPhi",
detect: super::pattern3_with_if_phi::can_lower,

3
src/mir/join_ir/lowering/common/body_local_derived_emitter.rs
View File

@ -92,6 +92,7 @@ impl BodyLocalDerivedEmitter {
alloc_value,
env,
Some(body_local_env),
None, // Phase 252: No static box context
)?;
instructions.extend(escape_cond_insts);
@ -130,7 +131,7 @@ impl BodyLocalDerivedEmitter {
let mut env_pre = env.clone();
env_pre.insert(recipe.loop_counter_name.clone(), counter_pre);
let (bounds_ok, bounds_insts) =
lower_condition_to_joinir(bounds_ast, alloc_value, &env_pre, Some(body_local_env))?;
lower_condition_to_joinir(bounds_ast, alloc_value, &env_pre, Some(body_local_env), None)?; // Phase 252: No static box context
instructions.extend(bounds_insts);
let guard = alloc_value();

2
src/mir/join_ir/lowering/common/conditional_step_emitter.rs
View File

@ -81,7 +81,7 @@ pub fn emit_conditional_step_update(
}
// Phase 92 P2-2: Lower the condition expression with body-local support
let (cond_id, cond_insts) = lower_condition_to_joinir(cond_ast, alloc_value, env, body_local_env).map_err(|e| {
let (cond_id, cond_insts) = lower_condition_to_joinir(cond_ast, alloc_value, env, body_local_env, None).map_err(|e| {
format!(
"ConditionalStep invariant violated: condition must be pure expression for carrier '{}': {}",
carrier_name, e

131
src/mir/join_ir/lowering/condition_var_extractor.rs
View File

@ -70,6 +70,33 @@ fn collect_variables_recursive(ast: &ASTNode, vars: &mut BTreeSet<String>) {
ASTNode::Literal { .. } => {
// Literals have no variables
}
// Phase 251 Fix: Handle complex condition expressions
ASTNode::MethodCall { object, arguments, .. } => {
// Recurse into object (e.g., 'arr' in 'arr.length()')
collect_variables_recursive(object, vars);
// Recurse into arguments (e.g., 'i' in 'arr.get(i)')
for arg in arguments {
collect_variables_recursive(arg, vars);
}
}
ASTNode::FieldAccess { object, .. } => {
// Recurse into object (e.g., 'obj' in 'obj.field')
collect_variables_recursive(object, vars);
}
ASTNode::Index { target, index, .. } => {
// Recurse into target (e.g., 'arr' in 'arr[i]')
collect_variables_recursive(target, vars);
// Recurse into index (e.g., 'i' in 'arr[i]')
collect_variables_recursive(index, vars);
}
ASTNode::Call { callee, arguments, .. } => {
// Recurse into callee (e.g., function references)
collect_variables_recursive(callee, vars);
// Recurse into arguments
for arg in arguments {
collect_variables_recursive(arg, vars);
}
}
_ => {
// Other AST nodes not expected in conditions
}
@ -192,4 +219,108 @@ mod tests {
let vars = extract_condition_variables(&ast, &[]);
assert_eq!(vars, vec!["x", "y", "z"]); // 'x' deduplicated
}
#[test]
fn test_extract_method_call() {
// AST: i < arr.length()
let ast = ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::MethodCall {
object: Box::new(ASTNode::Variable {
name: "arr".to_string(),
span: Span::unknown(),
}),
method: "length".to_string(),
arguments: vec![],
span: Span::unknown(),
}),
span: Span::unknown(),
};
let vars = extract_condition_variables(&ast, &["i".to_string()]);
assert_eq!(vars, vec!["arr"]); // Should extract 'arr'
}
#[test]
fn test_extract_field_access() {
// AST: i < obj.count
let ast = ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::FieldAccess {
object: Box::new(ASTNode::Variable {
name: "obj".to_string(),
span: Span::unknown(),
}),
field: "count".to_string(),
span: Span::unknown(),
}),
span: Span::unknown(),
};
let vars = extract_condition_variables(&ast, &["i".to_string()]);
assert_eq!(vars, vec!["obj"]);
}
#[test]
fn test_extract_index() {
// AST: i < arr[j]
let ast = ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::Index {
target: Box::new(ASTNode::Variable {
name: "arr".to_string(),
span: Span::unknown(),
}),
index: Box::new(ASTNode::Variable {
name: "j".to_string(),
span: Span::unknown(),
}),
span: Span::unknown(),
}),
span: Span::unknown(),
};
let vars = extract_condition_variables(&ast, &["i".to_string()]);
assert_eq!(vars, vec!["arr", "j"]); // Both 'arr' and 'j' (sorted)
}
#[test]
fn test_extract_complex_method_call_with_args() {
// AST: i < arr.get(j)
let ast = ASTNode::BinaryOp {
operator: BinaryOperator::Less,
left: Box::new(ASTNode::Variable {
name: "i".to_string(),
span: Span::unknown(),
}),
right: Box::new(ASTNode::MethodCall {
object: Box::new(ASTNode::Variable {
name: "arr".to_string(),
span: Span::unknown(),
}),
method: "get".to_string(),
arguments: vec![ASTNode::Variable {
name: "j".to_string(),
span: Span::unknown(),
}],
span: Span::unknown(),
}),
span: Span::unknown(),
};
let vars = extract_condition_variables(&ast, &["i".to_string()]);
assert_eq!(vars, vec!["arr", "j"]); // Both 'arr' and 'j' (sorted)
}
}

9
src/mir/join_ir/lowering/loop_with_break_minimal.rs
View File

@ -114,6 +114,8 @@ pub(crate) struct LoopWithBreakLoweringInputs<'a> {
pub body_local_derived_recipe: Option<&'a BodyLocalDerivedRecipe>,
/// Phase 107: Balanced depth-scan recipe (find_balanced_* family).
pub balanced_depth_scan_recipe: Option<&'a BalancedDepthScanRecipe>,
/// Phase 252: Name of the static box being lowered (for this.method(...) in break conditions)
pub current_static_box_name: Option<String>,
}
/// Lower Pattern 2 (Loop with Conditional Break) to JoinIR
@ -193,6 +195,7 @@ pub(crate) fn lower_loop_with_break_minimal(
condition_only_recipe,
body_local_derived_recipe,
balanced_depth_scan_recipe,
current_static_box_name, // Phase 252
} = inputs;
let mut body_local_env = body_local_env;
@ -325,7 +328,7 @@ pub(crate) fn lower_loop_with_break_minimal(
)
});
// Phase 169 / Phase 171-fix / Phase 240-EX / Phase 244: Lower condition
// Phase 169 / Phase 171-fix / Phase 240-EX / Phase 244 / Phase 252: Lower condition
let (cond_value, mut cond_instructions) = lower_header_condition(
condition,
env,
@ -333,6 +336,7 @@ pub(crate) fn lower_loop_with_break_minimal(
loop_var_name,
i_param,
&mut alloc_value,
current_static_box_name.as_deref(), // Phase 252
)?;
// After condition lowering, allocate remaining ValueIds
@ -510,7 +514,7 @@ pub(crate) fn lower_loop_with_break_minimal(
}
// ------------------------------------------------------------------
// Phase 170-B / Phase 244 / Phase 92 P2-2: Lower break condition
// Phase 170-B / Phase 244 / Phase 92 P2-2 / Phase 252: Lower break condition
// ------------------------------------------------------------------
// Phase 92 P2-2: Moved after body-local init to support body-local variable references
let (break_cond_value, break_cond_instructions) = lower_break_condition(
@ -521,6 +525,7 @@ pub(crate) fn lower_loop_with_break_minimal(
i_param,
&mut alloc_value,
body_local_env.as_ref().map(|e| &**e), // Phase 92 P2-2: Pass body_local_env
current_static_box_name.as_deref(), // Phase 252
)?;
// ------------------------------------------------------------------

12
src/mir/join_ir/lowering/loop_with_break_minimal/header_break_lowering.rs
View File

@ -28,6 +28,10 @@ fn make_scope_manager<'a>(
}
/// Lower the header condition.
///
/// # Phase 252: current_static_box_name Parameter
///
/// Added to support `this.method(...)` in header conditions for static boxes.
pub(crate) fn lower_header_condition(
condition: &ASTNode,
env: &ConditionEnv,
@ -35,6 +39,7 @@ pub(crate) fn lower_header_condition(
loop_var_name: &str,
loop_var_id: ValueId,
alloc_value: &mut dyn FnMut() -> ValueId,
current_static_box_name: Option<&str>, // Phase 252
) -> Result<(ValueId, Vec<JoinInst>), String> {
use crate::mir::join_ir::lowering::condition_lowering_box::ConditionLoweringBox;
@ -59,6 +64,7 @@ pub(crate) fn lower_header_condition(
loop_var_id,
scope: &scope_manager,
alloc_value,
current_static_box_name: current_static_box_name.map(|s| s.to_string()), // Phase 252
};
match expr_lowerer.lower_condition(condition, &mut context) {
@ -94,6 +100,10 @@ pub(crate) fn lower_header_condition(
///
/// Added `body_local_env` parameter to support break conditions that reference
/// body-local variables (e.g., `ch == '"'` in escape patterns).
///
/// # Phase 252: current_static_box_name Parameter
///
/// Added to support `this.method(...)` in break conditions for static boxes.
pub(crate) fn lower_break_condition(
break_condition: &ASTNode,
env: &ConditionEnv,
@ -102,6 +112,7 @@ pub(crate) fn lower_break_condition(
loop_var_id: ValueId,
alloc_value: &mut dyn FnMut() -> ValueId,
body_local_env: Option<&LoopBodyLocalEnv>, // Phase 92 P2-2
current_static_box_name: Option<&str>, // Phase 252
) -> Result<(ValueId, Vec<JoinInst>), String> {
use crate::mir::join_ir::lowering::condition_lowering_box::ConditionLoweringBox;
@ -126,6 +137,7 @@ pub(crate) fn lower_break_condition(
loop_var_id,
scope: &scope_manager,
alloc_value,
current_static_box_name: current_static_box_name.map(|s| s.to_string()), // Phase 252
};
let value_id = expr_lowerer

1
src/mir/join_ir/lowering/loop_with_continue_minimal.rs
View File

@ -286,6 +286,7 @@ pub(crate) fn lower_loop_with_continue_minimal(
loop_var_id: i_param,
scope: &scope_manager,
alloc_value: &mut alloc_value,
current_static_box_name: None, // Phase 252: TODO - plumb through Pattern 3
};
match expr_lowerer.lower_condition(condition, &mut context) {

2
src/mir/join_ir/lowering/method_call_lowerer.rs
View File

@ -88,6 +88,7 @@ impl<'a> CascadingArgResolver<'a> {
alloc_value,
self.cond_env,
None, // body-local not used for generic expressions
None, // Phase 252: No static box context for argument lowering
instructions,
),
}
@ -182,6 +183,7 @@ impl MethodCallLowerer {
alloc_value,
env,
None, // Phase 92 P2-2: No body-local for method call args
None, // Phase 252: No static box context for method call args
instructions,
)?;
lowered_args.push(arg_val);

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

@ -65,6 +65,7 @@ pub(crate) mod loop_view_builder; // Phase 33-23: Loop lowering dispatch
pub mod loop_with_break_minimal; // Phase 188-Impl-2: Pattern 2 minimal lowerer
pub mod loop_with_continue_minimal;
pub mod method_call_lowerer; // Phase 224-B: MethodCall lowering (metadata-driven)
pub mod user_method_policy; // Phase 252: User-defined method policy (SSOT for static box method whitelists)
pub mod method_return_hint; // Phase 83: P3-D 既知メソッド戻り値型推論箱
pub mod scope_manager; // Phase 231: Unified variable scope management // Phase 195: Pattern 4 minimal lowerer
#[cfg(feature = "normalized_dev")]
@ -74,6 +75,7 @@ pub(crate) mod step_schedule; // Phase 47-A: Generic step scheduler for P2/P3 (r
pub mod loop_with_if_phi_if_sum; // Phase 213: Pattern 3 AST-based if-sum lowerer (Phase 242-EX-A: supports complex conditions)
pub mod min_loop;
pub mod simple_while_minimal; // Phase 188-Impl-1: Pattern 1 minimal lowerer
pub mod scan_with_init_minimal; // Phase 254 P1: Pattern 6 minimal lowerer (index_of/find/contains)
pub mod skip_ws;
pub mod stage1_using_resolver;
pub mod stageb_body;

357
src/mir/join_ir/lowering/scan_with_init_minimal.rs Normal file
View File

@ -0,0 +1,357 @@
//! Phase 254 P1: Pattern 6 (ScanWithInit) Minimal Lowerer
//!
//! Target: apps/tests/phase254_p0_index_of_min.hako
//!
//! Code:
//! ```nyash
//! static box StringUtils {
//! index_of(s, ch) {
//! local i = 0
//! loop(i < s.length()) {
//! if s.substring(i, i + 1) == ch {
//! return i
//! }
//! i = i + 1
//! }
//! return -1
//! }
//! }
//! ```
//!
//! Expected JoinIR:
//! ```text
//! fn main(s, ch, i):
//! result = loop_step(s, ch, i)
//! // Post-loop early return will be inserted by MirBuilder
//!
//! fn loop_step(s, ch, i):
//! // 1. Check exit condition: i >= s.length()
//! len = StringBox.length(s)
//! exit_cond = (i >= len)
//! Jump(k_exit, [-1], cond=exit_cond) // Not found case
//!
//! // 2. Calculate i_plus_1 for substring
//! i_plus_1 = i + 1
//!
//! // 3. Hoist MethodCall(substring) to init-time BoxCall
//! cur = StringBox.substring(s, i, i_plus_1)
//!
//! // 4. Check match condition
//! match = (cur == ch)
//! Jump(k_exit, [i], cond=match) // Found case
//!
//! // 5. Tail recursion
//! Call(loop_step, [s, ch, i_plus_1])
//!
//! fn k_exit(i_exit):
//! return i_exit
//! ```
//!
//! ## Design Notes
//!
//! This is a MINIMAL P0 implementation targeting index_of pattern specifically.
//! Key features:
//! - substring is emitted as BoxCall (init-time, not condition whitelist)
//! - Two Jump instructions to k_exit (not found: -1, found: i)
//! - Step must be 1 (P0 restriction)
//! - not_found_return_lit must be -1 (P0 restriction)
use crate::mir::join_ir::lowering::join_value_space::JoinValueSpace;
use crate::mir::join_ir::{
BinOpKind, CompareOp, ConstValue, JoinFuncId, JoinFunction, JoinInst, JoinModule, MirLikeInst,
};
/// Lower Pattern 6 (ScanWithInit) to JoinIR
///
/// # Phase 254 P1: Pure JoinIR Fragment Generation
///
/// This version generates JoinIR using **JoinValueSpace** for unified ValueId allocation.
/// It uses the Param region (100+) for function parameters and Local region (1000+) for
/// temporary values.
///
/// ## Design Philosophy
///
/// Following Pattern 1's architecture:
/// - **Pure transformer**: No side effects, only JoinIR generation
/// - **Reusable**: Works in any context with proper boundary
/// - **Testable**: Can test JoinIR independently
///
/// ## Boundary Contract
///
/// This function returns a JoinModule with:
/// - **Input slots**: main() params for (s, ch, i)
/// - **Caller responsibility**: Create JoinInlineBoundary to map params to host variables
/// - **Exit binding**: k_exit param receives found index or -1
///
/// # Arguments
///
/// * `join_value_space` - Unified ValueId allocator (Phase 202-A)
///
/// # Returns
///
/// * `JoinModule` - Successfully lowered to JoinIR
pub(crate) fn lower_scan_with_init_minimal(
join_value_space: &mut JoinValueSpace,
) -> JoinModule {
let mut join_module = JoinModule::new();
// ==================================================================
// Function IDs allocation
// ==================================================================
let main_id = JoinFuncId::new(0);
let loop_step_id = JoinFuncId::new(1);
let k_exit_id = JoinFuncId::new(2);
// ==================================================================
// ValueId allocation
// ==================================================================
// main() params/locals
// Phase 255 P0: Loop variable MUST be first, then alphabetical order [ch, s]
// (CarrierInfo sorts carriers alphabetically for determinism)
let i_main_param = join_value_space.alloc_param(); // loop index
let ch_main_param = join_value_space.alloc_param(); // needle character (alphabetically first)
let s_main_param = join_value_space.alloc_param(); // haystack string (alphabetically second)
let loop_result = join_value_space.alloc_local(); // result from loop_step
// loop_step params/locals
// Phase 255 P0: Loop variable MUST be first, then alphabetical order [ch, s]
let i_step_param = join_value_space.alloc_param(); // loop index
let ch_step_param = join_value_space.alloc_param(); // needle (alphabetically first)
let s_step_param = join_value_space.alloc_param(); // haystack (alphabetically second)
let len = join_value_space.alloc_local(); // s.length()
let exit_cond = join_value_space.alloc_local(); // i >= len
let const_minus_1 = join_value_space.alloc_local(); // -1 for not found
let const_1 = join_value_space.alloc_local(); // 1 for increment
let i_plus_1 = join_value_space.alloc_local(); // i + 1
let cur = join_value_space.alloc_local(); // substring result
let match_cond = join_value_space.alloc_local(); // cur == ch
// k_exit params
let i_exit_param = join_value_space.alloc_param(); // exit parameter (index or -1)
// ==================================================================
// main() function
// ==================================================================
let mut main_func = JoinFunction::new(
main_id,
"main".to_string(),
vec![i_main_param, ch_main_param, s_main_param], // Phase 255 P0: [i, ch, s] alphabetical
);
// result = loop_step(i, ch, s) // Phase 255 P0: alphabetical order
main_func.body.push(JoinInst::Call {
func: loop_step_id,
args: vec![i_main_param, ch_main_param, s_main_param], // Phase 255 P0: [i, ch, s] alphabetical
k_next: None,
dst: Some(loop_result),
});
// Return loop_result (found index or -1)
main_func.body.push(JoinInst::Ret { value: Some(loop_result) });
join_module.add_function(main_func);
// ==================================================================
// loop_step(i, ch, s) function
// ==================================================================
// Phase 255 P0: Loop variable first, then alphabetical [ch, s]
let mut loop_step_func = JoinFunction::new(
loop_step_id,
"loop_step".to_string(),
vec![i_step_param, ch_step_param, s_step_param], // Phase 255 P0: [i, ch, s] alphabetical
);
// 1. len = s.length()
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::BoxCall {
dst: Some(len),
box_name: "StringBox".to_string(),
method: "length".to_string(),
args: vec![s_step_param],
}));
// 2. exit_cond = (i >= len)
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::Compare {
dst: exit_cond,
op: CompareOp::Ge,
lhs: i_step_param,
rhs: len,
}));
// 3. const -1
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::Const {
dst: const_minus_1,
value: ConstValue::Integer(-1),
}));
// 4. Jump(k_exit, [-1], cond=exit_cond) - not found case
loop_step_func.body.push(JoinInst::Jump {
cont: k_exit_id.as_cont(),
args: vec![const_minus_1],
cond: Some(exit_cond),
});
// 5. i_plus_1 = i + 1
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::Const {
dst: const_1,
value: ConstValue::Integer(1),
}));
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::BinOp {
dst: i_plus_1,
op: BinOpKind::Add,
lhs: i_step_param,
rhs: const_1,
}));
// 6. cur = s.substring(i, i_plus_1) - init-time BoxCall
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::BoxCall {
dst: Some(cur),
box_name: "StringBox".to_string(),
method: "substring".to_string(),
args: vec![s_step_param, i_step_param, i_plus_1],
}));
// 7. match_cond = (cur == ch)
loop_step_func
.body
.push(JoinInst::Compute(MirLikeInst::Compare {
dst: match_cond,
op: CompareOp::Eq,
lhs: cur,
rhs: ch_step_param,
}));
// 8. Jump(k_exit, [i], cond=match_cond) - found case
loop_step_func.body.push(JoinInst::Jump {
cont: k_exit_id.as_cont(),
args: vec![i_step_param],
cond: Some(match_cond),
});
// 9. Call(loop_step, [i_plus_1, ch, s]) - tail recursion
// Phase 255 P0: Loop variable first, then alphabetical [ch, s]
loop_step_func.body.push(JoinInst::Call {
func: loop_step_id,
args: vec![i_plus_1, ch_step_param, s_step_param], // Phase 255 P0: [i_plus_1, ch, s] alphabetical
k_next: None, // CRITICAL: None for tail call
dst: None,
});
join_module.add_function(loop_step_func);
// ==================================================================
// k_exit(i_exit) function
// ==================================================================
let mut k_exit_func = JoinFunction::new(k_exit_id, "k_exit".to_string(), vec![i_exit_param]);
// Return i_exit (found index or -1)
k_exit_func.body.push(JoinInst::Ret {
value: Some(i_exit_param),
});
join_module.add_function(k_exit_func);
// Set entry point
join_module.entry = Some(main_id);
eprintln!("[joinir/pattern6] Generated JoinIR for ScanWithInit Pattern");
eprintln!("[joinir/pattern6] Functions: main, loop_step, k_exit");
eprintln!("[joinir/pattern6] BoxCall: substring (init-time, not condition whitelist)");
join_module
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_lower_scan_with_init_minimal() {
let mut join_value_space = JoinValueSpace::new();
let join_module = lower_scan_with_init_minimal(&mut join_value_space);
// main + loop_step + k_exit の3関数
assert_eq!(join_module.functions.len(), 3);
// Entry が main(0) に設定されている
assert_eq!(join_module.entry, Some(JoinFuncId::new(0)));
// k_exit 関数が取れる
let k_exit_func = join_module
.functions
.get(&JoinFuncId::new(2))
.expect("k_exit function should exist");
assert_eq!(k_exit_func.name, "k_exit");
}
#[test]
fn test_loop_step_has_substring_box_call() {
let mut join_value_space = JoinValueSpace::new();
let join_module = lower_scan_with_init_minimal(&mut join_value_space);
// loop_step 関数を取得
let loop_step = join_module
.functions
.get(&JoinFuncId::new(1))
.expect("loop_step function should exist");
// BoxCall(substring) が含まれることを確認
let has_substring = loop_step.body.iter().any(|inst| {
matches!(
inst,
JoinInst::Compute(MirLikeInst::BoxCall { method, .. })
if method == "substring"
)
});
assert!(
has_substring,
"loop_step should contain substring BoxCall"
);
}
#[test]
fn test_loop_step_has_exit_jumps() {
let mut join_value_space = JoinValueSpace::new();
let join_module = lower_scan_with_init_minimal(&mut join_value_space);
// loop_step 関数を取得
let loop_step = join_module
.functions
.get(&JoinFuncId::new(1))
.expect("loop_step function should exist");
// Jump(k_exit, ...) が2つ含まれることを確認
let exit_jump_count = loop_step
.body
.iter()
.filter(|inst| {
matches!(
inst,
JoinInst::Jump { cont, .. }
if *cont == JoinFuncId::new(2).as_cont()
)
})
.count();
assert_eq!(
exit_jump_count, 2,
"loop_step should have 2 exit jumps"
);
}
}

304
src/mir/join_ir/lowering/user_method_policy.rs Normal file
View File

@ -0,0 +1,304 @@
//! Phase 252: User-Defined Method Policy Box
//!
//! This box provides a Single Source of Truth (SSOT) for determining whether
//! user-defined static box methods are allowed in JoinIR contexts.
//!
//! ## Design Philosophy
//!
//! **Box-First Design**: UserMethodPolicy is a single-responsibility box that
//! answers one question: "Can this static box method be safely lowered to JoinIR?"
//!
//! **Metadata-Driven**: Uses a policy table to determine allowed methods.
//! NO method name hardcoding in lowering logic - all decisions made here.
//!
//! **Fail-Fast**: If a method is not in the policy table, immediately returns false.
//! No silent fallbacks or guessing.
//!
//! **Future Extension**: This SSOT can be moved to .hako annotations or nyash.toml
//! in the future without breaking lowering logic.
//!
//! ## Supported Static Boxes
//!
//! - **StringUtils**: String utility functions (trim, character checks, etc.)
//!
//! ## Example Usage
//!
//! ```ignore
//! // Check if StringUtils.is_whitespace is allowed in condition
//! if UserMethodPolicy::allowed_in_condition("StringUtils", "is_whitespace") {
//! // Lower this.is_whitespace(...) to JoinIR
//! }
//! ```
/// Phase 252: User-Defined Method Policy Box
///
/// Provides metadata for user-defined static box methods to determine
/// their eligibility for JoinIR lowering in different contexts.
pub struct UserMethodPolicy;
impl UserMethodPolicy {
/// Check if a user-defined method is allowed in loop condition context
///
/// # Requirements for Condition Context
///
/// - Method must be pure (no side effects)
/// - Method should return boolean (for use in conditions)
/// - Method should be deterministic (same inputs → same outputs)
///
/// # Arguments
///
/// * `box_name` - Name of the static box (e.g., "StringUtils")
/// * `method_name` - Name of the method (e.g., "is_whitespace")
///
/// # Returns
///
/// * `true` - Method is whitelisted for condition context
/// * `false` - Method is not whitelisted or unknown
///
/// # Example
///
/// ```ignore
/// // Loop condition: loop(i < n && not this.is_whitespace(ch))
/// assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_whitespace"));
/// assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "trim_start"));
/// ```
pub fn allowed_in_condition(box_name: &str, method_name: &str) -> bool {
match box_name {
"StringUtils" => Self::stringutils_allowed_in_condition(method_name),
_ => false, // Unknown static box - fail-fast
}
}
/// Check if a user-defined method is allowed in LoopBodyLocal init context
///
/// # Requirements for Init Context
///
/// - Method must be pure (no side effects)
/// - Method can return any type (strings, integers, etc.)
/// - Method should be deterministic
///
/// # Arguments
///
/// * `box_name` - Name of the static box (e.g., "StringUtils")
/// * `method_name` - Name of the method (e.g., "trim_start")
///
/// # Returns
///
/// * `true` - Method is whitelisted for init context
/// * `false` - Method is not whitelisted or unknown
///
/// # Example
///
/// ```ignore
/// // LoopBodyLocal init: local ch = s.substring(i, i + 1)
/// // (substring is allowed in init but not in condition)
/// assert!(UserMethodPolicy::allowed_in_init("StringUtils", "trim_start"));
/// ```
pub fn allowed_in_init(box_name: &str, method_name: &str) -> bool {
match box_name {
"StringUtils" => Self::stringutils_allowed_in_init(method_name),
_ => false, // Unknown static box - fail-fast
}
}
// ========================================================================
// StringUtils Policy Table
// ========================================================================
/// StringUtils methods allowed in condition context
///
/// All methods here are pure boolean-returning functions suitable for
/// use in loop conditions and conditional expressions.
///
/// # StringUtils Source
///
/// See: `apps/lib/json_native/utils/string.hako`
fn stringutils_allowed_in_condition(method_name: &str) -> bool {
matches!(
method_name,
// Character classification (pure boolean functions)
"is_whitespace" // ch == " " or ch == "\t" or ...
| "is_digit" // ch == "0" or ch == "1" or ...
| "is_hex_digit" // is_digit(ch) or ch == "a" or ...
| "is_alpha" // (ch >= "a" and ch <= "z") or ...
| "is_alphanumeric" // is_alpha(ch) or is_digit(ch)
// String validation (pure boolean functions)
| "is_integer" // Checks if string represents an integer
| "is_empty_or_whitespace" // trim(s).length() == 0
// String matching (pure boolean functions)
| "starts_with" // s.substring(0, prefix.length()) == prefix
| "ends_with" // s.substring(s.length() - suffix.length(), ...) == suffix
| "contains" // index_of_string(s, substr) != -1
)
}
/// StringUtils methods allowed in init context
///
/// All methods here are pure functions but may return non-boolean types
/// (strings, integers). Suitable for LoopBodyLocal initialization.
///
/// # StringUtils Source
///
/// See: `apps/lib/json_native/utils/string.hako`
fn stringutils_allowed_in_init(method_name: &str) -> bool {
matches!(
method_name,
// Whitespace handling (pure string functions)
"trim" // s.trim() (VM StringBox method)
| "trim_start" // Remove leading whitespace
| "trim_end" // Remove trailing whitespace
// String search (pure integer-returning functions)
| "index_of" // First occurrence of character (-1 if not found)
| "last_index_of" // Last occurrence of character (-1 if not found)
| "index_of_string" // First occurrence of substring (-1 if not found)
// String transformation (pure string functions)
| "to_upper" // Convert string to uppercase
| "to_lower" // Convert string to lowercase
| "char_to_upper" // Convert single character to uppercase
| "char_to_lower" // Convert single character to lowercase
// String manipulation (pure functions)
| "join" // Join array elements with separator
| "split" // Split string by separator
// Numeric parsing (pure functions)
| "parse_float" // Parse floating-point number (currently identity)
| "parse_integer" // Parse integer from string
// Character classification (also allowed in init)
| "is_whitespace"
| "is_digit"
| "is_hex_digit"
| "is_alpha"
| "is_alphanumeric"
| "is_integer"
| "is_empty_or_whitespace"
| "starts_with"
| "ends_with"
| "contains"
)
}
}
#[cfg(test)]
mod tests {
use super::*;
// ===== Condition Context Tests =====
#[test]
fn test_stringutils_character_classification_in_condition() {
// Pure boolean character classification methods should be allowed
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_whitespace"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_digit"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_hex_digit"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_alpha"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_alphanumeric"));
}
#[test]
fn test_stringutils_validation_in_condition() {
// Pure boolean validation methods should be allowed
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_integer"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_empty_or_whitespace"));
}
#[test]
fn test_stringutils_matching_in_condition() {
// Pure boolean matching methods should be allowed
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "starts_with"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "ends_with"));
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "contains"));
}
#[test]
fn test_stringutils_string_functions_not_in_condition() {
// String-returning functions should NOT be allowed in condition
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "trim"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "trim_start"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "trim_end"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "to_upper"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "to_lower"));
}
#[test]
fn test_stringutils_search_not_in_condition() {
// Integer-returning search functions should NOT be allowed in condition
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "index_of"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "last_index_of"));
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "index_of_string"));
}
#[test]
fn test_unknown_static_box_in_condition() {
// Unknown static boxes should fail-fast
assert!(!UserMethodPolicy::allowed_in_condition("UnknownBox", "some_method"));
assert!(!UserMethodPolicy::allowed_in_condition("MathUtils", "abs"));
}
// ===== Init Context Tests =====
#[test]
fn test_stringutils_all_pure_methods_in_init() {
// All pure methods should be allowed in init (more permissive than condition)
// Character classification
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "is_whitespace"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "is_digit"));
// String manipulation
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "trim"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "trim_start"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "trim_end"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "to_upper"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "to_lower"));
// String search
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "index_of"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "last_index_of"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "index_of_string"));
// Numeric parsing
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "parse_integer"));
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "parse_float"));
}
#[test]
fn test_unknown_static_box_in_init() {
// Unknown static boxes should fail-fast
assert!(!UserMethodPolicy::allowed_in_init("UnknownBox", "some_method"));
assert!(!UserMethodPolicy::allowed_in_init("MathUtils", "sqrt"));
}
// ===== Real-World Pattern Tests =====
#[test]
fn test_trim_end_pattern() {
// Phase 252 P0: StringUtils.trim_end/1 pattern
// loop(i >= 0) { if not this.is_whitespace(s.substring(i, i + 1)) { break } ... }
// is_whitespace should be allowed in condition (boolean check)
assert!(UserMethodPolicy::allowed_in_condition("StringUtils", "is_whitespace"));
// trim_end itself should NOT be allowed in condition (string function)
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "trim_end"));
// But trim_end should be allowed in init
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "trim_end"));
}
#[test]
fn test_index_of_pattern() {
// Pattern: local pos = this.index_of(s, ch)
// index_of returns integer (-1 or index), not boolean
// Should NOT be allowed in condition
assert!(!UserMethodPolicy::allowed_in_condition("StringUtils", "index_of"));
// But should be allowed in init
assert!(UserMethodPolicy::allowed_in_init("StringUtils", "index_of"));
}
}