Allow unsizing pattern types with pointer base

Author: oli-obk

compiler/rustc_codegen_cranelift/src/unsize.rs

@@ -148,6 +148,11 @@ pub(crate) fn coerce_unsized_into<'tcx>(
         dst.write_cvalue(fx, CValue::by_val_pair(base, info, dst.layout()));
     };
     match (&src_ty.kind(), &dst_ty.kind()) {
+        (ty::Pat(a, _), ty::Pat(b, _)) => {
+            let src = src.cast_pat_ty_to_base(fx.layout_of(*a));
+            let dst = dst.place_transmute_type(fx, *b);
+            return coerce_unsized_into(fx, src, dst);
+        }
         (&ty::Ref(..), &ty::Ref(..))
         | (&ty::Ref(..), &ty::RawPtr(..))
         | (&ty::RawPtr(..), &ty::RawPtr(..)) => coerce_ptr(),

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -379,6 +379,14 @@ impl<'tcx> CValue<'tcx> {
         assert_eq!(self.layout().backend_repr, layout.backend_repr);
         CValue(self.0, layout)
     }
+
+    pub(crate) fn cast_pat_ty_to_base(self, layout: TyAndLayout<'tcx>) -> Self {
+        let ty::Pat(base, _) = *self.layout().ty.kind() else {
+            panic!("not a pattern type: {:#?}", self.layout())
+        };
+        assert_eq!(layout.ty, base);
+        CValue(self.0, layout)
+    }
 }
 
 /// A place where you can write a value to or read a value from

compiler/rustc_codegen_ssa/src/base.rs

