continue CovariantCopyTaggedPtr

Author: BoxyUwU

compiler/rustc_ast_lowering/src/lib.rs

@@ -47,7 +47,7 @@ use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::tagged_ptr::CovariantCopyTaggedPtr;
+use rustc_data_structures::tagged_ptr::TaggedPtr;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, StashKey};
 use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
@@ -1162,7 +1162,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             });
             let kind = hir::TyKind::TraitObject(
                 bounds,
-                CovariantCopyTaggedPtr::new(lifetime_bound, TraitObjectSyntax::None),
+                TaggedPtr::new(lifetime_bound, TraitObjectSyntax::None),
             );
             return hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.next_id() };
         }
@@ -1314,7 +1314,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         lifetime_bound.unwrap_or_else(|| this.elided_dyn_bound(t.span));
                     (bounds, lifetime_bound)
                 });
-                hir::TyKind::TraitObject(bounds, CovariantCopyTaggedPtr::new(lifetime_bound, *kind))
+                hir::TyKind::TraitObject(bounds, TaggedPtr::new(lifetime_bound, *kind))
             }
             TyKind::ImplTrait(def_node_id, bounds) => {
                 let span = t.span;
@@ -2370,7 +2370,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         hir_id = self.next_id();
                         hir::TyKind::TraitObject(
                             arena_vec![self; principal],
-                            CovariantCopyTaggedPtr::new(
+                            TaggedPtr::new(
                                 self.elided_dyn_bound(span),
                                 TraitObjectSyntax::None,
                             ),

compiler/rustc_data_structures/src/marker.rs

@@ -72,8 +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::CovariantCopyTaggedPtr<P, T, CP> where P: Send + crate::tagged_ptr::Pointer<Target: Sized>, 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]
@@ -149,8 +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::CovariantCopyTaggedPtr<P, T, CP> where P: Sync + crate::tagged_ptr::Pointer<Target: Sized>, 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,14 +22,10 @@ use std::sync::Arc;
 
 use crate::aligned::Aligned;
 
-mod copy;
 mod covariant;
-mod drop;
 mod impl_tag;
 
-pub use copy::CopyTaggedPtr;
-pub use covariant::CovariantCopyTaggedPtr;
-pub use drop::TaggedPtr;
+pub use covariant::TaggedPtr;
 
 /// This describes the pointer type encapsulated by [`TaggedPtr`] and
 /// [`CopyTaggedPtr`].
@@ -248,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);
+        }
     }
 }