Consolidate tagged pointer abstractions and make them covariant

Author: BoxyUwU

compiler/rustc_data_structures/src/marker.rs

@@ -72,7 +72,7 @@ impl_dyn_send!(
     [Vec<T, A> where T: DynSend, A: std::alloc::Allocator + DynSend]
     [Box<T, A> where T: ?Sized + DynSend, A: std::alloc::Allocator + DynSend]
     [crate::sync::RwLock<T> where T: DynSend]
-    [crate::tagged_ptr::CopyTaggedPtr<P, T, CP> where P: Send + crate::tagged_ptr::Pointer, T: Send + crate::tagged_ptr::Tag, const CP: bool]
+    [crate::tagged_ptr::TaggedPtr<P, P::Target, T, CP> where P: Send + crate::tagged_ptr::Pointer<Target: Sized>, T: Send + crate::tagged_ptr::Tag, const CP: bool]
     [rustc_arena::TypedArena<T> where T: DynSend]
     [indexmap::IndexSet<V, S> where V: DynSend, S: DynSend]
     [indexmap::IndexMap<K, V, S> where K: DynSend, V: DynSend, S: DynSend]
@@ -148,7 +148,7 @@ impl_dyn_sync!(
     [crate::sync::RwLock<T> where T: DynSend + DynSync]
     [crate::sync::WorkerLocal<T> where T: DynSend]
     [crate::intern::Interned<'a, T> where 'a, T: DynSync]
-    [crate::tagged_ptr::CopyTaggedPtr<P, T, CP> where P: Sync + crate::tagged_ptr::Pointer, T: Sync + crate::tagged_ptr::Tag, const CP: bool]
+    [crate::tagged_ptr::TaggedPtr<P, P::Target, T, CP> where P: Sync + crate::tagged_ptr::Pointer<Target: Sized>, T: Sync + crate::tagged_ptr::Tag, const CP: bool]
     [parking_lot::lock_api::Mutex<R, T> where R: DynSync, T: ?Sized + DynSend]
     [parking_lot::lock_api::RwLock<R, T> where R: DynSync, T: ?Sized + DynSend + DynSync]
     [indexmap::IndexSet<V, S> where V: DynSync, S: DynSync]

compiler/rustc_data_structures/src/tagged_ptr.rs

@@ -22,12 +22,10 @@ use std::sync::Arc;
 
 use crate::aligned::Aligned;
 
-mod copy;
-mod drop;
+mod covariant;
 mod impl_tag;
 
-pub use copy::CopyTaggedPtr;
-pub use drop::TaggedPtr;
+pub use covariant::TaggedPtr;
 
 /// This describes the pointer type encapsulated by [`TaggedPtr`] and
 /// [`CopyTaggedPtr`].
@@ -246,38 +244,40 @@ unsafe impl<'a, T: 'a + ?Sized + Aligned> Pointer for &'a mut T {
     }
 }
 
-/// A tag type used in [`CopyTaggedPtr`] and [`TaggedPtr`] tests.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[cfg(test)]
-enum Tag2 {
-    B00 = 0b00,
-    B01 = 0b01,
-    B10 = 0b10,
-    B11 = 0b11,
-}
+mod tests {
+    use super::*;
+
+    /// A tag type used in [`CopyTaggedPtr`] and [`TaggedPtr`] tests.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub enum Tag2 {
+        B00 = 0b00,
+        B01 = 0b01,
+        B10 = 0b10,
+        B11 = 0b11,
+    }
 