@@ -230,6 +230,7 @@ pub(crate) fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 ) -> (Bx::Value, Bx::Value) {
     debug!("unsize_ptr: {:?} => {:?}", src_ty, dst_ty);
     match (src_ty.kind(), dst_ty.kind()) {
+        (&ty::Pat(a, _), &ty::Pat(b, _)) => unsize_ptr(bx, src, a, b, old_info),
         (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))
         | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => {
             assert_eq!(bx.cx().type_is_sized(a), old_info.is_none());

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1073,6 +1073,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         //
                         // This is also relevant for `Pin<&mut Self>`, where we need to peel the
                         // `Pin`.
+
+                        loop {
+                            match *op.layout.ty.kind() {
+                                ty::Ref(..) | ty::RawPtr(..) => break,
+                                ty::Pat(inner, _) => op.layout = bx.layout_of(inner),
+                                _ => {
+                                    let (idx, _) = op.layout.non_1zst_field(bx).expect(
+                                        "not exactly one non-1-ZST field in a `DispatchFromDyn` type",
+                                    );
+                                    op = op.extract_field(self, bx, idx);
+                                }
+                            }
+                        }
                         while !op.layout.ty.is_raw_ptr() && !op.layout.ty.is_ref() {
                             let (idx, _) = op.layout.non_1zst_field(bx).expect(
                                 "not exactly one non-1-ZST field in a `DispatchFromDyn` type",

compiler/rustc_const_eval/src/interpret/call.rs

@@ -637,7 +637,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let mut receiver = self.copy_fn_arg(&args[0]);
                 let receiver_place = loop {
                     match receiver.layout.ty.kind() {
-                        ty::Ref(..) | ty::RawPtr(..) => {
+                        ty::Pat(..) | ty::Ref(..) | ty::RawPtr(..) => {
                             // We do *not* use `deref_pointer` here: we don't want to conceptually
                             // create a place that must be dereferenceable, since the receiver might
                             // be a raw pointer and (for `*const dyn Trait`) we don't need to

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -473,6 +473,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     ) -> InterpResult<'tcx> {
         trace!("Unsizing {:?} of type {} into {}", *src, src.layout.ty, cast_ty.ty);
         match (src.layout.ty.kind(), cast_ty.ty.kind()) {
+            (&ty::Pat(s, s_pat), &ty::Pat(c, c_pat)) if s_pat == c_pat => {
+                let mut src = src.clone();
+                src.layout = self.layout_of(s)?;
+                let mut dest = dest.clone();
+                dest.layout = self.layout_of(c)?;
+                let cast_ty = match *cast_ty.ty.kind() {
+                    ty::Pat(base, pat) if pat == c_pat => self.layout_of(base)?,
+                    _ => span_bug!(
+                        self.cur_span(),
+                        "unsize_into: invalid cast ty for pattern type: {cast_ty:#?}"
+                    ),
+                };
+                self.unsize_into(&src, cast_ty, &dest)
+            }
             (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(c, _))
             | (&ty::RawPtr(s, _), &ty::RawPtr(c, _)) => self.unsize_into_ptr(src, dest, s, c),
             (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {

compiler/rustc_const_eval/src/interpret/place.rs

@@ -6,8 +6,8 @@ use std::assert_matches::assert_matches;
 
 use either::{Either, Left, Right};
 use rustc_abi::{BackendRepr, HasDataLayout, Size};
-use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
+use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, mir, span_bug};
 use tracing::{instrument, trace};
 
@@ -419,8 +419,12 @@ where
         &self,
         val: &ImmTy<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
+        let pointer_type = match val.layout.ty.kind() {
+            ty::Pat(base, _) => *base,
+            _ => val.layout.ty,
+        };
         let pointee_type =
-            val.layout.ty.builtin_deref(true).expect("`ref_to_mplace` called on non-ptr type");
+            pointer_type.builtin_deref(true).expect("`ref_to_mplace` called on non-ptr type");
         let layout = self.layout_of(pointee_type)?;
         let (ptr, meta) = val.to_scalar_and_meta();
 

compiler/rustc_hir_analysis/messages.ftl

@@ -99,6 +99,8 @@ hir_analysis_coerce_pointee_not_struct = `derive(CoercePointee)` is only applica
 
 hir_analysis_coerce_pointee_not_transparent = `derive(CoercePointee)` is only applicable to `struct` with `repr(transparent)` layout
 
+hir_analysis_coerce_same_pat_kind = only pattern types with the same pattern can be coerced between each other
+
 hir_analysis_coerce_unsized_field_validity = for `{$ty}` to have a valid implementation of `{$trait_name}`, it must be possible to coerce the field of type `{$field_ty}`
     .label = `{$field_ty}` must be a pointer, reference, or smart pointer that is allowed to be unsized
 

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -249,6 +249,18 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
     // in the compiler (in particular, all the call ABI logic) will treat them as repr(transparent)
     // even if they do not carry that attribute.
     match (source.kind(), target.kind()) {
+        (&ty::Pat(_, pat_a), &ty::Pat(_, pat_b)) => {
+            if pat_a != pat_b {
+                return Err(tcx.dcx().emit_err(errors::CoerceSamePatKind {
+                    span,
+                    trait_name,
+                    pat_a: pat_a.to_string(),
+                    pat_b: pat_b.to_string(),
+                }));
+            }
+            Ok(())
+        }
+
         (&ty::Ref(r_a, _, mutbl_a), ty::Ref(r_b, _, mutbl_b))
             if r_a == *r_b && mutbl_a == *mutbl_b =>
         {
@@ -414,6 +426,18 @@ pub(crate) fn coerce_unsized_info<'tcx>(
         (mt_a.ty, mt_b.ty, unsize_trait, None, span)
     };
     let (source, target, trait_def_id, kind, field_span) = match (source.kind(), target.kind()) {
+        (&ty::Pat(ty_a, pat_a), &ty::Pat(ty_b, pat_b)) => {
+            if pat_a != pat_b {
+                return Err(tcx.dcx().emit_err(errors::CoerceSamePatKind {
+                    span,
+                    trait_name,
+                    pat_a: pat_a.to_string(),
+                    pat_b: pat_b.to_string(),
+                }));
+            }
+            (ty_a, ty_b, coerce_unsized_trait, None, span)
+        }
+
         (&ty::Ref(r_a, ty_a, mutbl_a), &ty::Ref(r_b, ty_b, mutbl_b)) => {
             infcx.sub_regions(infer::RelateObjectBound(span), r_b, r_a);
             let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
@@ -713,13 +737,16 @@ fn visit_implementation_of_pointer_like(checker: &Checker<'_>) -> Result<(), Err
     let impl_span = tcx.def_span(checker.impl_def_id);
     let self_ty = tcx.impl_trait_ref(checker.impl_def_id).unwrap().instantiate_identity().self_ty();
 
-    let is_permitted_primitive = match *self_ty.kind() {
-        ty::Adt(def, _) => def.is_box(),
-        ty::Uint(..) | ty::Int(..) | ty::RawPtr(..) | ty::Ref(..) | ty::FnPtr(..) => true,
-        _ => false,
-    };
+    fn is_permitted_primitive(self_ty: Ty<'_>) -> bool {
+        match *self_ty.kind() {
+            ty::Adt(def, _) => def.is_box(),
+            ty::Uint(..) | ty::Int(..) | ty::RawPtr(..) | ty::Ref(..) | ty::FnPtr(..) => true,
+            ty::Pat(base, _) => is_permitted_primitive(base),
+            _ => false,
+        }
+    }
 
-    if is_permitted_primitive
+    if is_permitted_primitive(self_ty)
         && let Ok(layout) = tcx.layout_of(typing_env.as_query_input(self_ty))
         && layout.layout.is_pointer_like(&tcx.data_layout)
     {

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -206,12 +206,8 @@ pub(crate) fn orphan_check_impl(
                 (LocalImpl::Disallow { problematic_kind }, NonlocalImpl::DisallowOther)
             }
 
-            ty::Pat(..) => (
-                LocalImpl::Disallow { problematic_kind: "pattern type" },
-                NonlocalImpl::DisallowOther,
-            ),
-
             ty::Bool
+            | ty::Pat(..)
             | ty::Char
             | ty::Int(..)
             | ty::Uint(..)

compiler/rustc_hir_analysis/src/errors.rs

@@ -1280,6 +1280,16 @@ pub(crate) struct CoerceUnsizedNonStruct {
     pub trait_name: &'static str,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_coerce_same_pat_kind)]
+pub(crate) struct CoerceSamePatKind {
+    #[primary_span]
+    pub span: Span,
+    pub trait_name: &'static str,
+    pub pat_a: String,
+    pub pat_b: String,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0377)]
 pub(crate) struct CoerceSameStruct {

compiler/rustc_middle/src/traits/select.rs

@@ -159,6 +159,9 @@ pub enum SelectionCandidate<'tcx> {
     /// types generated for a fn pointer type (e.g., `fn(int) -> int`)
     FnPointerCandidate,
 
+    /// Builtin impl of the `PointerLike` trait.
+    PointerLikeCandidate,
+
     TraitAliasCandidate,
 
     /// Matching `dyn Trait` with a supertrait of `Trait`. The index is the

compiler/rustc_middle/src/ty/layout.rs

@@ -1009,13 +1009,17 @@ where
     /// Compute the information for the pointer stored at the given offset inside this type.
     /// This will recurse into fields of ADTs to find the inner pointer.
     fn ty_and_layout_pointee_info_at(
-        this: TyAndLayout<'tcx>,
+        mut this: TyAndLayout<'tcx>,
         cx: &C,
         offset: Size,
     ) -> Option<PointeeInfo> {
         let tcx = cx.tcx();
         let typing_env = cx.typing_env();
 
+        if let ty::Pat(base, _) = *this.ty.kind() {
+            this.ty = base;
+        }
+
         let pointee_info = match *this.ty.kind() {
             ty::RawPtr(p_ty, _) if offset.bytes() == 0 => {
                 tcx.layout_of(typing_env.as_query_input(p_ty)).ok().map(|layout| PointeeInfo {

compiler/rustc_mir_transform/src/validate.rs

@@ -707,6 +707,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         };
                         check_equal(self, location, *f_ty);
                     }
+                    // Debug info is allowed to project into pattern types
+                    ty::Pat(base, _) => check_equal(self, location, *base),
                     ty::Adt(adt_def, args) => {
                         // see <https://github.com/rust-lang/rust/blob/7601adcc764d42c9f2984082b49948af652df986/compiler/rustc_middle/src/ty/layout.rs#L861-L864>
                         if self.tcx.is_lang_item(adt_def.did(), LangItem::DynMetadata) {

compiler/rustc_monomorphize/src/collector.rs

@@ -1067,6 +1067,7 @@ fn find_tails_for_unsizing<'tcx>(
     debug_assert!(!target_ty.has_param(), "{target_ty} should be fully monomorphic");
 
     match (source_ty.kind(), target_ty.kind()) {
+        (&ty::Pat(source, _), &ty::Pat(target, _)) => find_tails_for_unsizing(tcx, source, target),
         (
             &ty::Ref(_, source_pointee, _),
             &ty::Ref(_, target_pointee, _) | &ty::RawPtr(target_pointee, _),

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

@@ -138,6 +138,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 &mut candidates,
                             );
                         }
+                        Some(LangItem::PointerLike) => {
+                            self.assemble_pointer_like_candidates(obligation, &mut candidates);
+                        }
                         Some(LangItem::AsyncFn | LangItem::AsyncFnMut | LangItem::AsyncFnOnce) => {
                             self.assemble_async_closure_candidates(obligation, &mut candidates);
                         }
@@ -485,6 +488,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
     }
 
+    fn assemble_pointer_like_candidates(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+        candidates: &mut SelectionCandidateSet<'tcx>,
+    ) {
+        match obligation.self_ty().skip_binder().kind() {
+            ty::Pat(..) => candidates.vec.push(PointerLikeCandidate),
+            _ => {}
+        }
+    }
+
     fn assemble_async_fn_kind_helper_candidates(
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,

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

@@ -117,6 +117,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
             }
 
+            PointerLikeCandidate => {
+                let data = self.confirm_pointer_like_candidate(obligation);
+                ImplSource::Builtin(BuiltinImplSource::Misc, data)
+            }
+
             TraitAliasCandidate => {
                 let data = self.confirm_trait_alias_candidate(obligation);
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
@@ -665,6 +670,25 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         Ok(nested)
     }
 
+    fn confirm_pointer_like_candidate(
+        &mut self,
+        obligation: &PolyTraitObligation<'tcx>,
+    ) -> PredicateObligations<'tcx> {
+        debug!(?obligation, "confirm_fn_pointer_candidate");
+        let placeholder_predicate = self.infcx.enter_forall_and_leak_universe(obligation.predicate);
+        let self_ty = self.infcx.shallow_resolve(placeholder_predicate.self_ty());
+        let ty::Pat(base, _) = *self_ty.kind() else { bug!() };
+        let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
+
+        self.collect_predicates_for_types(
+            obligation.param_env,
+            cause,
+            obligation.recursion_depth + 1,
+            placeholder_predicate.def_id(),
+            vec![base],
+        )
+    }
+
     fn confirm_trait_alias_candidate(
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,

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

@@ -1983,6 +1983,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinObjectCandidate
                 | BuiltinUnsizeCandidate
+                | PointerLikeCandidate
                 | BikeshedGuaranteedNoDropCandidate => false,
                 // Non-global param candidates have already been handled, global
                 // where-bounds get ignored.

compiler/rustc_ty_utils/src/abi.rs

@@ -724,14 +724,19 @@ fn make_thin_self_ptr<'tcx>(
         // To get the type `*mut RcInner<Self>`, we just keep unwrapping newtypes until we
         // get a built-in pointer type
         let mut wide_pointer_layout = layout;
-        while !wide_pointer_layout.ty.is_raw_ptr() && !wide_pointer_layout.ty.is_ref() {
-            wide_pointer_layout = wide_pointer_layout
-                .non_1zst_field(cx)
-                .expect("not exactly one non-1-ZST field in a `DispatchFromDyn` type")
-                .1
+        loop {
+            match *wide_pointer_layout.ty.kind() {
+                ty::Ref(..) | ty::RawPtr(..) => break wide_pointer_layout.ty,
+                ty::Pat(inner, _) => match inner.kind() {
+                    ty::RawPtr(..) => break inner,
+                    _ => panic!("only raw pointers are allowed in unsized pattern types"),
+                },
+                _ => wide_pointer_layout = wide_pointer_layout
+                    .non_1zst_field(cx)
+                    .unwrap_or_else(|| panic!("not exactly one non-1-ZST field in a `DispatchFromDyn` type: {wide_pointer_layout:#?}"))
+                    .1,
+            }
         }
-
-        wide_pointer_layout.ty
     };
 
     // we now have a type like `*mut RcInner<dyn Trait>`

library/core/src/pat.rs

@@ -1,5 +1,10 @@
 //! Helper module for exporting the `pattern_type` macro
 
+#[cfg(not(bootstrap))]
+use crate::marker::{Freeze, Unsize};
+#[cfg(not(bootstrap))]
+use crate::ops::{CoerceUnsized, DispatchFromDyn};
+
 /// Creates a pattern type.
 /// ```ignore (cannot test this from within core yet)
 /// type Positive = std::pat::pattern_type!(i32 is 1..);
@@ -74,3 +79,21 @@ impl const RangePattern for char {
         }
     }
 }
+
+#[cfg(not(bootstrap))]
+impl<T: ?Sized, U: ?Sized> CoerceUnsized<pattern_type!(*const U is !null)> for pattern_type!(*const T is !null) where
+    T: Unsize<U>
+{
+}
+
+#[cfg(not(bootstrap))]
+impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<pattern_type!(U is !null)> for pattern_type!(T is !null) {}
+
+#[cfg(not(bootstrap))]
+impl<T: ?Sized> Unpin for pattern_type!(*const T is !null) {}
+
+#[cfg(not(bootstrap))]
+unsafe impl<T: ?Sized> Freeze for pattern_type!(*const T is !null) {}
+
+#[cfg(not(bootstrap))]
+unsafe impl<T: ?Sized> Freeze for pattern_type!(*mut T is !null) {}