add MetadataCast built-in trait

Author: Lukas Markeffsky

compiler/rustc_hir/src/lang_items.rs

@@ -155,6 +155,7 @@ language_item_table! {
     PointeeTrait,            sym::pointee_trait,       pointee_trait,              Target::Trait,          GenericRequirement::None;
     Metadata,                sym::metadata_type,       metadata_type,              Target::AssocTy,        GenericRequirement::None;
     DynMetadata,             sym::dyn_metadata,        dyn_metadata,               Target::Struct,         GenericRequirement::None;
+    MetadataCast,            sym::metadata_cast,       metadata_cast_trait,        Target::Trait,          GenericRequirement::Minimum(1);
 
     Freeze,                  sym::freeze,              freeze_trait,               Target::Trait,          GenericRequirement::Exact(0);
 

compiler/rustc_middle/src/traits/select.rs

@@ -108,14 +108,17 @@ pub enum SelectionCandidate<'tcx> {
     /// A builtin implementation for some specific traits, used in cases
     /// where we cannot rely an ordinary library implementations.
     ///
-    /// The most notable examples are `sized`, `Copy` and `Clone`. This is also
+    /// The most notable examples are `Sized`, `Copy` and `Clone`. This is also
     /// used for the `DiscriminantKind` and `Pointee` trait, both of which have
     /// an associated type.
     BuiltinCandidate {
         /// `false` if there are no *further* obligations.
         has_nested: bool,
     },
 
+    /// Implementation of the `MetadataCast` trait.
+    MetadataCastCandidate(MetadataCastKind<'tcx>),
+
     /// Implementation of transmutability trait.
     TransmutabilityCandidate,
 
@@ -176,6 +179,14 @@ pub enum SelectionCandidate<'tcx> {
     ConstDestructCandidate(Option<DefId>),
 }
 
+#[derive(PartialEq, Eq, Debug, Clone, TypeVisitable)]
+pub enum MetadataCastKind {
+    /// No further obligations.
+    Unconditional,
+    /// `T: MetadataCast<U>` if `T <: U`.
+    Subtype,
+}
+
 /// The result of trait evaluation. The order is important
 /// here as the evaluation of a list is the maximum of the
 /// evaluations.

compiler/rustc_span/src/symbol.rs

@@ -1017,6 +1017,7 @@ symbols! {
         memtag,
         message,
         meta,
+        metadata_cast,
         metadata_type,
         min_align_of,
         min_align_of_val,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -11,6 +11,7 @@ use hir::LangItem;
 use rustc_hir as hir;
 use rustc_infer::traits::ObligationCause;
 use rustc_infer::traits::{Obligation, PolyTraitObligation, SelectionError};
+use rustc_middle::traits::select::MetadataCastKind;
 use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams};
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
@@ -100,6 +101,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 self.assemble_candidate_for_pointer_like(obligation, &mut candidates);
             } else if lang_items.fn_ptr_trait() == Some(def_id) {
                 self.assemble_candidates_for_fn_ptr_trait(obligation, &mut candidates);
+            } else if lang_items.metadata_cast_trait() == Some(def_id) {
+                self.assemble_candidates_for_metadata_cast(obligation, &mut candidates);
             } else {
                 if lang_items.clone_trait() == Some(def_id) {
                     // Same builtin conditions as `Copy`, i.e., every type which has builtin support
@@ -1158,4 +1161,47 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
         }
     }
