Add ptr::Pointee trait (for all types) and ptr::metadata function

RFC: rust-lang/rfcs#2580

Author: SimonSapin

core/src/lib.rs

@@ -133,6 +133,7 @@
 #![feature(stmt_expr_attributes)]
 #![feature(str_split_as_str)]
 #![feature(str_split_inclusive_as_str)]
+#![feature(trait_alias)]
 #![feature(transparent_unions)]
 #![feature(try_blocks)]
 #![feature(unboxed_closures)]

core/src/ptr/metadata.rs

@@ -0,0 +1,77 @@
+#![unstable(feature = "ptr_metadata", issue = /* FIXME */ "none")]
+
+use crate::fmt;
+use crate::hash::Hash;
+use crate::ptr::NonNull;
+
+/// FIXME docs
+#[lang = "pointee_trait"]
+pub trait Pointee {
+    /// The type for metadata in pointers and references to `Self`.
+    #[lang = "metadata_type"]
+    // 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;
+}
+
+/// Pointers to types implementing this trait alias are “thin”
+///
+/// ```rust
+/// #![feature(ptr_metadata)]
+///
+/// fn this_never_panics<T: std::ptr::Thin>() {
+///     assert_eq!(std::mem::size_of::<&T>(), std::mem::size_of::<usize>())
+/// }
+/// ```
+#[unstable(feature = "ptr_metadata", issue = /* FIXME */ "none")]
+// NOTE: don’t stabilize this before trait aliases are stable in the language?
+pub trait Thin = Pointee<Metadata = ()>;
+
+/// Extract the metadata component of a pointer.
+#[inline]
+pub fn metadata<T: ?Sized>(ptr: *const T) -> <T as Pointee>::Metadata {
+    // SAFETY: Accessing the value from the `PtrRepr` union is safe since *const T
+    // and PtrComponents<T> have the same memory layouts. Only std can make this
+    // guarantee.
+    unsafe { PtrRepr { const_ptr: ptr }.components.metadata }
+}
+
+#[repr(C)]
+union PtrRepr<T: ?Sized> {
+    const_ptr: *const T,
+    components: PtrComponents<T>,
+}
+
+#[repr(C)]
+struct PtrComponents<T: ?Sized> {
+    data_address: usize,
+    metadata: <T as Pointee>::Metadata,
+}
+
+// Manual impl needed to avoid `T: Copy` bound.
+impl<T: ?Sized> Copy for PtrComponents<T> {}
+
+// Manual impl needed to avoid `T: Clone` bound.
+impl<T: ?Sized> Clone for PtrComponents<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+/// The metadata for a `dyn SomeTrait` trait object type.
+#[lang = "dyn_metadata"]
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct DynMetadata {
+    #[allow(unused)]
+    vtable_ptr: NonNull<()>,
+}
+
+unsafe impl Send for DynMetadata {}
+unsafe impl Sync for DynMetadata {}
+
+impl fmt::Debug for DynMetadata {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("DynMetadata { … }")
+    }
+}

core/src/ptr/mod.rs

@@ -82,6 +82,12 @@ pub use crate::intrinsics::copy;
 #[doc(inline)]
 pub use crate::intrinsics::write_bytes;
 
+#[cfg(not(bootstrap))]
+mod metadata;
+#[cfg(not(bootstrap))]
+#[unstable(feature = "ptr_metadata", issue = /* FIXME */ "none")]
+pub use metadata::{metadata, DynMetadata, Pointee, Thin};
+
 mod non_null;
 #[stable(feature = "nonnull", since = "1.25.0")]
 pub use non_null::NonNull;

core/tests/lib.rs

@@ -27,6 +27,7 @@
 #![feature(duration_saturating_ops)]
 #![feature(duration_zero)]
 #![feature(exact_size_is_empty)]
+#![feature(extern_types)]
 #![feature(fixed_size_array)]
 #![feature(flt2dec)]
 #![feature(fmt_internals)]
@@ -67,8 +68,10 @@
 #![feature(option_result_unwrap_unchecked)]
 #![feature(option_unwrap_none)]
 #![feature(peekable_peek_mut)]
+#![feature(ptr_metadata)]
 #![feature(once_cell)]
 #![feature(unsafe_block_in_unsafe_fn)]
