Add erase_alloc_id method to various Miri primitives

This method is based on `erase_tag`, and replaces `AllocId`s with `()`.

Author: ecstatic-morse

src/librustc/mir/interpret/pointer.rs

@@ -201,6 +201,13 @@ impl<'tcx, Tag> Pointer<Tag> {
         Pointer { alloc_id: self.alloc_id, offset: self.offset, tag: () }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> Pointer<Tag, ()> {
+        Pointer { alloc_id: (), offset: self.offset, tag: self.tag }
+    }
+
     /// Test if the pointer is "inbounds" of an allocation of the given size.
     /// A pointer is "inbounds" even if its offset is equal to the size; this is
     /// a "one-past-the-end" pointer.

src/librustc/mir/interpret/value.rs

@@ -153,6 +153,16 @@ impl<'tcx, Tag> Scalar<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> Scalar<Tag, ()> {
+        match self {
+            Scalar::Ptr(ptr) => Scalar::Ptr(ptr.erase_alloc_id()),
+            Scalar::Raw { data, size } => Scalar::Raw { data, size },
+        }
+    }
+
     #[inline]
     pub fn ptr_null(cx: &impl HasDataLayout) -> Self {
         Scalar::Raw {
@@ -509,6 +519,16 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> ScalarMaybeUndef<Tag, ()> {
+        match self {
+            ScalarMaybeUndef::Scalar(s) => ScalarMaybeUndef::Scalar(s.erase_alloc_id()),
+            ScalarMaybeUndef::Undef => ScalarMaybeUndef::Undef,
+        }
+    }
+
     #[inline]
     pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
         match self {

src/librustc_mir/interpret/operand.rs

@@ -91,6 +91,17 @@ impl<'tcx, Tag> Immediate<Tag> {
             Immediate::ScalarPair(a, b) => Ok((a.not_undef()?, b.not_undef()?))
         }
     }
+
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub(super) fn erase_alloc_id(self) -> Immediate<Tag, ()> {
+        match self {
+            Immediate::Scalar(a) => Immediate::Scalar(a.erase_alloc_id()),
+            Immediate::ScalarPair(a, b)
+                => Immediate::ScalarPair(a.erase_alloc_id(), b.erase_alloc_id()),
+        }
+    }
 }
 
 // ScalarPair needs a type to interpret, so we often have an immediate and a type together
@@ -176,6 +187,16 @@ impl<Tag> Operand<Tag> {
 
         }
     }
+
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub(super) fn erase_alloc_id(self) -> Operand<Tag, ()> {
+        match self {
+            Operand::Immediate(imm) => Operand::Immediate(imm.erase_alloc_id()),
+            Operand::Indirect(place) => Operand::Indirect(place.erase_alloc_id()),
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]

src/librustc_mir/interpret/place.rs

@@ -105,6 +105,17 @@ impl<Tag> MemPlace<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> MemPlace<Tag, ()> {
+        MemPlace {
+            ptr: self.ptr.erase_alloc_id(),
+            align: self.align,
+            meta: self.meta.map(Scalar::erase_alloc_id),
+        }
+    }
+
     #[inline(always)]
     pub fn from_scalar_ptr(ptr: Scalar<Tag>, align: Align) -> Self {
         MemPlace {