-#[cfg(test)]
-unsafe impl Tag for Tag2 {
-    const BITS: u32 = 2;
+    unsafe impl Tag for Tag2 {
+        const BITS: u32 = 2;
 
-    fn into_usize(self) -> usize {
-        self as _
-    }
+        fn into_usize(self) -> usize {
+            self as _
+        }
 
-    unsafe fn from_usize(tag: usize) -> Self {
-        match tag {
-            0b00 => Tag2::B00,
-            0b01 => Tag2::B01,
-            0b10 => Tag2::B10,
-            0b11 => Tag2::B11,
-            _ => unreachable!(),
+        unsafe fn from_usize(tag: usize) -> Self {
+            match tag {
+                0b00 => Tag2::B00,
+                0b01 => Tag2::B01,
+                0b10 => Tag2::B10,
+                0b11 => Tag2::B11,
+                _ => unreachable!(),
+            }
         }
     }
-}
 
-#[cfg(test)]
-impl<HCX> crate::stable_hasher::HashStable<HCX> for Tag2 {
-    fn hash_stable(&self, hcx: &mut HCX, hasher: &mut crate::stable_hasher::StableHasher) {
-        (*self as u8).hash_stable(hcx, hasher);
+    impl<HCX> crate::stable_hasher::HashStable<HCX> for Tag2 {
+        fn hash_stable(&self, hcx: &mut HCX, hasher: &mut crate::stable_hasher::StableHasher) {
+            (*self as u8).hash_stable(hcx, hasher);
+        }
     }
 }

compiler/rustc_data_structures/src/tagged_ptr/copy.rs renamed to compiler/rustc_data_structures/src/tagged_ptr/covariant.rs

@@ -9,21 +9,15 @@ use std::ptr::NonNull;
 use super::{Pointer, Tag};
 use crate::stable_hasher::{HashStable, StableHasher};
 
-/// A [`Copy`] tagged pointer.
-///
-/// This is essentially `{ pointer: P, tag: T }` packed in a single pointer.
-///
-/// You should use this instead of the [`TaggedPtr`] type in all cases where
-/// `P` implements [`Copy`].
+/// A covariant [`Copy`] tagged pointer. This is essentially `{ pointer: P, tag: T }` packed
+/// in a single pointer.
 ///
 /// If `COMPARE_PACKED` is true, then the pointers will be compared and hashed without
-/// unpacking. Otherwise we don't implement [`PartialEq`], [`Eq`] and [`Hash`];
-/// if you want that, wrap the [`CopyTaggedPtr`].
-///
-/// [`TaggedPtr`]: crate::tagged_ptr::TaggedPtr
-pub struct CopyTaggedPtr<P, T, const COMPARE_PACKED: bool>
+/// unpacking. Otherwise we don't implement [`PartialEq`], [`Eq`] and [`Hash`]; if you
+/// want that, wrap the [`TaggedPtr`].
+pub struct TaggedPtr<P, Pointee: ?Sized, T, const COMPARE_PACKED: bool>
 where
-    P: Pointer,
+    P: Pointer<Target = Pointee>,
     T: Tag,
 {
     /// This is semantically a pair of `pointer: P` and `tag: T` fields,
@@ -64,14 +58,14 @@ where
     ///
     /// The tag can be retrieved by `packed.addr() >> T::BITS` and the pointer
     /// can be retrieved by `packed.map_addr(|addr| addr << T::BITS)`.
-    packed: NonNull<P::Target>,
-    tag_ghost: PhantomData<T>,
+    packed: NonNull<Pointee>,
+    tag_pointer_ghost: PhantomData<(P, T)>,
 }
 
 // Note that even though `CopyTaggedPtr` is only really expected to work with
 // `P: Copy`, can't add `P: Copy` bound, because `CopyTaggedPtr` is used in the
 // `TaggedPtr`'s implementation.
-impl<P, T, const CP: bool> CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer,
     T: Tag,
@@ -85,7 +79,7 @@ where
     /// [`TaggedPtr`]: crate::tagged_ptr::TaggedPtr
     #[inline]
     pub fn new(pointer: P, tag: T) -> Self {
-        Self { packed: Self::pack(P::into_ptr(pointer), tag), tag_ghost: PhantomData }
+        Self { packed: Self::pack(P::into_ptr(pointer), tag), tag_pointer_ghost: PhantomData }
     }
 
     /// Retrieves the pointer.
@@ -177,14 +171,14 @@ where
     }
 }
 
-impl<P, T, const CP: bool> Copy for CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> Copy for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer + Copy,
     T: Tag,
 {
 }
 
-impl<P, T, const CP: bool> Clone for CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> Clone for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer + Copy,
     T: Tag,
@@ -195,7 +189,7 @@ where
     }
 }
 
