Remove Hash, PartialEq, Eq, PartialOrd, Ord from DynMetadata

Author: nbdd0121

library/core/src/hash/mod.rs

@@ -960,17 +960,21 @@ mod impls {
         fn hash<H: Hasher>(&self, state: &mut H) {
             let (address, metadata) = self.to_raw_parts();
             state.write_usize(address.addr());
-            metadata.hash(state);
+            if mem::size_of_val(&metadata) == mem::size_of::<usize>() {
+                // SAFETY: This is either `usize` or `DynMetadata`. In both case doing transmute
+                // is okay.
+                // We can't hash `DynMetadata` directly so transmute it to usize before hashing.
+                let metadata_as_usize = unsafe { mem::transmute_copy(&metadata) };
+                state.write_usize(metadata_as_usize);
+            }
         }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
     impl<T: ?Sized> Hash for *mut T {
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
-            let (address, metadata) = self.to_raw_parts();
-            state.write_usize(address.addr());
-            metadata.hash(state);
+            self.cast_const().hash(state);
         }
     }
 }

library/core/src/ptr/metadata.rs

@@ -1,7 +1,6 @@
 #![unstable(feature = "ptr_metadata", issue = "81513")]
 
 use crate::fmt;
-use crate::hash::{Hash, Hasher};
 
 /// Provides the pointer metadata type of any pointed-to type.
 ///
@@ -57,7 +56,7 @@ pub trait Pointee {
     // NOTE: Keep trait bounds in `static_assert_expected_bounds_for_metadata`
     // in `library/core/src/ptr/metadata.rs`
     // in sync with those here:
-    type Metadata: Copy + Send + Sync + Ord + Hash + Unpin;
+    type Metadata: Copy + Send + Sync + Unpin;
 }
 
 /// Pointers to types implementing this trait alias are “thin”.
@@ -241,33 +240,3 @@ impl<Dyn: ?Sized> Clone for DynMetadata<Dyn> {
         *self
     }
 }
-
-impl<Dyn: ?Sized> Eq for DynMetadata<Dyn> {}
-
-impl<Dyn: ?Sized> PartialEq for DynMetadata<Dyn> {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        crate::ptr::eq::<VTable>(self.vtable_ptr, other.vtable_ptr)
-    }
-}
-
-impl<Dyn: ?Sized> Ord for DynMetadata<Dyn> {
-    #[inline]
-    fn cmp(&self, other: &Self) -> crate::cmp::Ordering {
-        (self.vtable_ptr as *const VTable).cmp(&(other.vtable_ptr as *const VTable))
-    }
-}
-
-impl<Dyn: ?Sized> PartialOrd for DynMetadata<Dyn> {
-    #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<crate::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl<Dyn: ?Sized> Hash for DynMetadata<Dyn> {
-    #[inline]
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        crate::ptr::hash::<VTable, _>(self.vtable_ptr, hasher)
-    }
-}

library/core/tests/ptr.rs

@@ -801,17 +801,17 @@ fn ptr_metadata() {
 
 #[test]
 fn ptr_metadata_bounds() {
-    fn metadata_eq_method_address<T: ?Sized>() -> usize {
-        // The `Metadata` associated type has an `Ord` bound, so this is valid:
-        <<T as Pointee>::Metadata as PartialEq>::eq as usize
+    fn metadata_clone_method_address<T: ?Sized>() -> usize {
+        // The `Metadata` associated type has an `Copy` bound, so this is valid:
+        <<T as Pointee>::Metadata as Clone>::clone as usize
     }
     // "Synthetic" trait impls generated by the compiler like those of `Pointee`
     // are not checked for bounds of associated type.
     // So with a buggy core we could have both:
     // * `<dyn Display as Pointee>::Metadata == DynMetadata`
-    // * `DynMetadata: !PartialEq`
+    // * `DynMetadata: !Clone`
     // … and cause an ICE here:
-    metadata_eq_method_address::<dyn Display>();
+    metadata_clone_method_address::<dyn Display>();
 
     // For this reason, let’s check here that bounds are satisfied:
 
@@ -825,7 +825,7 @@ fn ptr_metadata_bounds() {
     fn static_assert_expected_bounds_for_metadata<Meta>()
     where
         // Keep this in sync with the associated type in `library/core/src/ptr/metadata.rs`
-        Meta: Copy + Send + Sync + Ord + std::hash::Hash + Unpin,
+        Meta: Copy + Send + Sync + Unpin,
     {
     }
 }