+#![feature(unsized_tuple_coercion)]
 #![feature(int_bits_const)]
 #![feature(nonzero_leading_trailing_zeros)]
 #![feature(const_option)]

core/tests/ptr.rs

@@ -1,5 +1,6 @@
 use core::cell::RefCell;
 use core::ptr::*;
+use std::fmt::Display;
 
 #[test]
 fn test_const_from_raw_parts() {
@@ -413,3 +414,89 @@ fn offset_from() {
         assert_eq!(ptr2.offset(-2), ptr1);
     }
 }
+
+#[test]
+#[cfg(not(bootstrap))]
+fn ptr_metadata() {
+    struct Unit;
+    struct Pair<A, B: ?Sized>(A, B);
+    extern "C" {
+        type Extern;
+    }
+    let () = metadata(&());
+    let () = metadata(&Unit);
+    let () = metadata(&4_u32);
+    let () = metadata(&String::new());
+    let () = metadata(&Some(4_u32));
+    let () = metadata(&ptr_metadata);
+    let () = metadata(&|| {});
+    let () = metadata(&[4, 7]);
+    let () = metadata(&(4, String::new()));
+    let () = metadata(&Pair(4, String::new()));
+    let () = metadata(0 as *const Extern);
+    let () = metadata(0 as *const <&u32 as std::ops::Deref>::Target);
+
+    assert_eq!(metadata("foo"), 3_usize);
+    assert_eq!(metadata(&[4, 7][..]), 2_usize);
+
+    let dst_tuple: &(bool, [u8]) = &(true, [0x66, 0x6F, 0x6F]);
+    let dst_struct: &Pair<bool, [u8]> = &Pair(true, [0x66, 0x6F, 0x6F]);
+    assert_eq!(metadata(dst_tuple), 3_usize);
+    assert_eq!(metadata(dst_struct), 3_usize);
+    unsafe {
+        let dst_tuple: &(bool, str) = std::mem::transmute(dst_tuple);
+        let dst_struct: &Pair<bool, str> = std::mem::transmute(dst_struct);
+        assert_eq!(&dst_tuple.1, "foo");
+        assert_eq!(&dst_struct.1, "foo");
+        assert_eq!(metadata(dst_tuple), 3_usize);
+        assert_eq!(metadata(dst_struct), 3_usize);
+    }
+
+    let vtable_1: DynMetadata = metadata(&4_u32 as &dyn Display);
+    let vtable_2: DynMetadata = metadata(&(true, 7_u32) as &(bool, dyn Display));
+    let vtable_3: DynMetadata = metadata(&Pair(true, 7_u32) as &Pair<bool, dyn Display>);
+    let vtable_4: DynMetadata = metadata(&4_u16 as &dyn Display);
+    unsafe {
+        let address_1: usize = std::mem::transmute(vtable_1);
+        let address_2: usize = std::mem::transmute(vtable_2);
+        let address_3: usize = std::mem::transmute(vtable_3);
+        let address_4: usize = std::mem::transmute(vtable_4);
+        // Same erased type and same trait: same vtable pointer
+        assert_eq!(address_1, address_2);
+        assert_eq!(address_1, address_3);
+        // Different erased type: different vtable pointer
+        assert_ne!(address_1, address_4);
+    }
+}
+
+#[test]
+#[cfg(not(bootstrap))]
+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
+    }
+    // "Synthetic" trait impls generated by the compiler like those of `Pointee`
+    // are not checked for bounds of associated type.
+    // So with a buggy libcore we could have both:
+    // * `<dyn Display as Pointee>::Metadata == DynMetadata`
+    // * `DynMetadata: !PartialEq`
+    // … and cause an ICE here:
+    metadata_eq_method_address::<dyn Display>();
+
+    // For this reason, let’s check here that bounds are satisfied:
+
+    static_assert_expected_bounds_for_metadata::<()>();
+    static_assert_expected_bounds_for_metadata::<usize>();
+    static_assert_expected_bounds_for_metadata::<DynMetadata>();
+    fn static_assert_associated_type<T: ?Sized>() {
+        static_assert_expected_bounds_for_metadata::<<T as Pointee>::Metadata>()
+    }
+
+    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,
+    {
+    }
+}