tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions 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,