jit: publish the vable promote snapshots in emission order, and fix the four callers the enum broke

`capture_vable_promote_guard` walked `0..minted`, newest guard first.
`publish_last_guard_resume_snapshot` is not side-effect free -- it leaves the
root frame's in-flight result slot cleared (`root_inflight_int_result`) -- so
the order decides what the earlier guard's snapshot sees. `generate_guard`
(pyjitpl.py:2582-2603) captures each guard synchronously as it is emitted, so
the loop runs oldest-first.

The `bool -> VableArrayStore` return also broke four `assert!` call sites in
`pyre-jit-trace`'s test module, which a release binary build and
`cargo test -p majit-metainterp` both compile past; `cargo check --workspace
--all-targets` is what reports them. `VableArrayStore` is re-exported from the
crate root so the external test can name it.

The doc comment claimed pyre's two snapshots match what upstream would produce.
They do not: `MetaInterp.replace_box` walks the framestack
(`frame.replace_active_box_in_frame`) and `TraceCtx::replace_box` does not, so
upstream's second capture would see the standard box. Stated as the pre-existing
gap it is.

Assisted-by: Claude

Author: youknowone

majit/majit-metainterp/src/lib.rs

@@ -171,6 +171,7 @@ pub use trace_ctx::GreenBox;
 pub use trace_ctx::MergePoint;
 pub use trace_ctx::ReconstructRecipe;
 pub use trace_ctx::TraceCtx;
+pub use trace_ctx::VableArrayStore;
 
 /// Compute green key from code pointer and PC.
 /// Must use the same hash as the front-end's make_green_key — the full

majit/majit-metainterp/src/pyjitpl/dispatch.rs

@@ -1487,10 +1487,14 @@ where
     /// One call can emit TWO: a vable array access whose symbolic frame box
     /// differs from the standard box but shares its pointer promotes the
     /// `isstandard` PTR_EQ and then the index, so every guard the call added is
-    /// stamped, not just the last.  Both take the same snapshot content, which
-    /// is what the two upstream `capture_resumedata` calls would produce here:
-    /// what runs between them is `replace_box`, and pyre's does not carry the
-    /// framestack walk (`TraceCtx::replace_box`).
+    /// stamped, not just the last. In pyre the two snapshots currently come
+    /// out identical because `TraceCtx::replace_box` updates the side tables
+    /// but not the live `MIFrame`s; this is a pre-existing gap, not parity:
+    /// upstream `MetaInterp.replace_box` walks the framestack via
+    /// `frame.replace_active_box_in_frame`, so its second capture sees the
+    /// standard box where the first saw the old one. The loop runs in emission
+    /// order because each capture leaves the root frame's in-flight result slot
+    /// cleared.
     ///
     /// `write` is the shadow slot a `vable_set*` overwrote. Upstream reaches
     /// `virtualizable_boxes[index] = valuebox` only after both promotes have
@@ -1524,7 +1528,7 @@ where
             ctx.swap_virtualizable_entry(w.index, w.prev_box, w.prev_value)
                 .map(|current| (w.index, current))
         });
-        for from_end in 0..minted {
+        for from_end in (0..minted).rev() {
             self.publish_last_guard_resume_snapshot(
                 ctx,
                 sym,

pyre/pyre-jit-trace/src/jitcode_dispatch/tests.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::jitcode_runtime::{insns_opname_to_byte, named_jitcode};
 use majit_ir::Type;
-use majit_metainterp::make_fail_descr;
+use majit_metainterp::{VableArrayStore, make_fail_descr};
 
 #[test]
 fn propagated_subwalk_abort_cannot_rebind_its_pc_to_a_caller_frame() {
@@ -570,16 +570,19 @@ fn vable_store_tracks_live_null_without_changing_the_recorded_trace() {
     let index0 = tc.const_int(0);
     let const_null = tc.const_null();
     let ops_before = tc.num_ops();
-    assert!(tc.vable_setarrayitem_indexed(
-        0,
-        vable,
-        index0,
-        0,
-        fdescr.clone(),
-        adescr.clone(),
-        const_null,
-        null,
-        true,
+    assert!(matches!(
+        tc.vable_setarrayitem_indexed(
+            0,
+            vable,
+            index0,
+            0,
+            fdescr.clone(),
+            adescr.clone(),
+            const_null,
+            null,
+            true,
+        ),
+        VableArrayStore::Stored(_)
     ));
     assert!(tc.virtualizable_slot_stored_live_null(flat_base));
     assert!(
@@ -598,37 +601,44 @@ fn vable_store_tracks_live_null_without_changing_the_recorded_trace() {
         "the side-table marker records no op"
     );
 
-    assert!(tc.vable_setarrayitem_indexed(
-        0,
-        vable,
-        index0,
-        0,
-        fdescr.clone(),
-        adescr.clone(),
-        const_null,
-        null,
-        false,
+    assert!(matches!(
+        tc.vable_setarrayitem_indexed(
+            0,
+            vable,
+            index0,
+            0,
+            fdescr.clone(),
+            adescr.clone(),
+            const_null,
+            null,
+            false,
+        ),
+        VableArrayStore::Stored(_)
     ));
     assert!(!tc.virtualizable_slot_stored_live_null(flat_base));
 
     let index1 = tc.const_int(1);
     let non_null = tc.const_ref(2);
-    assert!(tc.vable_setarrayitem_indexed(
-        0,
-        vable,
-        index1,
-        1,
-        fdescr.clone(),
-        adescr.clone(),
-        non_null,
-        Value::Ref(majit_ir::GcRef(2)),
-        true,
+    assert!(matches!(
+        tc.vable_setarrayitem_indexed(
+            0,
+            vable,
+            index1,
+            1,
+            fdescr.clone(),
+            adescr.clone(),
+            non_null,
+            Value::Ref(majit_ir::GcRef(2)),
+            true,
+        ),
+        VableArrayStore::Stored(_)
     ));
     assert!(!tc.virtualizable_slot_stored_live_null(flat_base + 1));
 
-    assert!(
-        tc.vable_setarrayitem_indexed(0, vable, index0, 0, fdescr, adescr, const_null, null, true,)
-    );
+    assert!(matches!(
+        tc.vable_setarrayitem_indexed(0, vable, index0, 0, fdescr, adescr, const_null, null, true,),
+        VableArrayStore::Stored(_)
+    ));
     assert!(tc.virtualizable_slot_stored_live_null(flat_base));
     tc.set_virtualizable_entry_at(flat_base, const_null, null);
     assert!(!tc.virtualizable_slot_stored_live_null(flat_base));