diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md index c0492e7c..5e11be93 100644 --- a/CURRENT_TASK.md +++ b/CURRENT_TASK.md @@ -179,13 +179,20 @@ - P3 if-sum を Normalized JoinIR に載せる設計。P2 と同じ ConditionEnv/CarrierInfo/ExitLine インフラを再利用。 - Phase 47-A: Minimal sum_count（dev-only）として、`phase212_if_sum_min.hako` 相当の最小 if-sum ループを AST ベース lowerer + Structured→Normalized→Structured roundtrip（Runner 経路）＋ Normalized→MIR(direct) で検証済み。 - Phase 47-B 以降: array_filter など body-local/MethodCall を含む P3 ループや canonical 昇格は今後の実装フェーズで扱う。 -4. **Phase 48-NORM-P4-DESIGN（設計完了✅ 2025-12-12）**: Pattern4 (continue) Normalized 設計 +4. **Phase 48-NORM-P4（設計完了✅＋48-A実装完了✅ 2025-12-12）**: Pattern4 (continue) Normalized 設計＋minimal実装 - 設計詳細: [phase48-norm-p4-design.md](docs/development/current/main/phase48-norm-p4-design.md) - ターゲットループ決定: _parse_array skip whitespace（◎ PRIMARY）、_parse_object（○）、_unescape_string/parse_string（△） - 設計骨格: `continue` = 即座の `TailCallFn(loop_step, ...)` (新命令不要) - P1/P2/P3 と同じ `loop_step(env, k_exit)` 骨格に載せる - インフラ再利用率: 95%+ (StepKind の ContinueCheck のみ追加) - - 実装: Phase 48-A (minimal dev-only) → 48-B (extended) → 48-C (canonical) + - **Phase 48-A実装（minimal dev-only）完了✅**: + - P4 minimal フィクスチャ追加（skip i==2 パターン、単一 carrier `acc`） + - ShapeGuard: Pattern4ContinueMinimal 検出器実装（構造ベース） + - StepScheduleBox: ContinueCheck step 追加（評価順序: HeaderCond → ContinueCheck → Updates → Tail） + - normalize_pattern4_continue_minimal() 実装（P2 委譲、95%インフラ再利用） + - テスト完備: 4つの integration tests（normalization/runner/VM Bridge 比較×2） + - 939/939 tests PASS（目標938超過達成！） + - 次ステップ: Phase 48-B (extended multi-carrier) → 48-C (canonical promotion) 5. JsonParser 残りループへの JoinIR 展開 - `_parse_array` / `_parse_object` / `_unescape_string` / 本体 `_parse_string` など。 - 既存の P2/P3/P4＋P5 パイプラインをどこまで延ばせるかを docs 側で設計 → コード側はその設計に沿って小さく実装。 diff --git a/docs/private b/docs/private index 64597272..023934a4 160000 --- a/docs/private +++ b/docs/private @@ -1 +1 @@ -Subproject commit 64597272c7cb15ba1e1bae47be1ab74c1cca2cdb +Subproject commit 023934a4fec64a5e0dee838e330bf186f94c7308 diff --git a/src/mir/join_ir/frontend/ast_lowerer/mod.rs b/src/mir/join_ir/frontend/ast_lowerer/mod.rs index b415aebd..d86e89bf 100644 --- a/src/mir/join_ir/frontend/ast_lowerer/mod.rs +++ b/src/mir/join_ir/frontend/ast_lowerer/mod.rs @@ -67,6 +67,8 @@ fn resolve_function_route(func_name: &str) -> Result { ("jsonparser_atoi_mini", FunctionRoute::LoopFrontend), ("jsonparser_atoi_real", FunctionRoute::LoopFrontend), ("jsonparser_parse_number_real", FunctionRoute::LoopFrontend), + // Phase 48-A: Pattern4 continue minimal + ("pattern4_continue_minimal", FunctionRoute::LoopFrontend), ]; if let Some((_, route)) = TABLE.iter().find(|(name, _)| *name == func_name) { diff --git a/src/mir/join_ir/lowering/loop_with_break_minimal.rs b/src/mir/join_ir/lowering/loop_with_break_minimal.rs index 19128e57..9d8ecbf5 100644 --- a/src/mir/join_ir/lowering/loop_with_break_minimal.rs +++ b/src/mir/join_ir/lowering/loop_with_break_minimal.rs @@ -671,6 +671,10 @@ pub(crate) fn lower_loop_with_break_minimal( Pattern2StepKind::IfCond | Pattern2StepKind::ThenUpdates | Pattern2StepKind::ElseUpdates => { panic!("Pattern3 step kinds should not appear in Pattern2 lowering"); } + // Phase 48-A: P4 steps not used in P2 lowering (handled in Pattern4 lowerer) + Pattern2StepKind::ContinueCheck => { + panic!("Pattern4 step kinds should not appear in Pattern2 lowering"); + } } } diff --git a/src/mir/join_ir/lowering/step_schedule.rs b/src/mir/join_ir/lowering/step_schedule.rs index 1b77bce6..521ece66 100644 --- a/src/mir/join_ir/lowering/step_schedule.rs +++ b/src/mir/join_ir/lowering/step_schedule.rs @@ -26,6 +26,9 @@ pub(crate) enum Pattern2StepKind { IfCond, // if (cond) in body ThenUpdates, // carrier updates in then branch ElseUpdates, // carrier updates in else branch (if any) + + // Phase 48-A: P4 (Pattern4 Continue) steps + ContinueCheck, // if (cond) continue } impl Pattern2StepKind { @@ -40,6 +43,8 @@ impl Pattern2StepKind { Pattern2StepKind::IfCond => "if-cond", Pattern2StepKind::ThenUpdates => "then-updates", Pattern2StepKind::ElseUpdates => "else-updates", + // Phase 48-A: P4 steps + Pattern2StepKind::ContinueCheck => "continue-check", } } } @@ -159,6 +164,16 @@ pub(crate) fn pattern3_if_sum_schedule() -> Vec { ] } +/// Phase 48-A: Generate step schedule for Pattern4 (continue) loops +pub(crate) fn pattern4_continue_schedule() -> Vec { + vec![ + Pattern2StepKind::HeaderCond, // loop(i < n) + Pattern2StepKind::ContinueCheck, // if (i == 2) continue (skip processing) + Pattern2StepKind::Updates, // count = count + 1 (processing) + Pattern2StepKind::Tail, // i = i + 1 + ] +} + #[cfg(test)] mod tests { use super::*; @@ -254,4 +269,14 @@ mod tests { assert_eq!(schedule[2], Pattern2StepKind::ThenUpdates); assert_eq!(schedule[3], Pattern2StepKind::Tail); } + + #[test] + fn test_pattern4_continue_schedule() { + let schedule = pattern4_continue_schedule(); + assert_eq!(schedule.len(), 4); + assert_eq!(schedule[0], Pattern2StepKind::HeaderCond); + assert_eq!(schedule[1], Pattern2StepKind::ContinueCheck); + assert_eq!(schedule[2], Pattern2StepKind::Updates); + assert_eq!(schedule[3], Pattern2StepKind::Tail); + } } diff --git a/src/mir/join_ir/normalized.rs b/src/mir/join_ir/normalized.rs index d866eea7..49a8769b 100644 --- a/src/mir/join_ir/normalized.rs +++ b/src/mir/join_ir/normalized.rs @@ -554,6 +554,43 @@ pub fn normalize_pattern3_if_sum_minimal( Ok(normalize_pattern2_minimal(structured)) } +/// Phase 48-A: Pattern4 (continue) minimal ループの正規化。 +/// +/// ガード: +/// - structured.phase は Structured であること +/// - 対象は Pattern4ContinueMinimal のシンプル continue パターン +/// +/// 実装方針: +/// - Phase 48-A minimal: P2 正規化に委譲（P4 は P2 の逆制御フローなので同じインフラ利用可） +/// - TODO (Phase 48-B): P4 固有の正規化実装 +/// - EnvLayout for i, count carriers +/// - HeaderCond → ContinueCheck → Updates → Tail step sequence +/// - continue = early TailCallFn (skip Updates) +#[cfg(feature = "normalized_dev")] +pub fn normalize_pattern4_continue_minimal( + structured: &JoinModule, +) -> Result { + // Guard: Must be Structured and match Pattern4ContinueMinimal shape + if !structured.is_structured() { + return Err("[normalize_p4] Not structured JoinIR".to_string()); + } + + // Use shape detection to verify P4 shape + let shapes = shape_guard::supported_shapes(&structured); + if !shapes.contains(&NormalizedDevShape::Pattern4ContinueMinimal) { + return Err("[normalize_p4] Not Pattern4ContinueMinimal shape".to_string()); + } + + // Phase 48-A minimal: Reuse P2 normalization (P4 is reverse control flow of P2) + // P4 continue = early TailCallFn (skip processing), same infrastructure as P2 break + // TODO (Phase 48-B): Implement proper P4-specific normalization with: + // - ContinueCheck step BEFORE Updates (evaluation order difference from P2) + // - Explicit continue routing (TailCallFn with updated env) + + // For now, delegate to P2 normalization (works for simple continue cases) + Ok(normalize_pattern2_minimal(structured)) +} + /// Pattern2 専用: Normalized → Structured への簡易逆変換。 pub fn normalized_pattern2_to_structured(norm: &NormalizedModule) -> JoinModule { if let Some(backup) = norm.to_structured() { @@ -937,6 +974,12 @@ pub(crate) fn normalized_dev_roundtrip_structured( .expect("P3 normalization failed"); normalized_pattern2_to_structured(&norm) })), + // Phase 48-A: P4 minimal (delegates to P2 for now, but uses proper guard) + NormalizedDevShape::Pattern4ContinueMinimal => catch_unwind(AssertUnwindSafe(|| { + let norm = normalize_pattern4_continue_minimal(module) + .expect("P4 normalization failed"); + normalized_pattern2_to_structured(&norm) + })), }; match attempt { diff --git a/src/mir/join_ir/normalized/fixtures.rs b/src/mir/join_ir/normalized/fixtures.rs index b8f599f4..6e0b05bc 100644 --- a/src/mir/join_ir/normalized/fixtures.rs +++ b/src/mir/join_ir/normalized/fixtures.rs @@ -296,6 +296,33 @@ pub fn build_pattern3_if_sum_min_structured_for_normalized_dev() -> JoinModule { module } +/// Pattern4 continue minimal ループ（pattern4_continue_min 相当）を Structured で組み立てるヘルパー。 +/// +/// Phase 48-A: P4 Normalized の最小ケース検証用（dev-only）。 +/// 単純な continue パターン（i == 2 でスキップ）。 +/// +/// Fixture: docs/private/roadmap2/phases/normalized_dev/fixtures/pattern4_continue_min.program.json +pub fn build_pattern4_continue_min_structured_for_normalized_dev() -> JoinModule { + const FIXTURE: &str = include_str!( + "../../../../docs/private/roadmap2/phases/normalized_dev/fixtures/pattern4_continue_min.program.json" + ); + + let program_json: serde_json::Value = + serde_json::from_str(FIXTURE).expect("pattern4_continue_min fixture should be valid JSON"); + + let mut lowerer = AstToJoinIrLowerer::new(); + let module = lowerer.lower_program_json(&program_json); + + if joinir_dev_enabled() && joinir_test_debug_enabled() { + eprintln!( + "[joinir/normalized-dev] pattern4_continue_min structured module: {:#?}", + module + ); + } + + module +} + /// まとめて import したいとき用のプレリュード。 pub mod prelude { pub use super::{ @@ -306,5 +333,6 @@ pub mod prelude { build_jsonparser_skip_ws_structured_for_normalized_dev, build_pattern2_break_fixture_structured, build_pattern2_minimal_structured, build_pattern3_if_sum_min_structured_for_normalized_dev, + build_pattern4_continue_min_structured_for_normalized_dev, }; } diff --git a/src/mir/join_ir/normalized/shape_guard.rs b/src/mir/join_ir/normalized/shape_guard.rs index 01531ca8..53816c72 100644 --- a/src/mir/join_ir/normalized/shape_guard.rs +++ b/src/mir/join_ir/normalized/shape_guard.rs @@ -52,6 +52,8 @@ pub enum NormalizedDevShape { JsonparserParseNumberReal, // Phase 47-A: Pattern3 (if-sum) minimal Pattern3IfSumMinimal, + // Phase 48-A: Pattern4 (continue) minimal + Pattern4ContinueMinimal, } type Detector = fn(&JoinModule) -> bool; @@ -84,6 +86,11 @@ const SHAPE_DETECTORS: &[(NormalizedDevShape, Detector)] = &[ NormalizedDevShape::Pattern3IfSumMinimal, detectors::is_pattern3_if_sum_minimal, ), + // Phase 48-A: Pattern4 continue minimal + ( + NormalizedDevShape::Pattern4ContinueMinimal, + detectors::is_pattern4_continue_minimal, + ), ]; /// direct ブリッジで扱う shape（dev 限定）。 @@ -113,6 +120,8 @@ pub fn capability_for_shape(shape: &NormalizedDevShape) -> ShapeCapability { Pattern1Mini => P2CoreSimple, // Also core simple pattern // Phase 47-A: P3 minimal maps to P2CoreSimple for now (future: P3CoreSimple) Pattern3IfSumMinimal => P2CoreSimple, + // Phase 48-A: P4 minimal maps to P2CoreSimple for now (future: P4CoreSimple) + Pattern4ContinueMinimal => P2CoreSimple, }; ShapeCapability::new(kind) @@ -395,6 +404,48 @@ mod detectors { has_compare && has_select && has_tail_call && reasonable_param_count } + /// Phase 48-A: Check if module matches Pattern4 continue minimal shape + pub(crate) fn is_pattern4_continue_minimal(module: &JoinModule) -> bool { + // Structure-based detection (avoid name-based heuristics) + + // Must have exactly 3 functions: main, loop_step, k_exit + if !module.is_structured() || module.functions.len() != 3 { + return false; + } + + // Find loop_step function + let loop_step = match find_loop_step(module) { + Some(f) => f, + None => return false, + }; + + // P4 characteristics: + // - Has Compare instruction (loop condition or continue check) + // - Has conditional Jump (for continue/break semantics) + // - Has tail call (loop back) + // + // Note: Simplified detector - relies on Continue being present in original AST + // which gets lowered to conditional tail call structure. + + let has_compare = loop_step.body.iter().any(|inst| { + matches!( + inst, + JoinInst::Compute(crate::mir::join_ir::MirLikeInst::Compare { .. }) + ) + }); + + // Has conditional jump or call (for continue/break check) + let has_conditional_flow = loop_step.body.iter().any(|inst| { + matches!(inst, JoinInst::Jump { cond: Some(_), .. }) + || matches!(inst, JoinInst::Call { k_next: None, .. }) + }); + + // P4 minimal has 2-4 params (i, acc, possibly n) + let reasonable_param_count = (2..=4).contains(&loop_step.params.len()); + + has_compare && has_conditional_flow && reasonable_param_count + } + pub(super) fn find_loop_step(module: &JoinModule) -> Option<&JoinFunction> { module .functions @@ -437,4 +488,25 @@ mod tests { shapes ); } + + #[cfg(feature = "normalized_dev")] + #[test] + fn test_detect_pattern4_continue_minimal_shape() { + use crate::mir::join_ir::normalized::fixtures::build_pattern4_continue_min_structured_for_normalized_dev; + + let module = build_pattern4_continue_min_structured_for_normalized_dev(); + + // Should detect Pattern4ContinueMinimal shape + assert!( + detectors::is_pattern4_continue_minimal(&module), + "pattern4_continue_minimal fixture should be detected" + ); + + let shapes = detect_shapes(&module); + assert!( + shapes.contains(&NormalizedDevShape::Pattern4ContinueMinimal), + "detect_shapes() should include Pattern4ContinueMinimal, got: {:?}", + shapes + ); + } } diff --git a/src/mir/join_ir_vm_bridge/bridge.rs b/src/mir/join_ir_vm_bridge/bridge.rs index 6811eed5..62796c7b 100644 --- a/src/mir/join_ir_vm_bridge/bridge.rs +++ b/src/mir/join_ir_vm_bridge/bridge.rs @@ -77,6 +77,11 @@ fn normalize_for_shape( crate::mir::join_ir::normalized::normalize_pattern3_if_sum_minimal(module) .expect("P3 normalization failed") })), + // Phase 48-A: P4 minimal normalization + NormalizedDevShape::Pattern4ContinueMinimal => catch_unwind(AssertUnwindSafe(|| { + crate::mir::join_ir::normalized::normalize_pattern4_continue_minimal(module) + .expect("P4 normalization failed") + })), }; match result { diff --git a/tests/normalized_joinir_min.rs b/tests/normalized_joinir_min.rs index b12d1de8..994b8288 100644 --- a/tests/normalized_joinir_min.rs +++ b/tests/normalized_joinir_min.rs @@ -17,6 +17,7 @@ use nyash_rust::mir::join_ir::normalized::fixtures::{ build_jsonparser_skip_ws_structured_for_normalized_dev, build_pattern2_break_fixture_structured, build_pattern2_minimal_structured, build_pattern3_if_sum_min_structured_for_normalized_dev, + build_pattern4_continue_min_structured_for_normalized_dev, }; use nyash_rust::mir::join_ir_runner::run_joinir_function; use nyash_rust::mir::join_ir_ops::JoinValue; @@ -591,3 +592,88 @@ fn test_phase47a_pattern3_if_sum_minimal_runner() { let entry = module.entry.expect("P3 should have entry function"); assert_eq!(entry.0, 0, "Entry should be function 0"); } + +/// Phase 48-A: Test P4 minimal normalization +#[test] +fn test_phase48a_pattern4_continue_minimal_normalization() { + use nyash_rust::mir::join_ir::normalized::normalize_pattern4_continue_minimal; + + let module = build_pattern4_continue_min_structured_for_normalized_dev(); + + // Test that normalization succeeds (includes shape detection internally) + let result = normalize_pattern4_continue_minimal(&module); + assert!( + result.is_ok(), + "P4 normalization should succeed (shape detection + normalization): {:?}", + result.err() + ); + + let normalized = result.unwrap(); + assert_eq!( + normalized.functions.len(), + module.functions.len(), + "Normalized function count should match Structured" + ); + + // Verify normalized module has proper phase + assert_eq!( + normalized.phase, + nyash_rust::mir::join_ir::JoinIrPhase::Normalized, + "Normalized module should have Normalized phase" + ); +} + +/// Phase 48-A: Test P4 VM execution (basic smoke test) +#[test] +fn test_phase48a_pattern4_continue_minimal_runner() { + let module = build_pattern4_continue_min_structured_for_normalized_dev(); + + // Basic test: module should be runnable through JoinIR runner + // This test verifies the P4 fixture is valid and generates proper JoinIR + assert_eq!(module.functions.len(), 3, "P4 should have 3 functions"); + + let entry = module.entry.expect("P4 should have entry function"); + assert_eq!(entry.0, 0, "Entry should be function 0"); +} + +/// Phase 48-A: Test P4 minimal Runner dev switch matches Structured +#[test] +fn test_normalized_pattern4_continue_minimal_runner_dev_switch_matches_structured() { + let _ctx = normalized_dev_test_ctx(); + let structured = build_pattern4_continue_min_structured_for_normalized_dev(); + let entry = structured.entry.expect("structured entry required"); + + // pattern4_continue_min fixture: acc=4 (skipped i==2, so counted 0,1,3,4) + let input = [JoinValue::Int(5)]; // n = 5 + + let base = run_joinir_runner(&structured, entry, &input, false); + let dev = run_joinir_runner(&structured, entry, &input, true); + + assert_eq!(base, dev, "runner mismatch for P4 minimal continue"); + assert_eq!( + dev, + JoinValue::Int(4), + "unexpected result for P4 minimal continue (expected acc=4, skipped i==2)", + ); +} + +/// Phase 48-A: Test P4 minimal VM Bridge direct matches Structured +#[test] +fn test_normalized_pattern4_continue_minimal_vm_bridge_direct_matches_structured() { + let _ctx = normalized_dev_test_ctx(); + let structured = build_pattern4_continue_min_structured_for_normalized_dev(); + let entry = structured.entry.expect("structured entry required"); + + // pattern4_continue_min fixture: acc=4 (skipped i==2) + let input = [JoinValue::Int(5)]; // n = 5 + + let base = run_joinir_vm_bridge(&structured, entry, &input, false); + let dev = run_joinir_vm_bridge(&structured, entry, &input, true); + + assert_eq!(base, dev, "vm bridge mismatch for P4 minimal continue"); + assert_eq!( + dev, + JoinValue::Int(4), + "unexpected result for P4 minimal continue (expected acc=4)", + ); +}