From b25fc289eb6a0fe8f26d5680d5c5e53b4a86dc7e Mon Sep 17 00:00:00 2001 From: nyash-codex Date: Mon, 8 Dec 2025 19:47:29 +0900 Subject: [PATCH] refactor(joinir): Unify Pattern 2 with PatternPipelineContext MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 179-B Task 5: Refactor Pattern 2 to use PatternPipelineContext for unified preprocessing. Changes: - Use build_pattern_context() for initial loop variable extraction and scope construction - Extract loop_var_name, loop_var_id, carrier_info, and scope from context - Keep Trim pattern logic inline (complex, needs dedicated module in future Phase 180+) - Reduce line count: 517 → 509 lines (1.5% reduction) Note: Pattern 2 has significant complexity (Trim pattern, carrier filtering, break condition processing) that cannot be easily unified without breaking the "analyzer-only" design constraint of PatternPipelineContext. The minimal refactoring maintains compatibility while establishing the pipeline pattern. Benefits: - Consistent entry point with Pattern 1/3 - Establishes pattern for future Trim module extraction - Maintains all existing functionality and test compatibility 🤖 Generated with Claude Code (https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .../joinir/patterns/pattern2_with_break.rs | 62 ++++++++----------- 1 file changed, 27 insertions(+), 35 deletions(-) diff --git a/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs b/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs index a6cfc296..be188251 100644 --- a/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs +++ b/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs @@ -75,17 +75,19 @@ pub fn lower( } impl MirBuilder { - /// Phase 188-Impl-2: Pattern 2 (Loop with Conditional Break) minimal lowerer + /// Phase 179-B: Pattern 2 (Loop with Conditional Break) minimal lowerer /// - /// Similar to Pattern 1, but handles loops with break statements. + /// **Refactored**: Now uses PatternPipelineContext for unified preprocessing /// - /// # Steps - /// 1. Extract loop variable from condition - /// 2. Generate JoinIR using loop_with_break_minimal - /// 3. Convert JoinModule → MirModule - /// 4. Create JoinInlineBoundary for input mapping - /// 5. Merge MIR blocks into current_function - /// 6. Return Void (loop doesn't produce values) + /// # Pipeline (Phase 179-B) + /// 1. Build preprocessing context → PatternPipelineContext + /// 2. Pattern 2-specific processing (Trim, carrier updates, break condition) + /// 3. Call JoinIR lowerer → JoinModule + /// 4. Create boundary from context → JoinInlineBoundary + /// 5. Merge MIR blocks → JoinIRConversionPipeline + /// + /// Note: Pattern 2 has complex Trim pattern logic that remains inline + /// for now. Future Phase 180+ will move Trim logic to dedicated module. pub(in crate::mir::builder) fn cf_loop_pattern2_with_break( &mut self, condition: &ASTNode, @@ -94,29 +96,31 @@ impl MirBuilder { debug: bool, ) -> Result, String> { use crate::mir::join_ir::lowering::loop_with_break_minimal::lower_loop_with_break_minimal; - use crate::mir::BasicBlockId; - use std::collections::BTreeSet; // Phase 195: Use unified trace trace::trace().debug("pattern2", "Calling Pattern 2 minimal lowerer"); - // Phase 33-22: Use CommonPatternInitializer for loop variable extraction - // Phase 171-C-4: carrier_info is now mutable for promotion merging - use super::common_init::CommonPatternInitializer; - let (loop_var_name, loop_var_id, mut carrier_info) = - CommonPatternInitializer::initialize_pattern( - self, - condition, - &self.variable_map, - None, // Pattern 2 handles break-triggered vars via condition_bindings - )?; + // Phase 179-B: Use PatternPipelineContext for unified preprocessing + // Note: Pattern 2 still needs inline processing for Trim/carrier logic + use super::pattern_pipeline::{build_pattern_context, PatternVariant}; + let ctx = build_pattern_context( + self, + condition, + _body, + PatternVariant::Pattern2, + )?; + + // Extract from context + let loop_var_name = ctx.loop_var_name.clone(); + let loop_var_id = ctx.loop_var_id; + let mut carrier_info = ctx.carrier_info.clone(); + let scope = ctx.loop_scope.clone(); eprintln!( - "[pattern2/init] CommonPatternInitializer returned: loop_var='{}', loop_var_id={:?}, carriers={}", + "[pattern2/init] PatternPipelineContext: loop_var='{}', loop_var_id={:?}, carriers={}", loop_var_name, loop_var_id, carrier_info.carriers.len() ); - // Phase 195: Use unified trace trace::trace().varmap("pattern2_start", &self.variable_map); @@ -150,18 +154,6 @@ impl MirBuilder { eprintln!(" No condition-only variables"); } - // Phase 171-172: Use LoopScopeShapeBuilder for unified initialization (Issue 4) - // Extract body_locals from loop body AST for proper variable classification (Trim support) - use super::loop_scope_shape_builder::LoopScopeShapeBuilder; - let scope = LoopScopeShapeBuilder::with_body_locals( - BasicBlockId(0), - BasicBlockId(0), - BasicBlockId(0), - BasicBlockId(0), - BTreeSet::new(), - _body, - ); - // Phase 170-B: Extract break condition from loop body use super::ast_feature_extractor; let break_condition_raw = ast_feature_extractor::extract_break_condition(_body)