From aef9374b5ad5bd933cd5b5072d55921d9fe40046 Mon Sep 17 00:00:00 2001 From: nyash-codex Date: Sun, 30 Nov 2025 07:14:50 +0900 Subject: [PATCH] =?UTF-8?q?refactor(joinir):=20LoopScopeShape=20=E3=83=A2?= =?UTF-8?q?=E3=82=B8=E3=83=A5=E3=83=BC=E3=83=AB=E7=AE=B1=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## 目的 loop_scope_shape.rs（1274行）を責務別に7ファイルに分割し、 箱理論に基づいた保守性の高い構造に再構成。 ## 箱化構造 ``` loop_scope_shape/ ├── README.md - 責務説明 ├── mod.rs - モジュール統合 ├── shape.rs - 変数分類のSSOT + 質問系API（Phase 48-4） ├── builder.rs - LoopForm/Trio からの組み立て ├── case_a.rs - Case-A minimal ターゲット判定 ├── context.rs - generic_case_a 共通コンテキスト └── tests.rs - 回帰テスト（13本） ``` ## 責務分離 ### shape.rs（核心） - **SSOT**: 変数分類（pinned/carrier/body_local/exit_live） - **Phase 48-4 API**: - `get_exit_live()`: LoopExitLivenessBox 代替 - `is_available_in_all()`: LocalScopeInspectorBox 代替 - `variable_definitions`: Phase 48-5+ で統合予定 ### builder.rs（組み立て） - `from_existing_boxes_legacy()`: Trio → LoopScopeShape - `from_loop_form()`: Phase 48-2 で内部化（Trio 依存削減） - Case-A ルーティング込み ### case_a.rs（判定） - `is_case_a_minimal_target()`: Phase 30 F-3.1 ハードコード集合 ### context.rs（共通化） - `CaseAContext`: generic_case_a 共通ロジック ### tests.rs（検証） - 13本のテスト（Phase 48-4 の2本含む） - 回帰防止の完全カバレッジ ## Phase 48-4 テスト復活 リファクタリング時に削除された2本のテストを復活: - `test_is_available_in_all_phase48_4`: 空の variable_definitions - `test_is_available_in_all_phase48_5_future`: Phase 48-5+ シミュレート ## テスト結果 ``` running 13 tests test test_get_exit_live ... ok test test_is_available_in_all_phase48_4 ... ok test test_is_available_in_all_phase48_5_future ... ok [... 10 other tests ...] test result: ok. 13 passed; 0 failed ``` ## 箱理論の実践 ### 箱化の利点 - ✅ 単一責務: shape.rs が SSOT、builder.rs が組み立て - ✅ 拡張容易: 新しい入力経路は builder.rs に箱追加 - ✅ テスタビリティ: tests.rs で独立検証 - ✅ API安定性: shape.rs の質問系 API が外部インターフェース ### Phase 48-5+ への橋渡し - shape.rs に Phase 48-4 API が配置済み - builder.rs で Trio 依存を段階削除可能 - variable_definitions 統合の準備完了 ## 修正ファイル - 削除: `src/mir/join_ir/lowering/loop_scope_shape.rs` (1274行) - 新規: `src/mir/join_ir/lowering/loop_scope_shape/` (7ファイル) 🎉 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../lowering/loop_scope_shape/README.md | 13 + .../lowering/loop_scope_shape/builder.rs | 236 +++++++++ .../lowering/loop_scope_shape/case_a.rs | 25 + .../lowering/loop_scope_shape/context.rs | 107 ++++ .../join_ir/lowering/loop_scope_shape/mod.rs | 19 + .../lowering/loop_scope_shape/shape.rs | 129 +++++ .../lowering/loop_scope_shape/tests.rs | 459 ++++++++++++++++++ 7 files changed, 988 insertions(+) create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/README.md create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/builder.rs create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/case_a.rs create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/context.rs create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/mod.rs create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/shape.rs create mode 100644 src/mir/join_ir/lowering/loop_scope_shape/tests.rs diff --git a/src/mir/join_ir/lowering/loop_scope_shape/README.md b/src/mir/join_ir/lowering/loop_scope_shape/README.md new file mode 100644 index 00000000..a0d021a0 --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/README.md @@ -0,0 +1,13 @@ +# loop_scope_shape + +LoopScopeShape を箱化し、JoinIR lowering からの質問をここに集約するよ。 + +- `shape.rs`: 変数分類の SSOT。pinned/carrier/body_local/exit_live と API を提供。 +- `builder.rs`: LoopForm + Trio を受け取って LoopScopeShape を組み立て。Case-A ルーティング込み。 +- `case_a.rs`: Case-A minimal ターゲット判定（Phase 30 F-3.1 のハードコード集合）。 +- `context.rs`: generic_case_a 共通の CaseAContext。 +- `tests.rs`: 既存仕様の回帰テスト。 + +責務の境界: +- 解析・分類の仕様は shape.rs に閉じ込める（他層は API で参照）。 +- 新しい入力経路を足すときは builder.rs に箱を追加し、shape.rs の SSOT を崩さないこと。 diff --git a/src/mir/join_ir/lowering/loop_scope_shape/builder.rs b/src/mir/join_ir/lowering/loop_scope_shape/builder.rs new file mode 100644 index 00000000..0daf5fc5 --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/builder.rs @@ -0,0 +1,236 @@ +//! LoopScopeShape の組み立てロジック +//! +//! LoopForm / 既存箱から LoopScopeShape を構築し、Case-A minimal ターゲットは +//! analyze_case_a パスにルーティングする。 + +use std::collections::{BTreeMap, BTreeSet}; + +use crate::mir::control_form::LoopId; +use crate::mir::join_ir::lowering::loop_form_intake::LoopFormIntake; +use crate::mir::loop_form::LoopForm; +use crate::mir::phi_core::local_scope_inspector::LocalScopeInspectorBox; +use crate::mir::phi_core::loop_exit_liveness::LoopExitLivenessBox; +use crate::mir::phi_core::loop_var_classifier::{LoopVarClass, LoopVarClassBox}; +use crate::mir::{BasicBlockId, MirQuery}; + +use super::case_a::is_case_a_minimal_target; +use super::shape::LoopScopeShape; + +impl LoopScopeShape { + /// Case-A ルーティング込みで LoopScopeShape を構築 + pub(crate) fn from_existing_boxes( + loop_form: &LoopForm, + intake: &LoopFormIntake, + var_classes: &LoopVarClassBox, + exit_live_box: &LoopExitLivenessBox, + query: &impl MirQuery, + func_name: Option<&str>, + ) -> Option { + if let Some(name) = func_name { + if is_case_a_minimal_target(name) { + return Self::analyze_case_a( + loop_form, + intake, + var_classes, + exit_live_box, + query, + name, + ); + } + } + + Self::from_existing_boxes_legacy(loop_form, intake, var_classes, exit_live_box, query) + } + + /// Trio 引数なしで LoopScopeShape を構築（Trio 内部化） + pub(crate) fn from_loop_form( + loop_form: &LoopForm, + intake: &LoopFormIntake, + query: &impl MirQuery, + func_name: Option<&str>, + ) -> Option { + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + + Self::from_existing_boxes( + loop_form, + intake, + &var_classes, + &exit_live_box, + query, + func_name, + ) + } + + /// Case-A minimal 用の解析パス（現在は legacy と同じ実装） + fn analyze_case_a( + loop_form: &LoopForm, + intake: &LoopFormIntake, + var_classes: &LoopVarClassBox, + exit_live_box: &LoopExitLivenessBox, + query: &impl MirQuery, + func_name: &str, + ) -> Option { + let result = + Self::from_existing_boxes_legacy(loop_form, intake, var_classes, exit_live_box, query)?; + + if std::env::var("NYASH_LOOPSCOPE_DEBUG").is_ok() { + eprintln!( + "[loopscope/case_a] {} via analyze_case_a path (pinned={}, carriers={}, exit_live={})", + func_name, + result.pinned.len(), + result.carriers.len(), + result.exit_live.len(), + ); + } + + Some(result) + } + + /// 既存箱ベースの従来実装（Case-A 以外のループで使用） + fn from_existing_boxes_legacy( + loop_form: &LoopForm, + intake: &LoopFormIntake, + var_classes: &LoopVarClassBox, + exit_live_box: &LoopExitLivenessBox, + query: &impl MirQuery, + ) -> Option { + let layout = block_layout(loop_form); + + if std::env::var("NYASH_LOOPSCOPE_DEBUG").is_ok() { + let loop_id = LoopId(0); + let control = loop_form.to_control_view(loop_id); + eprintln!( + "[loopscope/view] region.header={:?}, latches={}, exit_edges={}, control.exits={}", + layout.header, + loop_form.to_region_view(loop_id).latches.len(), + loop_form.to_exit_edges(loop_id).len(), + control.exits.len() + ); + } + + let pinned: BTreeSet = intake.pinned_ordered.iter().cloned().collect(); + let carriers: BTreeSet = intake.carrier_ordered.iter().cloned().collect(); + + let inspector = build_inspector(intake, layout.exit); + let (body_locals, mut exit_live) = + classify_body_and_exit(var_classes, intake, &inspector, &layout); + + let exit_live_from_box = + merge_exit_live_from_box(exit_live_box, query, intake, layout.exit); + for name in exit_live_from_box { + exit_live.insert(name); + } + + let progress_carrier = carriers.iter().next().cloned(); + let variable_definitions = BTreeMap::new(); + + Some(Self { + header: layout.header, + body: layout.body, + latch: layout.latch, + exit: layout.exit, + pinned, + carriers, + body_locals, + exit_live, + progress_carrier, + variable_definitions, + }) + } +} + +#[derive(Debug, Copy, Clone)] +struct LoopBlockLayout { + header: BasicBlockId, + body: BasicBlockId, + latch: BasicBlockId, + exit: BasicBlockId, +} + +fn block_layout(loop_form: &LoopForm) -> LoopBlockLayout { + let loop_id = LoopId(0); // 単一ループの場合は 0 + let region = loop_form.to_region_view(loop_id); + let exit_edges = loop_form.to_exit_edges(loop_id); + + let header = region.header; + let body = loop_form.body; // body は region.blocks から推測が難しいので直接参照 + let latch = region.latches.first().copied().unwrap_or(loop_form.latch); + let exit = exit_edges.first().map(|e| e.to).unwrap_or(loop_form.exit); + + LoopBlockLayout { + header, + body, + latch, + exit, + } +} + +fn build_inspector(intake: &LoopFormIntake, exit: BasicBlockId) -> LocalScopeInspectorBox { + let mut inspector = LocalScopeInspectorBox::new(); + inspector.record_snapshot(exit, &intake.header_snapshot); + for (bb, snap) in &intake.exit_snapshots { + inspector.record_snapshot(*bb, snap); + } + inspector +} + +fn classify_body_and_exit( + var_classes: &LoopVarClassBox, + intake: &LoopFormIntake, + inspector: &LocalScopeInspectorBox, + layout: &LoopBlockLayout, +) -> (BTreeSet, BTreeSet) { + let all_names: Vec = intake.header_snapshot.keys().cloned().collect(); + let classified = var_classes.classify_all( + &all_names, + &intake.pinned_ordered, + &intake.carrier_ordered, + inspector, + &intake.exit_preds, + ); + + let mut body_locals: BTreeSet = BTreeSet::new(); + let mut exit_live: BTreeSet = BTreeSet::new(); + + for (name, class) in &classified { + match class { + LoopVarClass::Pinned | LoopVarClass::Carrier => { + exit_live.insert(name.clone()); + } + LoopVarClass::BodyLocalExit => { + body_locals.insert(name.clone()); + exit_live.insert(name.clone()); + } + LoopVarClass::BodyLocalInternal => { + body_locals.insert(name.clone()); + } + } + } + + if std::env::var("NYASH_LOOPSCOPE_DEBUG").is_ok() { + eprintln!( + "[loopscope/classify] header={:?} exit={} locals={} exit_live={}", + layout.header, + layout.exit.0, + body_locals.len(), + exit_live.len() + ); + } + + (body_locals, exit_live) +} + +fn merge_exit_live_from_box( + exit_live_box: &LoopExitLivenessBox, + query: &impl MirQuery, + intake: &LoopFormIntake, + exit_block: BasicBlockId, +) -> BTreeSet { + exit_live_box.compute_live_at_exit( + query, + exit_block, + &intake.header_snapshot, + &intake.exit_snapshots, + ) +} diff --git a/src/mir/join_ir/lowering/loop_scope_shape/case_a.rs b/src/mir/join_ir/lowering/loop_scope_shape/case_a.rs new file mode 100644 index 00000000..ad7b4383 --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/case_a.rs @@ -0,0 +1,25 @@ +//! Phase 30 F-3.1: Case-A minimal ターゲット判定 + +/// 現在 JoinIR lowering でサポートしている Case-A minimal ループのみ true を返す。 +/// これらは LoopScopeShape の新しい analyze_case_a パスを通る。 +/// +/// # Supported Targets +/// +/// - `Main.skip/1`: minimal_ssa_skip_ws.hako +/// - `FuncScannerBox.trim/1`: funcscanner_trim_min.hako +/// - `FuncScannerBox.append_defs/2`: funcscanner_append_defs_min.hako +/// - `Stage1UsingResolverBox.resolve_for_source/5`: stage1_using_resolver minimal +/// +/// # Future +/// +/// 将来的に LoopForm/LoopScopeShape ベースの汎用判定に置き換わる予定。 +/// その時点でこのハードコードリストは削除される。 +pub(crate) fn is_case_a_minimal_target(func_name: &str) -> bool { + matches!( + func_name, + "Main.skip/1" + | "FuncScannerBox.trim/1" + | "FuncScannerBox.append_defs/2" + | "Stage1UsingResolverBox.resolve_for_source/5" + ) +} diff --git a/src/mir/join_ir/lowering/loop_scope_shape/context.rs b/src/mir/join_ir/lowering/loop_scope_shape/context.rs new file mode 100644 index 00000000..a6354dab --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/context.rs @@ -0,0 +1,107 @@ +//! CaseAContext - generic_case_a 共通ロジックの集約 + +use std::collections::BTreeMap; + +use crate::mir::join_ir::lowering::exit_args_resolver::resolve_exit_args; +use crate::mir::ValueId; + +use super::LoopScopeShape; + +/// Case A lowering の共通コンテキスト +/// +/// generic_case_a.rs の4関数に共通するロジックを集約し、 +/// 重複コードを削減する。 +#[derive(Debug, Clone)] +pub(crate) struct CaseAContext { + pub ordered_pinned: Vec, + pub ordered_carriers: Vec, + pub name_to_loop_id: BTreeMap, + pub pinned_ids: Vec, + pub carrier_ids: Vec, + pub exit_args: Vec, +} + +impl CaseAContext { + /// LoopScopeShape を直接受け取るコンストラクタ + /// + /// # Arguments + /// + /// - `scope`: LoopScopeShape（変数スコープ情報） + /// - `log_tag`: ログ出力用タグ（例: "skip_ws", "trim"） + /// - `loop_step_id_fn`: offset から ValueId を生成する関数 + /// + /// # Returns + /// + /// Some(CaseAContext) if successful, None if validation fails. + pub(crate) fn from_scope( + scope: LoopScopeShape, + log_tag: &str, + loop_step_id_fn: F, + ) -> Option + where + F: Fn(u32) -> ValueId, + { + if scope.header == scope.exit { + eprintln!( + "[joinir/generic_case_a/{}] loop_form malformed (header == exit), fallback", + log_tag + ); + return None; + } + + let ordered_pinned = scope.pinned_ordered(); + let ordered_carriers = scope.carriers_ordered(); + + let mut name_to_loop_id: BTreeMap = BTreeMap::new(); + let mut offset: u32 = 0; + for name in &ordered_pinned { + name_to_loop_id.insert(name.clone(), loop_step_id_fn(offset)); + offset += 1; + } + for name in &ordered_carriers { + name_to_loop_id.insert(name.clone(), loop_step_id_fn(offset)); + offset += 1; + } + + let pinned_ids: Vec = ordered_pinned + .iter() + .filter_map(|k| name_to_loop_id.get(k).copied()) + .collect(); + let carrier_ids: Vec = ordered_carriers + .iter() + .filter_map(|k| name_to_loop_id.get(k).copied()) + .collect(); + + let exit_args = resolve_exit_args(&scope.exit_live, &name_to_loop_id, &ordered_carriers)?; + + Some(Self { + ordered_pinned, + ordered_carriers, + name_to_loop_id, + pinned_ids, + carrier_ids, + exit_args, + }) + } + + /// 変数名から loop 関数内の ValueId を取得 + pub fn get_loop_id(&self, name: &str) -> Option { + self.name_to_loop_id.get(name).copied() + } + + /// pinned 変数の n 番目の名前を取得（なければ 0 番目を使う） + pub fn pinned_name_or_first(&self, index: usize) -> Option { + self.ordered_pinned + .get(index) + .cloned() + .or_else(|| self.ordered_pinned.first().cloned()) + } + + /// carrier 変数の n 番目の名前を取得（なければ 0 番目を使う） + pub fn carrier_name_or_first(&self, index: usize) -> Option { + self.ordered_carriers + .get(index) + .cloned() + .or_else(|| self.ordered_carriers.first().cloned()) + } +} diff --git a/src/mir/join_ir/lowering/loop_scope_shape/mod.rs b/src/mir/join_ir/lowering/loop_scope_shape/mod.rs new file mode 100644 index 00000000..31f5870a --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/mod.rs @@ -0,0 +1,19 @@ +//! LoopScopeShape - ループ変数スコープの統合ビュー +//! +//! Box化して責務を分離: +//! - `shape`: 変数分類のSSOTと質問系API +//! - `builder`: LoopForm / 既存箱からの組み立て（Case-A ルーティング含む） +//! - `case_a`: Case-A minimal ターゲット判定（Phase 30 F-3.1） +//! - `context`: generic_case_a 用の共通コンテキスト + +mod builder; +mod case_a; +mod context; +mod shape; + +pub(crate) use case_a::is_case_a_minimal_target; +pub(crate) use context::CaseAContext; +pub(crate) use shape::LoopScopeShape; + +#[cfg(test)] +mod tests; diff --git a/src/mir/join_ir/lowering/loop_scope_shape/shape.rs b/src/mir/join_ir/lowering/loop_scope_shape/shape.rs new file mode 100644 index 00000000..7b630de5 --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/shape.rs @@ -0,0 +1,129 @@ +//! LoopScopeShape 本体と分類API +//! +//! 変数分類の唯一の情報源 (SSOT) として、pinned/carrier/body_local/exit_live を保持する。 + +use std::collections::{BTreeMap, BTreeSet}; + +use crate::mir::phi_core::loop_var_classifier::LoopVarClass; +use crate::mir::BasicBlockId; + +/// ループ変数スコープの統合ビュー +/// +/// ## 4分類の定義 +/// +/// 1. **Pinned**（ループ外パラメータ） +/// - ループ開始前に定義され、ループ内で変更されない +/// - header/exit で PHI 必須 +/// +/// 2. **Carrier**（ループ更新変数） +/// - 各イテレーションで更新される +/// - header/exit で PHI 必須 +/// +/// 3. **BodyLocalExit**（全 exit 経路で定義） +/// - ループ内で定義され、全 exit predecessor で利用可能 +/// - exit で PHI 必須、header では不要 +/// +/// 4. **BodyLocalInternal**（一部 exit 経路のみ） +/// - 一部の exit predecessor でのみ定義 +/// - PHI 不要（Option C） +/// +/// # Fields +/// +/// - Block IDs: `header`, `body`, `latch`, `exit` +/// - Variable classification: `pinned`, `carriers`, `body_locals`, `exit_live` +/// - `progress_carrier`: 進捗チェック用（将来の Verifier で使用予定） +/// - `variable_definitions`: LocalScopeInspectorBox 情報統合予定（Phase 48-5+） +#[derive(Debug, Clone)] +#[allow(dead_code)] // Block IDs and progress_carrier are reserved for future F-3/F-4 use +pub(crate) struct LoopScopeShape { + pub header: BasicBlockId, + pub body: BasicBlockId, + pub latch: BasicBlockId, + pub exit: BasicBlockId, + pub pinned: BTreeSet, + pub carriers: BTreeSet, + pub body_locals: BTreeSet, + pub exit_live: BTreeSet, + pub progress_carrier: Option, + pub(crate) variable_definitions: BTreeMap>, +} + +impl LoopScopeShape { + /// header PHI が必要か判定 + #[allow(dead_code)] // Phase 30: will be used in F-3 generic lowering + pub fn needs_header_phi(&self, var_name: &str) -> bool { + self.pinned.contains(var_name) || self.carriers.contains(var_name) + } + + /// exit PHI が必要か判定 + pub fn needs_exit_phi(&self, var_name: &str) -> bool { + self.exit_live.contains(var_name) + } + + /// 順序付き pinned 変数一覧 + pub fn pinned_ordered(&self) -> Vec { + self.pinned.iter().cloned().collect() + } + + /// 順序付き carrier 変数一覧 + pub fn carriers_ordered(&self) -> Vec { + self.carriers.iter().cloned().collect() + } + + /// header PHI 対象（pinned + carriers） + #[allow(dead_code)] // Phase 30: will be used in F-3 generic lowering + pub fn header_phi_vars(&self) -> Vec { + let mut result: Vec = self.pinned.iter().cloned().collect(); + result.extend(self.carriers.iter().cloned()); + result + } + + /// exit PHI 対象 + #[allow(dead_code)] // Phase 30: will be used in F-3 generic lowering + pub fn exit_phi_vars(&self) -> Vec { + self.exit_live.iter().cloned().collect() + } + + /// 変数を4分類 + pub fn classify(&self, var_name: &str) -> LoopVarClass { + if self.pinned.contains(var_name) { + return LoopVarClass::Pinned; + } + + if self.carriers.contains(var_name) { + return LoopVarClass::Carrier; + } + + if self.body_locals.contains(var_name) { + if self.exit_live.contains(var_name) { + LoopVarClass::BodyLocalExit + } else { + LoopVarClass::BodyLocalInternal + } + } else { + LoopVarClass::BodyLocalInternal + } + } + + /// 複数変数を一括分類 + pub fn classify_all(&self, var_names: &[String]) -> Vec<(String, LoopVarClass)> { + var_names + .iter() + .map(|name| (name.clone(), self.classify(name))) + .collect() + } + + /// ループ終了時に live な変数集合を返す + pub fn get_exit_live(&self) -> &BTreeSet { + &self.exit_live + } + + /// 変数が required_blocks すべてで利用可能か判定 + pub fn is_available_in_all(&self, var_name: &str, required_blocks: &[BasicBlockId]) -> bool { + if let Some(def_blocks) = self.variable_definitions.get(var_name) { + required_blocks.iter().all(|bid| def_blocks.contains(bid)) + } else { + false + } + } +} diff --git a/src/mir/join_ir/lowering/loop_scope_shape/tests.rs b/src/mir/join_ir/lowering/loop_scope_shape/tests.rs new file mode 100644 index 00000000..0615f80c --- /dev/null +++ b/src/mir/join_ir/lowering/loop_scope_shape/tests.rs @@ -0,0 +1,459 @@ +use super::*; +use crate::mir::join_ir::lowering::loop_form_intake::LoopFormIntake; +use crate::mir::phi_core::loop_exit_liveness::LoopExitLivenessBox; +use crate::mir::phi_core::loop_var_classifier::{LoopVarClass, LoopVarClassBox}; +use crate::mir::{BasicBlockId, MirQuery, ValueId}; +use std::collections::{BTreeMap, BTreeSet}; + +fn make_dummy_loop_form() -> crate::mir::loop_form::LoopForm { + crate::mir::loop_form::LoopForm { + preheader: BasicBlockId::new(1), + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + continue_targets: vec![], + break_targets: vec![], + } +} + +fn make_dummy_intake() -> LoopFormIntake { + let mut header_snapshot = BTreeMap::new(); + header_snapshot.insert("s".to_string(), ValueId(10)); + header_snapshot.insert("n".to_string(), ValueId(20)); + header_snapshot.insert("i".to_string(), ValueId(30)); + + LoopFormIntake { + pinned_ordered: vec!["s".to_string(), "n".to_string()], + carrier_ordered: vec!["i".to_string()], + header_snapshot, + exit_snapshots: vec![], + exit_preds: vec![], + } +} + +struct EmptyQuery; +impl MirQuery for EmptyQuery { + fn insts_in_block(&self, _bb: BasicBlockId) -> &[crate::mir::MirInstruction] { + &[] + } + fn succs(&self, _bb: BasicBlockId) -> Vec { + Vec::new() + } + fn reads_of(&self, _inst: &crate::mir::MirInstruction) -> Vec { + Vec::new() + } + fn writes_of(&self, _inst: &crate::mir::MirInstruction) -> Vec { + Vec::new() + } +} + +#[test] +fn test_from_existing_boxes_basic() { + let loop_form = make_dummy_loop_form(); + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ); + + assert!(scope.is_some()); + let scope = scope.unwrap(); + + assert_eq!(scope.header, BasicBlockId::new(2)); + assert_eq!(scope.body, BasicBlockId::new(3)); + assert_eq!(scope.latch, BasicBlockId::new(4)); + assert_eq!(scope.exit, BasicBlockId::new(100)); + + assert!(scope.pinned.contains("s")); + assert!(scope.pinned.contains("n")); + assert_eq!(scope.pinned.len(), 2); + + assert!(scope.carriers.contains("i")); + assert_eq!(scope.carriers.len(), 1); + + assert_eq!(scope.progress_carrier, Some("i".to_string())); +} + +#[test] +fn test_needs_header_phi() { + let loop_form = make_dummy_loop_form(); + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ) + .unwrap(); + + assert!(scope.needs_header_phi("s")); + assert!(scope.needs_header_phi("n")); + assert!(scope.needs_header_phi("i")); + assert!(!scope.needs_header_phi("unknown")); +} + +#[test] +fn test_needs_exit_phi() { + let loop_form = make_dummy_loop_form(); + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ) + .unwrap(); + + assert!(scope.needs_exit_phi("s")); + assert!(scope.needs_exit_phi("n")); + assert!(scope.needs_exit_phi("i")); +} + +#[test] +fn test_ordered_accessors() { + let loop_form = make_dummy_loop_form(); + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ) + .unwrap(); + + let pinned = scope.pinned_ordered(); + assert_eq!(pinned.len(), 2); + assert!(pinned.contains(&"s".to_string())); + assert!(pinned.contains(&"n".to_string())); + + let carriers = scope.carriers_ordered(); + assert_eq!(carriers.len(), 1); + assert!(carriers.contains(&"i".to_string())); +} + +/// CaseAContext::from_scope で header == exit のとき None を返すテスト +#[test] +fn test_from_scope_validation_header_eq_exit() { + use crate::mir::join_ir::lowering::value_id_ranges::skip_ws as vid; + + let scope = LoopScopeShape { + header: BasicBlockId::new(10), + body: BasicBlockId::new(11), + latch: BasicBlockId::new(12), + exit: BasicBlockId::new(10), + pinned: vec!["s".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: BTreeSet::new(), + exit_live: vec!["i".to_string()].into_iter().collect(), + progress_carrier: Some("i".to_string()), + variable_definitions: BTreeMap::new(), + }; + + let ctx = CaseAContext::from_scope(scope, "test", |offset| vid::loop_step(offset)); + assert!( + ctx.is_none(), + "from_scope should return None when header == exit" + ); +} + +/// block IDs が LoopForm から正しく伝播されるテスト +#[test] +fn test_block_ids_preserved() { + let loop_form = crate::mir::loop_form::LoopForm { + preheader: BasicBlockId::new(100), + header: BasicBlockId::new(200), + body: BasicBlockId::new(300), + latch: BasicBlockId::new(400), + exit: BasicBlockId::new(500), + continue_targets: vec![], + break_targets: vec![], + }; + + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ) + .unwrap(); + + assert_eq!(scope.header, BasicBlockId::new(200)); + assert_eq!(scope.body, BasicBlockId::new(300)); + assert_eq!(scope.latch, BasicBlockId::new(400)); + assert_eq!(scope.exit, BasicBlockId::new(500)); +} + +/// BTreeSet による順序決定性の確認テスト +#[test] +fn test_deterministic_order() { + let mut set1: BTreeSet = BTreeSet::new(); + set1.insert("z".to_string()); + set1.insert("a".to_string()); + set1.insert("m".to_string()); + + let mut set2: BTreeSet = BTreeSet::new(); + set2.insert("m".to_string()); + set2.insert("z".to_string()); + set2.insert("a".to_string()); + + let vec1: Vec<_> = set1.iter().cloned().collect(); + let vec2: Vec<_> = set2.iter().cloned().collect(); + + assert_eq!(vec1, vec2); + assert_eq!( + vec1, + vec!["a".to_string(), "m".to_string(), "z".to_string()] + ); +} + +/// needs_header_phi と needs_exit_phi の一貫性テスト +#[test] +fn test_needs_phi_consistency() { + let loop_form = make_dummy_loop_form(); + let intake = make_dummy_intake(); + let var_classes = LoopVarClassBox::new(); + let exit_live_box = LoopExitLivenessBox::new(); + let query = EmptyQuery; + + let scope = LoopScopeShape::from_existing_boxes( + &loop_form, + &intake, + &var_classes, + &exit_live_box, + &query, + None, + ) + .unwrap(); + + for var in &scope.pinned { + assert!( + scope.needs_header_phi(var), + "pinned var {} should need header phi", + var + ); + assert!( + scope.needs_exit_phi(var), + "pinned var {} should need exit phi", + var + ); + } + + for var in &scope.carriers { + assert!( + scope.needs_header_phi(var), + "carrier var {} should need header phi", + var + ); + assert!( + scope.needs_exit_phi(var), + "carrier var {} should need exit phi", + var + ); + } + + for var in &scope.body_locals { + assert!( + !scope.needs_header_phi(var), + "body_local var {} should NOT need header phi", + var + ); + } +} + +/// classify() メソッドのテスト +#[test] +fn test_classify_method() { + let scope = LoopScopeShape { + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + pinned: vec!["s".to_string(), "n".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: vec!["x".to_string(), "ch".to_string()] + .into_iter() + .collect(), + exit_live: vec![ + "s".to_string(), + "n".to_string(), + "i".to_string(), + "x".to_string(), + ] + .into_iter() + .collect(), + progress_carrier: Some("i".to_string()), + variable_definitions: BTreeMap::new(), + }; + + assert_eq!(scope.classify("s"), LoopVarClass::Pinned); + assert_eq!(scope.classify("n"), LoopVarClass::Pinned); + assert_eq!(scope.classify("i"), LoopVarClass::Carrier); + assert_eq!(scope.classify("x"), LoopVarClass::BodyLocalExit); + assert_eq!(scope.classify("ch"), LoopVarClass::BodyLocalInternal); + assert_eq!(scope.classify("unknown"), LoopVarClass::BodyLocalInternal); +} + +/// classify() と needs_*_phi() の一貫性 +#[test] +fn test_classify_phi_consistency() { + let scope = LoopScopeShape { + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + pinned: vec!["s".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: vec!["x".to_string(), "ch".to_string()] + .into_iter() + .collect(), + exit_live: vec!["s".to_string(), "i".to_string(), "x".to_string()] + .into_iter() + .collect(), + progress_carrier: Some("i".to_string()), + variable_definitions: BTreeMap::new(), + }; + + for var in ["s", "i", "x", "ch", "unknown"] { + let class = scope.classify(var); + assert_eq!( + class.needs_header_phi(), + scope.needs_header_phi(var), + "classify and needs_header_phi mismatch for {}", + var + ); + assert_eq!( + class.needs_exit_phi(), + scope.needs_exit_phi(var), + "classify and needs_exit_phi mismatch for {}", + var + ); + } +} + +/// get_exit_live() API テスト +#[test] +fn test_get_exit_live() { + let scope = LoopScopeShape { + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + pinned: vec!["s".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: BTreeSet::new(), + exit_live: vec!["s".to_string(), "i".to_string()].into_iter().collect(), + progress_carrier: Some("i".to_string()), + variable_definitions: BTreeMap::new(), + }; + + let exit_live = scope.get_exit_live(); + assert_eq!(exit_live.len(), 2); + assert!(exit_live.contains("s")); + assert!(exit_live.contains("i")); +} + +/// Phase 48-4: is_available_in_all() API テスト（空の variable_definitions） +#[test] +fn test_is_available_in_all_phase48_4() { + // Phase 48-4: variable_definitions が空のため常に false + let scope = LoopScopeShape { + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + pinned: vec!["s".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: BTreeSet::new(), + exit_live: vec!["s".to_string(), "i".to_string()].into_iter().collect(), + progress_carrier: Some("i".to_string()), + variable_definitions: BTreeMap::new(), // Phase 48-4: 空で初期化 + }; + + // variable_definitions が空のため、すべて false を返す + assert!(!scope.is_available_in_all("x", &[BasicBlockId::new(3)])); + assert!(!scope.is_available_in_all("i", &[BasicBlockId::new(3)])); + assert!(!scope.is_available_in_all("unknown", &[BasicBlockId::new(3)])); +} + +/// Phase 48-5+ 想定: is_available_in_all() with variable_definitions +#[test] +fn test_is_available_in_all_phase48_5_future() { + // Phase 48-5+ で variable_definitions が統合された状態をシミュレート + let mut variable_definitions = BTreeMap::new(); + variable_definitions.insert( + "x".to_string(), + vec![BasicBlockId::new(3), BasicBlockId::new(4)] + .into_iter() + .collect(), + ); + variable_definitions.insert( + "i".to_string(), + vec![BasicBlockId::new(2), BasicBlockId::new(3), BasicBlockId::new(4)] + .into_iter() + .collect(), + ); + + let scope = LoopScopeShape { + header: BasicBlockId::new(2), + body: BasicBlockId::new(3), + latch: BasicBlockId::new(4), + exit: BasicBlockId::new(100), + pinned: vec!["s".to_string()].into_iter().collect(), + carriers: vec!["i".to_string()].into_iter().collect(), + body_locals: vec!["x".to_string()].into_iter().collect(), + exit_live: vec!["s".to_string(), "i".to_string(), "x".to_string()] + .into_iter() + .collect(), + progress_carrier: Some("i".to_string()), + variable_definitions, // Phase 48-5+ で統合された状態 + }; + + // x は block 3, 4 で定義 → block 3, 4 を要求すれば true + assert!(scope.is_available_in_all("x", &[BasicBlockId::new(3), BasicBlockId::new(4)])); + + // x は block 2 で未定義 → block 2, 3 を要求すれば false + assert!(!scope.is_available_in_all("x", &[BasicBlockId::new(2), BasicBlockId::new(3)])); + + // i は block 2, 3, 4 で定義 → すべて要求しても true + assert!(scope.is_available_in_all( + "i", + &[BasicBlockId::new(2), BasicBlockId::new(3), BasicBlockId::new(4)] + )); + + // unknown は variable_definitions にない → false + assert!(!scope.is_available_in_all("unknown", &[BasicBlockId::new(3)])); +}