feat(test): receipt-driven normalise filter replaces hardcoded rules

The normalise filter now reads the companion *.smir.receipts.json
(emitted by the spy serializer) and applies three generic passes:
interned_keys are deleted, interned_newtypes are zeroed, and
interned_positions are zeroed. No more per-field jq rules for the
body tree.

All three receipt categories are pre-seeded with known interned
paths, and the spy adds more dynamically as it discovers them.
The seeding turns out to be critical: upstream's serialize_index_impl!
macro provides a custom Serialize impl for interned types (Ty, Span,
DefId, AllocId, etc.) that serializes them as bare integers via
Serialize::serialize(&n, serializer), completely erasing the type
name. The spy never sees serialize_newtype_struct or
serialize_tuple_struct for these types; it just sees a u64. So the
spy's dynamic discovery is blind to the most important interned
types, and the seeded values carry all the weight.

The spy still adds value for discovering interned paths in types that
DO preserve their names through serde (e.g. GenericArgs, ClosureDef),
but the baseline coverage comes from the seed lists.

Author: cds-amal

Makefile

@@ -69,7 +69,7 @@ GOLDEN_DIR     := $(shell \
 integration-test: TESTS     ?= $(shell find $(TESTDIR) -type f -name "*.rs")
 integration-test: SMIR      ?= cargo run -- "-Zno-codegen"
 # override this to tweak how expectations are formatted
-integration-test: NORMALIZE ?= jq -S -e -f $(TESTDIR)/../normalise-filter.jq
+integration-test: FILTER    ?= $(TESTDIR)/../normalise-filter.jq
 # override this to re-make golden files
 integration-test: DIFF      ?= | diff -
 ## Run integration tests against expected outputs
@@ -79,14 +79,15 @@ integration-test:
 	report() { echo "$$1: $$2"; errors="$$errors\n$$1: $$2"; }; \
 	for rust in $(TESTS); do \
 		target=$${rust%.rs}.smir.json; \
+		receipts=$${target%.json}.receipts.json; \
 		name=$$(basename $${rust%.rs}); \
 		dir=$$(dirname $${rust}); \
 		expected="$(GOLDEN_DIR)/$${name}.smir.json.expected"; \
 		echo "$$rust"; \
 		$(SMIR) --out-dir $${dir} $${rust} || report "$$rust" "Conversion failed"; \
 		[ -f $${target} ] \
-			&& $(NORMALIZE) $${target} $(DIFF) $${expected} \
-			&& rm $${target} \
+			&& jq -S -e --slurpfile receipts $${receipts} -f $(FILTER) $${target} $(DIFF) $${expected} \
+			&& rm -f $${target} $${receipts} \
 			|| report "$$rust" "Unexpected json output"; \
 		done; \
 	[ -z "$$errors" ] || (echo "===============\nFAILING TESTS:$$errors"; exit 1)

src/printer/receipts.rs

@@ -36,6 +36,35 @@ const INTERNED_TYPES: &[&str] = &[
     "VariantIdx",
 ];
 
+// Interned key names that always need normalizing, regardless of whether
+// the spy encounters them in a particular program's output.  These fields
+// carry interned indices used as cross-reference keys by downstream tools
+// (joining AggregateKind::Adt in MIR bodies with type metadata entries,
+// etc.), so they can't be dropped from the output itself; they're only
+// stripped for golden-file comparison.
+//
+// The spy may miss them because (a) the program under test doesn't
+// exercise the code path that produces them, or (b) the DefId is wrapped
+// in a domain-specific newtype (TraitDef, StaticDef, ClosureDef) that's
+// transparent in JSON but opaque to the spy's immediate-parent check.
+const SEEDED_INTERNED_KEYS: &[&str] = &[
+    "def_id", "adt_def", "ty", "span", "id", "alloc_id",
+];
+
+// Interned newtype wrappers that always need normalizing.  On newer
+// nightlies the serialize_index_impl! macro serializes interned types
+// as bare integers, so the spy can't discover these dynamically.
+const SEEDED_INTERNED_NEWTYPES: &[&str] = &["Type", "Array"];
+
+// Interned positions that always need normalizing.
+const SEEDED_INTERNED_POSITIONS: &[(&str, &[usize])] = &[
+    ("Field", &[1]),
+    ("Cast", &[2]),
+    ("Closure", &[0]),
+    ("VTable", &[0]),
+    ("Adt", &[0]),
+];
+
 // ── Receipt output ──────────────────────────────────────────────────────────
 
 /// Schema-level receipt of where interned indices appear in the JSON output.
@@ -84,12 +113,19 @@ struct Tracker {
 
 impl Tracker {
     fn new() -> Self {
+        let mut positions = BTreeMap::new();
+        for (name, idxs) in SEEDED_INTERNED_POSITIONS {
+            positions
+                .entry(name.to_string())
+                .or_insert_with(BTreeSet::new)
+                .extend(idxs.iter().copied());
+        }
         Self {
             context: vec![ParentKind::Root],
             interned_names: INTERNED_TYPES.iter().copied().collect(),
-            keys: BTreeSet::new(),
-            newtypes: BTreeSet::new(),
-            positions: BTreeMap::new(),
+            keys: SEEDED_INTERNED_KEYS.iter().map(|s| s.to_string()).collect(),
+            newtypes: SEEDED_INTERNED_NEWTYPES.iter().map(|s| s.to_string()).collect(),
+            positions,
         }
     }
 
@@ -128,11 +164,7 @@ impl Tracker {
         Receipts {
             interned_keys: self.keys,
             interned_newtypes: self.newtypes,
-            interned_positions: self
-                .positions
-                .into_iter()
-                .map(|(k, v)| (k, v))
-                .collect(),
+            interned_positions: self.positions,
         }
     }
 }
@@ -312,6 +344,19 @@ impl ser::Serializer for SpySerializer {
         name: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        // On newer nightlies (post-ThreadLocalIndex), interned types like
+        // Ty(usize, ThreadLocalIndex) serialize as tuple structs instead of
+        // newtype structs.  Detect them the same way we detect newtypes.
+        {
+            let tracker = self.tracker.borrow();
+            if tracker.interned_names.contains(name) {
+                drop(tracker);
+                self.tracker.borrow_mut().record_interned();
+                // Return a compound that ignores its fields; we've already
+                // recorded the finding and don't need to recurse deeper.
+                return Ok(SpyCompound::new(self.tracker, "", false));
+            }
+        }
         Ok(SpyCompound::new(self.tracker, name, false))
     }
 
@@ -608,5 +653,38 @@ mod tests {
             "expected Cast[2] in interned_positions, got: {:?}",
             receipts.interned_positions
         );
+
+        // Seeded values should always be present, even if the test type
+        // doesn't exercise the code paths that produce them.
+        for key in SEEDED_INTERNED_KEYS {
+            assert!(
+                receipts.interned_keys.contains(*key),
+                "expected seeded key '{}' in interned_keys, got: {:?}",
+                key,
+                receipts.interned_keys
+            );
+        }
+        for nt in SEEDED_INTERNED_NEWTYPES {
+            assert!(
+                receipts.interned_newtypes.contains(*nt),
+                "expected seeded newtype '{}' in interned_newtypes, got: {:?}",
+                nt,
+                receipts.interned_newtypes
+            );
+        }
+        for (name, idxs) in SEEDED_INTERNED_POSITIONS {
+            for idx in *idxs {
+                assert!(
+                    receipts
+                        .interned_positions
+                        .get(*name)
+                        .map_or(false, |s| s.contains(idx)),
+                    "expected seeded position {}[{}] in interned_positions, got: {:?}",
+                    name,
+                    idx,
+                    receipts.interned_positions
+                );
+            }
+        }
     }
 }