-impl<P, T, const CP: bool> Deref for CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> Deref for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer,
     T: Tag,
@@ -211,7 +205,7 @@ where
     }
 }
 
-impl<P, T, const CP: bool> DerefMut for CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> DerefMut for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer + DerefMut,
     T: Tag,
@@ -226,7 +220,7 @@ where
     }
 }
 
-impl<P, T, const CP: bool> fmt::Debug for CopyTaggedPtr<P, T, CP>
+impl<P, T, const CP: bool> fmt::Debug for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer + fmt::Debug,
     T: Tag + fmt::Debug,
@@ -238,7 +232,7 @@ where
     }
 }
 
-impl<P, T> PartialEq for CopyTaggedPtr<P, T, true>
+impl<P, T> PartialEq for TaggedPtr<P, P::Target, T, true>
 where
     P: Pointer,
     T: Tag,
@@ -250,14 +244,14 @@ where
     }
 }
 
-impl<P, T> Eq for CopyTaggedPtr<P, T, true>
+impl<P, T> Eq for TaggedPtr<P, P::Target, T, true>
 where
     P: Pointer,
     T: Tag,
 {
 }
 
-impl<P, T> Hash for CopyTaggedPtr<P, T, true>
+impl<P, T> Hash for TaggedPtr<P, P::Target, T, true>
 where
     P: Pointer,
     T: Tag,
@@ -268,7 +262,7 @@ where
     }
 }
 
-impl<P, T, HCX, const CP: bool> HashStable<HCX> for CopyTaggedPtr<P, T, CP>
+impl<P, T, HCX, const CP: bool> HashStable<HCX> for TaggedPtr<P, P::Target, T, CP>
 where
     P: Pointer + HashStable<HCX>,
     T: Tag + HashStable<HCX>,
@@ -282,7 +276,7 @@ where
 // Safety:
 // `CopyTaggedPtr<P, T, ..>` is semantically just `{ ptr: P, tag: T }`, as such
 // it's ok to implement `Sync` as long as `P: Sync, T: Sync`
-unsafe impl<P, T, const CP: bool> Sync for CopyTaggedPtr<P, T, CP>
+unsafe impl<P, T, const CP: bool> Sync for TaggedPtr<P, P::Target, T, CP>
 where
     P: Sync + Pointer,
     T: Sync + Tag,
@@ -292,7 +286,7 @@ where
 // Safety:
 // `CopyTaggedPtr<P, T, ..>` is semantically just `{ ptr: P, tag: T }`, as such
 // it's ok to implement `Send` as long as `P: Send, T: Send`
-unsafe impl<P, T, const CP: bool> Send for CopyTaggedPtr<P, T, CP>
+unsafe impl<P, T, const CP: bool> Send for TaggedPtr<P, P::Target, T, CP>
 where
     P: Send + Pointer,
     T: Send + Tag,

compiler/rustc_data_structures/src/tagged_ptr/copy/tests.rs renamed to compiler/rustc_data_structures/src/tagged_ptr/covariant/tests.rs

@@ -1,8 +1,9 @@
 use std::ptr;
 
+use super::*;
 use crate::hashes::Hash128;
 use crate::stable_hasher::{HashStable, StableHasher};
-use crate::tagged_ptr::{CopyTaggedPtr, Pointer, Tag, Tag2};
+use crate::tagged_ptr::tests::Tag2;
 
 #[test]
 fn smoke() {
@@ -45,6 +46,6 @@ fn stable_hash_hashes_as_tuple() {
 }
 
 /// Helper to create tagged pointers without specifying `COMPARE_PACKED` if it does not matter.
-fn tag_ptr<P: Pointer, T: Tag>(ptr: P, tag: T) -> CopyTaggedPtr<P, T, true> {
-    CopyTaggedPtr::new(ptr, tag)
+fn tag_ptr<P: Pointer, T: Tag>(ptr: P, tag: T) -> TaggedPtr<P, P::Target, T, true> {
+    TaggedPtr::new(ptr, tag)
 }