Stabilize joinir tests and env guards

src/mir/builder/phi_observation_tests.rs

@@ -0,0 +1,105 @@
+use crate::mir::builder::MirBuilder;
+use crate::mir::join_ir::verify_phi_reserved::{
+    analyze_distribution, disable_observation, enable_observation, get_observations,
+};
+use crate::mir::types::ConstValue;
+use crate::mir::MirInstruction;
+
+/// Phase 72-1: Observe PHI dst distribution from MirBuilder usage
+///
+/// This test manually creates MIR scenarios to observe PHI dst allocation.
+#[test]
+fn test_phase72_observe_phi_dst_via_builder() {
+    enable_observation();
+
+    // Create multiple builders to simulate different compilation contexts
+    for scenario in 0..10 {
+        let mut builder = MirBuilder::new();
+        builder.enter_function_for_test(format!("test_func_{}", scenario));
+
+        // Allocate some values (simulating loop setup)
+        let _entry_block = builder.current_block_for_test().expect("entry block");
+
+        // Simulate loop header block
+        builder.push_block_for_test().expect("push block");
+        let _header_block = builder.current_block_for_test().expect("header block");
+
+        // Allocate initial values
+        let v1 = builder.alloc_value_for_test();
+        let v2 = builder.alloc_value_for_test();
+        let v3 = builder.alloc_value_for_test();
+
+        // Emit some instructions
+        builder
+            .emit_for_test(MirInstruction::Const {
+                dst: v1,
+                value: ConstValue::Integer(0),
+            })
+            .expect("emit const v1");
+        builder
+            .emit_for_test(MirInstruction::Const {
+                dst: v2,
+                value: ConstValue::Integer(100),
+            })
+            .expect("emit const v2");
+        builder
+            .emit_for_test(MirInstruction::Const {
+                dst: v3,
+                value: ConstValue::Integer(1),
+            })
+            .expect("emit const v3");
+
+        // Now allocate PHI dst candidates (what would be PHI dsts)
+        // These come from builder.next_value_id() in loop_header_phi_builder
+        let phi_dst_1 = builder.alloc_value_for_test();
+        let phi_dst_2 = builder.alloc_value_for_test();
+        let phi_dst_3 = builder.alloc_value_for_test();
+
+        // Manually observe these as if they were PHI dsts
+        #[cfg(debug_assertions)]
+        {
+            crate::mir::join_ir::verify_phi_reserved::observe_phi_dst(phi_dst_1);
+            crate::mir::join_ir::verify_phi_reserved::observe_phi_dst(phi_dst_2);
+            crate::mir::join_ir::verify_phi_reserved::observe_phi_dst(phi_dst_3);
+        }
+
+        builder.exit_function_for_test();
+    }
+
+    // Collect observations
+    let observations = get_observations();
+    let report = analyze_distribution(&observations);
+
+    eprintln!("\n========== Phase 72: PHI dst Distribution Analysis ==========");
+    eprintln!("{}", report.summary());
+    eprintln!();
+    eprintln!("Detailed breakdown:");
+    eprintln!(
+        "  - Reserved region (0-99):   {} PHI dsts",
+        report.in_reserved
+    );
+    eprintln!("  - Param region (100-999):   {} PHI dsts", report.in_param);
+    eprintln!("  - Local region (1000+):     {} PHI dsts", report.in_local);
+    eprintln!();
+
+    if report.is_all_reserved() {
+        eprintln!("OK: CONCLUSION: All PHI dsts are in reserved region (0-99)");
+        eprintln!("   -> Safe to strengthen verifier with reserved region check");
+    } else {
+        eprintln!("WARN: CONCLUSION: Some PHI dsts are OUTSIDE reserved region");
+        eprintln!("   -> PHI dst allocation does NOT respect reserved boundary");
+        eprintln!("   -> Document this finding and skip verifier strengthening");
+
+        if let (Some(min), Some(max)) = (report.min_val, report.max_val) {
+            eprintln!();
+            eprintln!("Observed range: [{}, {}]", min, max);
+            eprintln!("Expected range: [0, 99]");
+        }
+    }
+    eprintln!("==============================================================\n");
+
+    disable_observation();
+
+    // This test always passes - it's for observation and decision-making
+    assert!(true, "Observation complete - see output above for analysis");
+}