448 lines
18 KiB
Rust
448 lines
18 KiB
Rust
//! Pattern Router - Table-driven dispatch for loop patterns
|
|
//!
|
|
//! Phase 194: Replace if/else chain with table-driven routing
|
|
//!
|
|
//! # Architecture
|
|
//!
|
|
//! - Each pattern registers a detect function and a lower function
|
|
//! - Patterns are tried in priority order (lower = tried first)
|
|
//! - First matching pattern wins
|
|
//! - Feature extraction delegated to ast_feature_extractor module
|
|
//!
|
|
//! # Adding New Patterns
|
|
//!
|
|
//! 1. Create a new module in `patterns/` (e.g., `pattern4_your_name.rs`)
|
|
//! 2. Implement `pub fn can_lower(ctx: &LoopPatternContext) -> bool`
|
|
//! 3. Implement `pub fn lower(builder: &mut MirBuilder, ctx: &LoopPatternContext) -> Result<Option<ValueId>, String>`
|
|
//! 4. Add entry to `LOOP_PATTERNS` table below
|
|
//!
|
|
//! That's it! No need to modify routing logic.
|
|
|
|
use crate::ast::ASTNode;
|
|
use crate::mir::builder::MirBuilder;
|
|
use crate::mir::ValueId;
|
|
|
|
use crate::mir::loop_pattern_detection::{LoopFeatures, LoopPatternKind};
|
|
|
|
// Phase 273 P1: Import Plan components (DomainPlan → Normalizer → Verifier → Lowerer)
|
|
use crate::mir::builder::control_flow::plan::lowerer::PlanLowerer;
|
|
use crate::mir::builder::control_flow::plan::normalizer::PlanNormalizer;
|
|
use crate::mir::builder::control_flow::plan::verifier::PlanVerifier;
|
|
use crate::mir::builder::control_flow::plan::composer;
|
|
use crate::mir::builder::control_flow::plan::single_planner;
|
|
|
|
/// AST Feature Extractor (declared in mod.rs as pub module, import from parent)
|
|
use super::ast_feature_extractor as ast_features;
|
|
|
|
/// Phase 92 P0-2: Import LoopSkeleton for Option A
|
|
use crate::mir::loop_canonicalizer::LoopSkeleton;
|
|
|
|
/// Context passed to pattern detect/lower functions
|
|
pub(crate) struct LoopPatternContext<'a> {
|
|
/// Loop condition AST node
|
|
pub condition: &'a ASTNode,
|
|
|
|
/// Loop body statements
|
|
pub body: &'a [ASTNode],
|
|
|
|
/// Current function name (for routing)
|
|
pub func_name: &'a str,
|
|
|
|
/// Debug logging enabled
|
|
pub debug: bool,
|
|
|
|
/// In static box context? (affects Pattern8 routing)
|
|
pub in_static_box: bool,
|
|
|
|
/// Has continue statement(s) in body? (Phase 194+)
|
|
#[allow(dead_code)]
|
|
pub has_continue: bool,
|
|
|
|
/// Has break statement(s) in body? (Phase 194+)
|
|
#[allow(dead_code)]
|
|
pub has_break: bool,
|
|
|
|
/// Phase 192: Loop features extracted from AST
|
|
#[allow(dead_code)]
|
|
pub features: LoopFeatures,
|
|
|
|
/// Phase 192: Pattern classification based on features
|
|
pub pattern_kind: LoopPatternKind,
|
|
|
|
/// Phase 200-C: Optional function body AST for capture analysis
|
|
/// None if not available, Some(&[ASTNode]) if function body is accessible
|
|
pub fn_body: Option<&'a [ASTNode]>,
|
|
|
|
/// Phase 92 P0-2: Optional LoopSkeleton from canonicalizer
|
|
/// This provides ConditionalStep information for Pattern2 lowering.
|
|
/// None if canonicalizer hasn't run yet (backward compatibility).
|
|
/// SSOT Principle: Avoid re-detecting ConditionalStep in lowering phase.
|
|
#[allow(dead_code)]
|
|
pub skeleton: Option<&'a LoopSkeleton>,
|
|
|
|
/// Phase 188.3: Cached StepTree max_loop_depth for Pattern6
|
|
/// None if not computed, Some(depth) if Pattern6 candidate
|
|
/// Avoids re-building StepTree in lowering phase
|
|
pub step_tree_max_loop_depth: Option<u32>,
|
|
}
|
|
|
|
impl<'a> LoopPatternContext<'a> {
|
|
/// Create new context from routing parameters
|
|
///
|
|
/// Automatically detects continue/break statements in body
|
|
/// Extracts features and classifies pattern from AST
|
|
/// Detects infinite loop condition
|
|
/// Uses choose_pattern_kind() SSOT entry point
|
|
pub(crate) fn new(
|
|
condition: &'a ASTNode,
|
|
body: &'a [ASTNode],
|
|
func_name: &'a str,
|
|
debug: bool,
|
|
in_static_box: bool,
|
|
) -> Self {
|
|
// Use AST Feature Extractor for break/continue detection
|
|
let has_continue = ast_features::detect_continue_in_body(body);
|
|
let has_break = ast_features::detect_break_in_body(body);
|
|
|
|
// Extract features (includes infinite loop detection)
|
|
let features = ast_features::extract_features(condition, body, has_continue, has_break);
|
|
|
|
// Phase 137-6-S1: Use SSOT pattern selection entry point
|
|
use crate::mir::builder::control_flow::joinir::routing::choose_pattern_kind;
|
|
let pattern_kind = choose_pattern_kind(condition, body);
|
|
|
|
Self {
|
|
condition,
|
|
body,
|
|
func_name,
|
|
debug,
|
|
in_static_box,
|
|
has_continue,
|
|
has_break,
|
|
features,
|
|
pattern_kind,
|
|
fn_body: None, // Phase 200-C: Default to None
|
|
skeleton: None, // Phase 92 P0-2: Default to None
|
|
step_tree_max_loop_depth: None, // Phase 188.3: Default to None
|
|
}
|
|
}
|
|
|
|
/// Phase 200-C: Create context with fn_body for capture analysis
|
|
pub(crate) fn with_fn_body(
|
|
condition: &'a ASTNode,
|
|
body: &'a [ASTNode],
|
|
func_name: &'a str,
|
|
debug: bool,
|
|
in_static_box: bool,
|
|
fn_body: &'a [ASTNode],
|
|
) -> Self {
|
|
let mut ctx = Self::new(condition, body, func_name, debug, in_static_box);
|
|
ctx.fn_body = Some(fn_body);
|
|
ctx
|
|
}
|
|
|
|
/// Phase 92 P0-2: Set skeleton (for canonicalizer integration)
|
|
#[allow(dead_code)]
|
|
pub(crate) fn with_skeleton(mut self, skeleton: &'a LoopSkeleton) -> Self {
|
|
self.skeleton = Some(skeleton);
|
|
self
|
|
}
|
|
}
|
|
|
|
/// Phase 286 P2.2: Common helper for Plan line lowering
|
|
///
|
|
/// Extracts the common 3-line pattern used by Pattern6/7/4/1:
|
|
/// 1. Normalize DomainPlan → CorePlan
|
|
/// 2. Verify CorePlan invariants (fail-fast)
|
|
/// 3. Lower CorePlan → MIR
|
|
///
|
|
/// This eliminates repetition across 4 pattern routing blocks.
|
|
fn lower_via_plan(
|
|
builder: &mut MirBuilder,
|
|
domain_plan: crate::mir::builder::control_flow::plan::DomainPlan,
|
|
ctx: &LoopPatternContext,
|
|
) -> Result<Option<ValueId>, String> {
|
|
let core_plan = PlanNormalizer::normalize(builder, domain_plan, ctx)?;
|
|
PlanVerifier::verify(&core_plan)?;
|
|
PlanLowerer::lower(builder, core_plan, ctx)
|
|
}
|
|
|
|
// Phase 29ai P5: Plan extractor routing moved to `plan::single_planner`.
|
|
|
|
/// Phase 272 P0.2 Refactoring: can_lower() strategy classification
|
|
///
|
|
/// Clarifies the two main detection strategies used across patterns:
|
|
///
|
|
/// ## ExtractionBased (SSOT Approach)
|
|
/// - Used by: Pattern6, Pattern7
|
|
/// - Strategy: Try pattern extraction, if successful → match
|
|
/// - Pros: Single source of truth (extract function defines pattern)
|
|
/// - Cons: Extraction can be expensive (but amortized over lowering)
|
|
///
|
|
/// ## StructureBased (Feature Classification)
|
|
/// - Used by: Pattern1, Pattern2, Pattern3, Pattern4, Pattern5, Pattern8, Pattern9
|
|
/// - Strategy: Check pattern_kind (from LoopPatternContext), plus optional structural checks
|
|
/// - Pros: Fast classification, reuses centralized feature detection
|
|
/// - Cons: Two sources of truth (classify + structural checks)
|
|
///
|
|
/// ## Rationale for Dual Strategy:
|
|
/// - Pattern6/7: Complex extraction logic (variable step, carrier tracking)
|
|
/// → ExtractionBased avoids duplication between detect and extract
|
|
/// - Other patterns: Simple structural features (break/continue/if-phi)
|
|
/// → StructureBased leverages centralized LoopFeatures classification
|
|
///
|
|
/// This documentation prevents bugs like Phase 272 P0.2's Pattern7 issue
|
|
/// (pattern_kind check was too restrictive, extraction-based approach fixed it).
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
#[allow(dead_code)] // Documentation purpose - not enforced in code yet
|
|
pub(crate) enum CanLowerStrategy {
|
|
/// Extraction-based detection: Try extract(), success → match
|
|
/// Used by Pattern6, Pattern7
|
|
ExtractionBased,
|
|
|
|
/// Structure-based detection: Check pattern_kind from LoopPatternContext
|
|
/// Used by Pattern1, Pattern2, Pattern3, Pattern4, Pattern5, Pattern8, Pattern9
|
|
StructureBased,
|
|
}
|
|
|
|
/// Entry in the loop pattern router table.
|
|
/// Each pattern registers a detect function and a lower function.
|
|
pub(crate) struct LoopPatternEntry {
|
|
/// Human-readable pattern name for debugging
|
|
pub(crate) name: &'static str,
|
|
|
|
/// Detection function: returns true if this pattern matches
|
|
pub(crate) detect: fn(&MirBuilder, &LoopPatternContext) -> bool,
|
|
|
|
/// Lowering function: performs the actual JoinIR generation
|
|
pub(crate) lower: fn(&mut MirBuilder, &LoopPatternContext) -> Result<Option<ValueId>, String>,
|
|
}
|
|
|
|
/// Static table of all registered loop patterns.
|
|
///
|
|
/// **IMPORTANT**: Patterns are tried in array order (SSOT).
|
|
/// Array order defines priority - earlier entries are tried first.
|
|
/// Pattern4 → Pattern8 → Pattern9 → Pattern3 → Pattern1 → Pattern2
|
|
///
|
|
/// # Current Patterns (Structure-based detection, established Phase 131-11+)
|
|
///
|
|
/// Pattern detection strategies (updated Phase 286):
|
|
/// - Pattern6/7: ExtractionBased (Plan line, Phase 273+)
|
|
/// - Pattern5/8/9: ExtractionBased (extraction functions, Plan line Phase 286+)
|
|
/// - Pattern1-4: StructureBased (LoopFeatures classification, legacy)
|
|
///
|
|
/// - Pattern 4: Loop with Continue (loop_continue_pattern4.hako)
|
|
/// - Detection: pattern_kind == Pattern4Continue
|
|
/// - Structure: has_continue && !has_break
|
|
///
|
|
/// - Pattern 3: Loop with If-Else PHI (loop_if_phi.hako)
|
|
/// - Detection: pattern_kind == Pattern3IfPhi
|
|
/// - Structure: has_if_else_phi && !has_break && !has_continue
|
|
///
|
|
/// - Pattern 1: Simple While Loop (loop_min_while.hako)
|
|
/// - Detection: pattern_kind == Pattern1SimpleWhile
|
|
/// - Structure: !has_break && !has_continue && !has_if_else_phi
|
|
///
|
|
/// - Pattern 2: Loop with Conditional Break (joinir_min_loop.hako)
|
|
/// - Detection: pattern_kind == Pattern2Break
|
|
/// - Structure: has_break && !has_continue
|
|
///
|
|
/// Note: func_name is now only used for debug logging, not pattern detection
|
|
/// Phase 286: Pattern5 removed (migrated to Plan-based routing)
|
|
pub(crate) static LOOP_PATTERNS: &[LoopPatternEntry] = &[
|
|
LoopPatternEntry {
|
|
name: "Pattern6_NestedLoopMinimal", // Phase 188.3: 1-level nested loop
|
|
detect: super::pattern6_nested_minimal::can_lower,
|
|
lower: super::pattern6_nested_minimal::lower,
|
|
},
|
|
LoopPatternEntry {
|
|
name: "Pattern4_WithContinue",
|
|
detect: super::pattern4_with_continue::can_lower,
|
|
lower: super::pattern4_with_continue::lower,
|
|
},
|
|
// Phase 273 P0.1: Pattern6 entry removed (migrated to Plan-based routing)
|
|
// Pattern6_ScanWithInit now handled via extract_scan_with_init_plan() + PlanLowerer
|
|
// Phase 273 P2: Pattern7 entry removed (migrated to Plan-based routing)
|
|
// Pattern7_SplitScan now handled via extract_split_scan_plan() + PlanLowerer
|
|
LoopPatternEntry {
|
|
name: "Pattern8_BoolPredicateScan", // Phase 259 P0: boolean predicate scan (is_integer/is_valid)
|
|
detect: super::pattern8_scan_bool_predicate::can_lower,
|
|
lower: super::pattern8_scan_bool_predicate::lower,
|
|
},
|
|
LoopPatternEntry {
|
|
name: "Pattern9_AccumConstLoop", // Phase 270 P1: accumulator const loop (橋渡しパターン, before P1)
|
|
detect: super::pattern9_accum_const_loop::can_lower,
|
|
lower: super::pattern9_accum_const_loop::lower,
|
|
},
|
|
LoopPatternEntry {
|
|
name: "Pattern3_WithIfPhi",
|
|
detect: super::pattern3_with_if_phi::can_lower,
|
|
lower: super::pattern3_with_if_phi::lower,
|
|
},
|
|
LoopPatternEntry {
|
|
name: "Pattern1_Minimal",
|
|
detect: super::pattern1_minimal::can_lower,
|
|
lower: super::pattern1_minimal::lower,
|
|
},
|
|
LoopPatternEntry {
|
|
name: "Pattern2_WithBreak",
|
|
detect: super::pattern2_with_break::can_lower,
|
|
lower: super::pattern2_with_break::lower,
|
|
},
|
|
];
|
|
|
|
/// Try all registered patterns in priority order.
|
|
///
|
|
/// Returns Ok(Some(value_id)) if a pattern matched and lowered successfully.
|
|
/// Returns Ok(None) if no pattern matched.
|
|
/// Returns Err if a pattern matched but lowering failed.
|
|
///
|
|
/// # Router Architecture (Structure-based routing established Phase 183)
|
|
///
|
|
/// This router uses multiple detection strategies:
|
|
/// - Plan-based (Pattern6/7): extract_*_plan() → DomainPlan (Phase 273+ SSOT)
|
|
/// - Extraction-based (Pattern8/9): extract_*() functions (already implemented)
|
|
/// - Structure-based (Pattern1-5): ctx.pattern_kind classification (legacy)
|
|
///
|
|
/// # Plan Line SSOT for Pattern6/7 (Phase 273+)
|
|
///
|
|
/// This function implements the following routing strategy:
|
|
/// 1. Try Plan-based Pattern6 (extract_scan_with_init_plan) → DomainPlan
|
|
/// 2. Try Plan-based Pattern7 (extract_split_scan_plan) → DomainPlan
|
|
/// 3. Fall through to legacy Pattern1-5 table for other patterns
|
|
///
|
|
/// The Plan line (Extractor → Normalizer → Verifier → Lowerer) is the
|
|
/// current operational SSOT for Pattern6/7. Legacy patterns (1-5) use
|
|
/// the traditional LoopPatternContext-based routing.
|
|
///
|
|
/// Plan-based architecture (Phase 273 P1-P3):
|
|
/// - extract_*_plan() → DomainPlan (pure extraction, no builder)
|
|
/// - PlanNormalizer::normalize() → CorePlan (pattern knowledge expansion, SSOT)
|
|
/// - PlanVerifier::verify() → fail-fast validation
|
|
/// - PlanLowerer::lower() → MIR emission (pattern-agnostic, emit_frag SSOT)
|
|
///
|
|
/// SSOT Entry Points:
|
|
/// - Pattern6: src/mir/builder/control_flow/plan/normalizer.rs (ScanWithInit normalization)
|
|
/// - Pattern7: src/mir/builder/control_flow/plan/normalizer.rs (SplitScan normalization)
|
|
/// - Pattern1-5: src/mir/builder/control_flow/joinir/patterns/pattern*.rs (direct lowering)
|
|
pub(crate) fn route_loop_pattern(
|
|
builder: &mut MirBuilder,
|
|
ctx: &LoopPatternContext,
|
|
) -> Result<Option<ValueId>, String> {
|
|
use super::super::trace;
|
|
|
|
// Phase 29ai P5: Single entrypoint for plan extraction (router has no rule table).
|
|
if let (Some(domain_plan), outcome) = single_planner::try_build_domain_plan_with_outcome(ctx)? {
|
|
let strict_or_dev = crate::config::env::joinir_dev::strict_enabled()
|
|
|| crate::config::env::joinir_dev_enabled();
|
|
|
|
if let Some(adopt) = composer::try_shadow_adopt_core_plan(
|
|
builder,
|
|
ctx,
|
|
strict_or_dev,
|
|
&domain_plan,
|
|
&outcome,
|
|
)? {
|
|
let composer::ShadowAdoptOutcome { core_plan, tag } = adopt;
|
|
PlanVerifier::verify(&core_plan)?;
|
|
eprintln!("{}", tag);
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
|
|
if !strict_or_dev {
|
|
if let Some(core_plan) = composer::try_release_adopt_core_plan_for_pattern1(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)? {
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
if let Some(core_plan) =
|
|
composer::try_release_adopt_core_plan_for_pattern6_scan_with_init(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)?
|
|
{
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
if let Some(core_plan) =
|
|
composer::try_release_adopt_core_plan_for_pattern7_split_scan(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)?
|
|
{
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
if let Some(core_plan) =
|
|
composer::try_release_adopt_core_plan_for_pattern2_break_subset(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)?
|
|
{
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
if let Some(core_plan) =
|
|
composer::try_release_adopt_core_plan_for_pattern3_ifphi(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)?
|
|
{
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
if let Some(core_plan) =
|
|
composer::try_release_adopt_core_plan_for_pattern5_infinite_early_exit(
|
|
builder,
|
|
ctx,
|
|
&domain_plan,
|
|
&outcome,
|
|
)?
|
|
{
|
|
PlanVerifier::verify(&core_plan)?;
|
|
return PlanLowerer::lower(builder, core_plan, ctx);
|
|
}
|
|
}
|
|
|
|
return lower_via_plan(builder, domain_plan, ctx);
|
|
}
|
|
|
|
// Phase 183: Route based on pre-classified pattern kind
|
|
// Pattern kind was already determined by ctx.pattern_kind in LoopPatternContext::new()
|
|
// This eliminates duplicate detection logic across routers.
|
|
|
|
// Find matching pattern entry based on pattern_kind
|
|
// Phase 273 P0.1: Pattern6 skip logic removed (entry no longer in LOOP_PATTERNS)
|
|
for entry in LOOP_PATTERNS {
|
|
if (entry.detect)(builder, ctx) {
|
|
let log_msg = format!("route=joinir strategy=extract pattern={} (Phase 194+)", entry.name);
|
|
trace::trace().pattern("route", &log_msg, true);
|
|
return (entry.lower)(builder, ctx);
|
|
}
|
|
}
|
|
|
|
// No pattern matched - return None (caller will handle error)
|
|
if ctx.debug {
|
|
trace::trace().debug(
|
|
"route",
|
|
&format!(
|
|
"route=none (no pattern matched) func='{}' pattern_kind={:?} (exhausted: plan+joinir)",
|
|
ctx.func_name, ctx.pattern_kind
|
|
),
|
|
);
|
|
}
|
|
Ok(None)
|
|
}
|