+
+    fn assemble_candidates_for_metadata_cast(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+        candidates: &mut SelectionCandidateSet<'tcx>,
+    ) {
+        let target = obligation.predicate.skip_binder().trait_ref.args.type_at(1);
+        let target = self.infcx.shallow_resolve(target);
+
+        if target.is_unit() {
+            candidates.vec.push(MetadataCastCandidate(MetadataCastKind::Unconditional));
+            return;
+        }
+
+        let source = obligation.self_ty().skip_binder();
+        let source = self.infcx.shallow_resolve(source);
+
+        if source.has_non_region_infer() || target.has_non_region_infer() {
+            candidates.ambiguous = true;
+            return;
+        }
+
+        if let ty::Adt(src_def, src_args) = source.kind()
+            && let ty::Adt(tgt_def, tgt_args) = target.kind()
+            && src_def == tgt_def
+            && Some(src_def.did()) == self.tcx().lang_items().dyn_metadata()
+        {
+            let src_dyn = src_args.type_at(0);
+            let tgt_dyn = tgt_args.type_at(0);
+
+            // We could theoretically allow casting the principal away, but `as` casts
+            // don't allow that, so neither does `MetadataCast` for now.
+            if let ty::Dynamic(src_pred, _, ty::Dyn) = src_dyn.kind()
+                && let ty::Dynamic(tgt_pred, _, ty::Dyn) = tgt_dyn.kind()
+                && src_pred.principal_def_id() == tgt_pred.principal_def_id()
+            {
+                candidates.vec.push(MetadataCastCandidate(MetadataCastKind::Unconditional));
+                return;
+            }
+        }
+
+        candidates.vec.push(MetadataCastCandidate(MetadataCastKind::Subtype));
+    }
 }

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -11,6 +11,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::BoundRegionConversionTime::HigherRankedType;
 use rustc_infer::infer::{DefineOpaqueTypes, InferOk};
+use rustc_middle::traits::select::MetadataCastKind;
 use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData};
 use rustc_middle::ty::{
     self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, ToPredicate,
@@ -51,6 +52,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
             }
 
+            MetadataCastCandidate(kind) => {
+                let data = self.confirm_metadata_cast_candidate(obligation, kind)?;
+                ImplSource::Builtin(BuiltinImplSource::Misc, data)
+            }
+
             TransmutabilityCandidate => {
                 let data = self.confirm_transmutability_candidate(obligation)?;
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
@@ -272,6 +278,28 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         obligations
     }
 
+    fn confirm_metadata_cast_candidate(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+        kind: MetadataCastKind,
+    ) -> Result<Vec<PredicateObligation<'tcx>>, SelectionError<'tcx>> {
+        match kind {
+            MetadataCastKind::Unconditional => Ok(Vec::new()),
+            MetadataCastKind::Subtype => {
+                let source = obligation.self_ty().skip_binder();
+                let target = obligation.predicate.skip_binder().trait_ref.args.type_at(1);
+
+                let InferOk { obligations, .. } = self
+                    .infcx
+                    .at(&obligation.cause, obligation.param_env)
+                    .sub(DefineOpaqueTypes::No, source, target)
+                    .map_err(|_| Unimplemented)?;
+
+                Ok(obligations)
+            }
+        }
+    }
+
     #[instrument(level = "debug", skip(self))]
     fn confirm_transmutability_candidate(
         &mut self,

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1830,12 +1830,18 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             (TransmutabilityCandidate, _) | (_, TransmutabilityCandidate) => DropVictim::No,
 
             // (*)
-            (BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_), _) => {
-                DropVictim::Yes
-            }
-            (_, BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_)) => {
-                DropVictim::No
-            }
+            (
+                BuiltinCandidate { has_nested: false }
+                | ConstDestructCandidate(_)
+                | MetadataCastCandidate(MetadataCastKind::Unconditional),
+                _,
+            ) => DropVictim::Yes,
+            (
+                _,
+                BuiltinCandidate { has_nested: false }
+                | ConstDestructCandidate(_)
+                | MetadataCastCandidate(MetadataCastKind::Unconditional),
+            ) => DropVictim::No,
 
             (ParamCandidate(other), ParamCandidate(victim)) => {
                 let same_except_bound_vars = other.skip_binder().trait_ref
@@ -1873,6 +1879,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { .. }
+                | MetadataCastCandidate(_)
                 | TraitAliasCandidate
                 | ObjectCandidate(_)
                 | ProjectionCandidate(_),
@@ -1903,6 +1910,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { has_nested: true }
+                | MetadataCastCandidate(MetadataCastKind::Subtype)
                 | TraitAliasCandidate,
                 ParamCandidate(ref victim_cand),
             ) => {
@@ -1939,6 +1947,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { .. }
+                | MetadataCastCandidate(_)
                 | TraitAliasCandidate,
             ) => DropVictim::Yes,
 
