Allow unsizing pattern types with pointer base

Author: oli-obk

compiler/rustc_codegen_cranelift/src/unsize.rs

@@ -133,6 +133,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

@@ -342,6 +342,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

@@ -227,6 +227,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_const_eval/src/interpret/cast.rs

@@ -460,6 +460,12 @@ 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_pat), &ty::Pat(cast_ty, c_pat)) if s_pat == c_pat => {
+                let src = self.project_field(src, FieldIdx::ZERO)?;
+                let dest = self.project_field(dest, FieldIdx::ZERO)?;
+                let cast_ty = self.layout_of(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_hir_analysis/messages.ftl

@@ -106,6 +106,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

@@ -252,6 +252,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 =>
         {
@@ -417,6 +429,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(SubregionOrigin::RelateObjectBound(span), r_b, r_a);
             let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };

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

@@ -1268,6 +1268,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

@@ -154,6 +154,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_mir_transform/src/validate.rs

@@ -709,6 +709,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) {