Coerce pattern types to their base type

Author: oli-obk

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2176,6 +2176,21 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             }
                         }
                     }
+                    CastKind::StripPat => {
+                        let ty_from = op.ty(body, tcx);
+                        match ty_from.kind() {
+                            ty::Pat(base, _) if base == ty => (),
+                            _ => {
+                                span_mirbug!(
+                                    self,
+                                    rvalue,
+                                    "Invalid StripPat cast {:?} -> {:?}",
+                                    ty_from,
+                                    ty
+                                )
+                            }
+                        }
+                    }
                     CastKind::Transmute => {
                         span_mirbug!(
                             self,

compiler/rustc_codegen_cranelift/src/base.rs

@@ -793,7 +793,7 @@ fn codegen_stmt<'tcx>(
                     let operand = codegen_operand(fx, operand);
                     crate::unsize::coerce_dyn_star(fx, operand, lval);
                 }
-                Rvalue::Cast(CastKind::Transmute, ref operand, _to_ty) => {
+                Rvalue::Cast(CastKind::Transmute | CastKind::StripPat, ref operand, _to_ty) => {
                     let operand = codegen_operand(fx, operand);
                     lval.write_cvalue_transmute(fx, operand);
                 }

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -599,7 +599,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 bug!("Unsupported cast of {operand:?} to {cast:?}");
                             })
                     }
-                    mir::CastKind::Transmute => {
+                    mir::CastKind::StripPat | mir::CastKind::Transmute => {
                         self.codegen_transmute_operand(bx, operand, cast).unwrap_or_else(|| {
                             bug!("Unsupported transmute-as-operand of {operand:?} to {cast:?}");
                         })

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -141,7 +141,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
             }
 
-            CastKind::Transmute => {
+            CastKind::StripPat | CastKind::Transmute => {
                 assert!(src.layout.is_sized());
                 assert!(dest.layout.is_sized());
                 assert_eq!(cast_ty, dest.layout.ty); // we otherwise ignore `cast_ty` enirely...

compiler/rustc_hir_typeck/src/cast.rs

@@ -838,6 +838,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             (Int(Char) | Int(Bool), Int(_)) => Ok(CastKind::PrimIntCast),
 
             (Int(_) | Float, Int(_) | Float) => Ok(CastKind::NumericCast),
+            (Pat, _) => Err(CastError::IllegalCast),
+            (_, Pat) => Err(CastError::IllegalCast),
         }
     }
 

compiler/rustc_hir_typeck/src/coercion.rs

@@ -57,7 +57,7 @@ use rustc_middle::ty::adjustment::{
 };
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::visit::TypeVisitableExt;
-use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt};
+use rustc_middle::ty::{self, GenericArgsRef, Pattern, Ty, TyCtxt};
 use rustc_session::parse::feature_err;
 use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Span, sym};
 use rustc_trait_selection::infer::InferCtxtExt as _;
@@ -259,6 +259,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // It cannot convert closures that require unsafe.
                 self.coerce_closure_to_fn(a, closure_def_id_a, args_a, b)
             }
+            ty::Pat(base, pat) => self.coerce_from_pat_ty(base, pat, b),
             _ => {
                 // Otherwise, just use unification rules.
                 self.unify_and(a, b, identity)
@@ -1017,6 +1018,24 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         }
     }
 
+    fn coerce_from_pat_ty(
+        &self,
+        base: Ty<'tcx>,
+        pat: Pattern<'tcx>,
+        b: Ty<'tcx>,
+    ) -> CoerceResult<'tcx> {
+        match *b.kind() {
+            // FIXME(pattern_types): allow coercion to less restrictive patterns
+            ty::Pat(b_base, b_pat) if b_pat == pat => self.unify_and(base, b_base, identity),
+            // Coercing to anything but a pattern type only works by dismissing the pattern
+            _ => {
+                let mut coerce = self.unify_and(base, b, identity)?;
+                coerce.value.0.insert(0, Adjustment { kind: Adjust::StripPattern, target: base });
+                Ok(coerce)
+            }
+        }
+    }
+
     fn coerce_raw_ptr(
         &self,
         a: Ty<'tcx>,

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -762,7 +762,9 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         for adjustment in adjustments {
             debug!("walk_adjustment expr={:?} adj={:?}", expr, adjustment);
             match adjustment.kind {
-                adjustment::Adjust::NeverToAny | adjustment::Adjust::Pointer(_) => {
+                adjustment::Adjust::StripPattern
+                | adjustment::Adjust::NeverToAny
+                | adjustment::Adjust::Pointer(_) => {
                     // Creating a closure/fn-pointer or unsizing consumes
                     // the input and stores it into the resulting rvalue.
                     self.consume_or_copy(&place_with_id, place_with_id.hir_id);
@@ -1325,6 +1327,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             adjustment::Adjust::NeverToAny
             | adjustment::Adjust::Pointer(_)
             | adjustment::Adjust::Borrow(_)
+            | adjustment::Adjust::StripPattern
             | adjustment::Adjust::ReborrowPin(..) => {
                 // Result is an rvalue.
                 Ok(self.cat_rvalue(expr.hir_id, target))

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -281,7 +281,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // FIXME(const_trait_impl): We could enforce these; they correspond to
                     // `&mut T: DerefMut` tho, so it's kinda moot.
                 }
-                Adjust::Borrow(_) => {
+                Adjust::StripPattern | Adjust::Borrow(_) => {
                     // No effects to enforce here.
                 }
             }
@@ -321,11 +321,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     }
 
                     (
-                        &mut [
+                        [
                             Adjustment { kind: Adjust::Deref(_), .. },
                             Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
                         ],
-                        &[
+                        [
                             Adjustment { kind: Adjust::Deref(_), .. },
                             .., // Any following adjustments are allowed.
                         ],
@@ -334,6 +334,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         *entry.get_mut() = adj;
                     }
 
+                    (
+                        [Adjustment { kind: Adjust::StripPattern, .. }],
+                        [Adjustment { kind: Adjust::Borrow(_), .. }, ..],
+                    ) => {
+                        entry.get_mut().extend(adj);
+                    }
+
                     _ => {
                         // FIXME: currently we never try to compose autoderefs
                         // and ReifyFnPointer/UnsafeFnPointer, but we could.

compiler/rustc_middle/src/mir/statement.rs

@@ -662,6 +662,7 @@ impl<'tcx> Rvalue<'tcx> {
                 | CastKind::PtrToPtr
                 | CastKind::PointerCoercion(_, _)
                 | CastKind::PointerWithExposedProvenance
+                | CastKind::StripPat
                 | CastKind::Transmute,
                 _,
                 _,

compiler/rustc_middle/src/mir/syntax.rs

@@ -1440,6 +1440,9 @@ pub enum CastKind {
     ///
     /// Allowed only in [`MirPhase::Runtime`]; Earlier it's a [`TerminatorKind::Call`].
     Transmute,
+    /// Removing the pattern of a pattern type and yielding the base type is entirely
+    /// safe and requires no additional checks.
+    StripPat,
 }
 
 /// Represents how a [`CastKind::PointerCoercion`] was constructed.