@@ -1955,6 +1964,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { .. }
+                | MetadataCastCandidate(_)
                 | TraitAliasCandidate,
                 ObjectCandidate(_) | ProjectionCandidate(_),
             ) => DropVictim::No,
@@ -2063,6 +2073,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { has_nested: true }
+                | MetadataCastCandidate(MetadataCastKind::Subtype)
                 | TraitAliasCandidate,
                 ImplCandidate(_)
                 | ClosureCandidate { .. }
@@ -2075,6 +2086,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinCandidate { has_nested: true }
+                | MetadataCastCandidate(MetadataCastKind::Subtype)
                 | TraitAliasCandidate,
             ) => DropVictim::No,
         }

library/core/src/ptr/metadata.rs

@@ -77,6 +77,22 @@ pub trait Pointee {
 // NOTE: don’t stabilize this before trait aliases are stable in the language?
 pub trait Thin = Pointee<Metadata = ()>;
 
+/// A marker for valid metadata conversions during pointer-to-pointer casts.
+///
+/// A type `T` implements `MetadataCast<U>` if and only if pointers with metadata `T`
+/// can be cast to pointers with metadata `U`.
+#[unstable(feature = "ptr_metadata_cast", issue = "none")]
+#[cfg_attr(not(bootstrap), lang = "metadata_cast")]
+#[rustc_deny_explicit_impl(implement_via_object = false)]
+pub trait MetadataCast<T: ?Sized> {}
+
+/// A marker for valid pointer-to-pointer casts.
+///
+/// A type `T` implements `PointerCast<U>` if and only if a pointer to `T` can be
+/// cast into a pointer to `U`.
+#[unstable(feature = "ptr_metadata_cast", issue = "none")]
+pub trait PointerCast<T: ?Sized> = Pointee<Metadata: MetadataCast<<T as Pointee>::Metadata>>;
+
 /// Extract the metadata component of a pointer.
 ///
 /// Values of type `*mut T`, `&T`, or `&mut T` can be passed directly to this function

library/core/src/ptr/mod.rs

@@ -406,6 +406,8 @@ pub use crate::intrinsics::write_bytes;
 mod metadata;
 #[unstable(feature = "ptr_metadata", issue = "81513")]
 pub use metadata::{from_raw_parts, from_raw_parts_mut, metadata, DynMetadata, Pointee, Thin};
+#[unstable(feature = "ptr_metadata_cast", issue = "none")]
+pub use metadata::{MetadataCast, PointerCast};
 
 mod non_null;
 #[stable(feature = "nonnull", since = "1.25.0")]

tests/ui/traits/metadata-cast-fail-lifetimes.rs

@@ -0,0 +1,39 @@
+#![feature(ptr_metadata, ptr_metadata_cast)]
+
+use std::ptr::{self, DynMetadata, MetadataCast, Pointee, PointerCast};
+
+fn cast<T: ?Sized, U: ?Sized>(ptr: *mut T) -> *mut U
+where
+    T: PointerCast<U>,
+{
+    todo!()
+}
+
+fn check<T: ?Sized, U: ?Sized>()
+where
+    T: MetadataCast<U>,
+{
+}
+
+fn main() {}
+
+fn err1<'a, 'b>() {
+    // changing lifetimes in `DynMetadata<T>` is only allowed if `T = dyn Trait`
+    check::<DynMetadata<&'a ()>, DynMetadata<&'b ()>>();
+    //~^ ERROR may not live long enough
+}
+
+fn err2<'a, 'b>() {
+    check::<&'a (), &'b ()>();
+    //~^ ERROR may not live long enough
+}
+
+fn subtype_fail<'short, 'long: 'short, T, U>(ptr: *mut T) -> *mut U
+where
+    T: ?Sized + Pointee<Metadata = &'short ()>,
+    U: ?Sized + Pointee<Metadata = &'long ()>,
+{
+    // extending the lifetime of arbitrary metadata is not allowed
+    cast(ptr)
+    //~^ ERROR may not live long enough
+}

tests/ui/traits/metadata-cast-fail-lifetimes.stderr

@@ -0,0 +1,40 @@
+error: lifetime may not live long enough
+  --> $DIR/metadata-cast-fail-lifetimes.rs:22:5
+   |
+LL | fn err1<'a, 'b>() {
+   |         --  -- lifetime `'b` defined here
+   |         |
+   |         lifetime `'a` defined here
+LL |     // changing lifetimes in `DynMetadata<T>` is only allowed if `T = dyn Trait`
+LL |     check::<DynMetadata<&'a ()>, DynMetadata<&'b ()>>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'b`
+   |
+   = help: consider adding the following bound: `'a: 'b`
+
+error: lifetime may not live long enough
+  --> $DIR/metadata-cast-fail-lifetimes.rs:27:5
+   |
+LL | fn err2<'a, 'b>() {
+   |         --  -- lifetime `'b` defined here
+   |         |
+   |         lifetime `'a` defined here
+LL |     check::<&'a (), &'b ()>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'b`
+   |
+   = help: consider adding the following bound: `'a: 'b`
+
+error: lifetime may not live long enough
+  --> $DIR/metadata-cast-fail-lifetimes.rs:37:5
+   |
+LL | fn subtype_fail<'short, 'long: 'short, T, U>(ptr: *mut T) -> *mut U
+   |                 ------  ----- lifetime `'long` defined here
+   |                 |
+   |                 lifetime `'short` defined here
+...
+LL |     cast(ptr)
+   |     ^^^^^^^^^ requires that `'short` must outlive `'long`
+   |
+   = help: consider adding the following bound: `'short: 'long`
+
+error: aborting due to 3 previous errors
+

tests/ui/traits/metadata-cast-fail-traits.rs

@@ -0,0 +1,45 @@
+#![feature(ptr_metadata, ptr_metadata_cast)]
+
+use std::ptr::{DynMetadata, MetadataCast, PointerCast};
+
+fn cast<T: ?Sized, U: ?Sized>(_: *mut T) -> *mut U
+where
+    T: PointerCast<U>,
+{
+    todo!()
+}
+
+fn check<T: ?Sized, U: ?Sized>()
+where
+    T: MetadataCast<U>,
+{
+}
+
+trait Trait {}
+trait Trait2 {}
+
+fn main() {
+    check::<(), usize>(); //~ ERROR not satisfied
+    check::<(), DynMetadata<dyn Trait>>(); //~ ERROR not satisfied
+    check::<usize, DynMetadata<dyn Trait>>(); //~ ERROR not satisfied
+    check::<DynMetadata<dyn Trait>, usize>(); //~ ERROR not satisfied
+    check::<DynMetadata<dyn Trait>, DynMetadata<dyn Trait2>>(); //~ ERROR not satisfied
+    check::<dyn Trait + Send, dyn Trait + Sync>(); //~ ERROR not satisfied
+
+    // `dyn MetadataCast<usize>` should not implement `MetadataCast<usize>`
+    check::<dyn MetadataCast<usize>, usize>(); //~ ERROR not satisfied
+
+    // this could pass in the future, but for now it matches the behavior of `as` casts
+    check::<DynMetadata<dyn Trait>, DynMetadata<dyn Send>>(); //~ ERROR not satisfied
+}
+
+fn do_casts<'a>(thin: &mut i32, slice: &mut [i32], trait_object: &mut (dyn Trait + Send)) {
+    let _: *mut [u8] = cast(thin); //~ ERROR not satisfied
+    let _: *mut dyn Trait = cast(thin); //~ ERROR not satisfied
+    let _: *mut [u8] = cast(trait_object); //~ ERROR not satisfied
+    let _: *mut dyn Trait = cast(slice); //~ ERROR not satisfied
+    let _: *mut dyn Trait2 = cast(trait_object); //~ ERROR not satisfied
+
+    // may be allowed in the future
+    let _: *mut dyn Send = cast(trait_object); //~ ERROR not satisfied
+}