tests/integration/expected/nightly-2026-01-15/static-vtable-nonbuiltin-deref.smir.json.expected

@@ -8,7 +8,7 @@
     {
       "global_alloc": {
         "VTable": [
-          11,
+          0,
           {
             "bound_vars": [],
             "value": {

tests/integration/normalise-filter.jq

@@ -1,10 +1,30 @@
+# normalise-filter.jq
+#
+# Normalizes *.smir.json output for golden-file comparison.  Interned
+# indices (Ty, Span, DefId, etc.) are non-deterministic across platforms
+# and runs; we strip or zero them so that cross-platform diffs are clean.
+#
+# This filter reads a companion receipts file ($receipts) that declares
+# which JSON paths carry interned indices.  See ADR-004 for the design.
+#
+# The receipts cover the Body tree (where the whack-a-mole problem lives);
+# top-level array transformations below are structural and stay explicit.
+
+# ── Hash stripping ──────────────────────────────────────────────────────
+#
 # Strip platform-specific crate hashes from mangled symbol names.
 # Legacy mangling (_ZN...): hash is always the trailing 17 chars (16 hex + "h" prefix).
 # v0 mangling (_R...): crate disambiguators appear as C<base62>_ throughout the symbol;
 # replace each with "C_" to normalize across platforms.
 def strip_hashes:
     if startswith("_R") then gsub("C[a-zA-Z0-9]+_(?=[0-9])"; "C_")
     else .[:-17] end;
+
+# ── Top-level structural transforms ─────────────────────────────────────
+#
+# These operate on the SmirJson arrays directly and are unrelated to the
+# walk-based interned-index normalization that the receipts drive.
+
 .functions = ( [ .functions[] | if .[1].NormalSym then .[1].NormalSym = (.[1].NormalSym | strip_hashes) else .  end ] )
     | .items = ( [ .items[] | if .symbol_name then .symbol_name = (.symbol_name | strip_hashes) else .  end ] )
 # delete unstable alloc, function, and type IDs
@@ -14,30 +34,12 @@ def strip_hashes:
 # remove "Never" type
     | .types = ( [ .types[] ] | map(select(.[0] != "VoidType")) )
     |
-# Apply the normalisation filter
+
+# ── Restructure and sort ────────────────────────────────────────────────
+
 { allocs:    ( .allocs | sort ),
   functions: (.functions | sort ),
-  items:     (.items | map(walk(
-               if type == "object" then del(.ty)
-               # Several array-encoded constructs embed interned Ty or DefId
-               # indices as bare integers at known positions. Normalize each:
-               #   Field[1]     - Ty index in field projections
-               #   Cast[2]      - Ty index (target type of a cast)
-               #   Closure[0]   - DefId index
-               #   VTable[0]    - Ty index
-               #   Adt[0]       - AdtDef index
-               | if .Field   then .Field[1]   = 0 else . end
-               | if .Cast    then .Cast[2]    = 0 else . end
-               | if .Closure then .Closure[0] = 0 else . end
-               | if .VTable  then .VTable[0]  = 0 else . end
-               | if .Adt     then .Adt[0]     = 0 else . end
-               # {"Type": <int>} wrappers carry interned Ty indices (e.g. inside
-               # Closure aggregate kinds). Normalize to 0.
-               | if .Type and (.Type | type) == "number" then .Type = 0 else . end
-               # {"Array": <int>} is a bare Ty index; {"Array": {count,stride}}
-               # is a layout descriptor. Only normalize the integer form.
-               | if .Array and (.Array | type) == "number" then .Array = 0 else . end
-               else . end)) | sort_by(.symbol_name + "|" + (.mono_item_kind.MonoItemFn.name // "")) ),
+  items:     (.items | sort_by(.symbol_name + "|" + (.mono_item_kind.MonoItemFn.name // "")) ),
   types: ( [
 # sort by constructors and remove unstable IDs within each
     ( .types | map(select(.[0].PrimitiveType)) | sort ),
@@ -55,10 +57,26 @@ def strip_hashes:
     ( .types | map(select(.[0].FunType) | sort) )
   ] | flatten(1) )
 }
-# Strip interned index fields globally: def_id (AdtDef indices), id
-# (MonoItemFn and const_ interned IDs), and span (interned Span indices).
-# These are consistent within a single rustc invocation but not stable
-# across runs or platforms; the same non-determinism that affects alloc_id,
-# Ty indices, and adt_def (see lines 5-6, 18-21 above). We only strip
-# them here for golden-file comparison.
-| walk(if type == "object" then del(.def_id) | del(.id) | del(.span) else . end)
+
+# ── Receipt-driven interned-index normalization ─────────────────────────
+#
+# Instead of hardcoding per-field rules, we read the receipts and apply
+# three generic passes:
+#
+#   1. interned_keys:      delete object fields whose values are interned
+#   2. interned_newtypes:  zero enum-variant wrappers around bare integers
+#   3. interned_positions: zero known tuple positions carrying interned indices
+
+| walk(if type == "object" then
+    # 1. Strip interned key fields (e.g. "span", "ty", "def_id", "id")
+    reduce ($receipts[0].interned_keys[]) as $k (.; del(.[$k]))
+    # 2. Zero interned newtype wrappers (e.g. {"Type": 42} → {"Type": 0})
+  | reduce ($receipts[0].interned_newtypes[]) as $n (.;
+      if .[$n] and (.[$n] | type) == "number" then .[$n] = 0 else . end)
+    # 3. Zero interned positions in tuple variants (e.g. Cast[2], Field[1])
+  | reduce ($receipts[0].interned_positions | to_entries[]) as $e (.;
+      if .[$e.key] and (.[$e.key] | type) == "array" then
+        reduce ($e.value[]) as $p (.;
+          if .[$e.key][$p] then .[$e.key][$p] = 0 else . end)
+      else . end)
+  else . end)