Actually create ranged types

Author: oli-obk

compiler/rustc_borrowck/src/lib.rs

@@ -2103,6 +2103,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                     ProjectionElem::Deref => {
                         let base_ty = place_base.ty(self.body(), self.infcx.tcx).ty;
 
+                        let base_ty = match *base_ty.kind() {
+                            ty::Pat(inner, _) => inner,
+                            _ => base_ty,
+                        };
+
                         // Check the kind of deref to decide
                         match base_ty.kind() {
                             ty::Ref(_, _, mutbl) => {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -433,6 +433,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
         }
     }
 
+    #[instrument(level = "trace", skip(self))]
     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
         self.super_rvalue(rvalue, location);
         let rval_ty = rvalue.ty(self.body(), self.tcx());
@@ -517,14 +518,13 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
 
     /// Checks that the types internal to the `place` match up with
     /// what would be expected.
+    #[instrument(level = "trace", skip(self), ret)]
     fn sanitize_place(
         &mut self,
         place: &Place<'tcx>,
         location: Location,
         context: PlaceContext,
     ) -> PlaceTy<'tcx> {
-        debug!("sanitize_place: {:?}", place);
-
         let mut place_ty = PlaceTy::from_ty(self.body().local_decls[place.local].ty);
 
         for elem in place.projection.iter() {
@@ -630,14 +630,14 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         }
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     fn sanitize_projection(
         &mut self,
         base: PlaceTy<'tcx>,
         pi: PlaceElem<'tcx>,
         place: &Place<'tcx>,
         location: Location,
     ) -> PlaceTy<'tcx> {
-        debug!("sanitize_projection: {:?} {:?} {:?}", base, pi, place);
         let tcx = self.tcx();
         let base_ty = base.ty;
         match pi {
@@ -1310,6 +1310,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 self.check_operand(discr, term_location);
 
                 let switch_ty = discr.ty(body, tcx);
+                let switch_ty = switch_ty.strip_pattern().unwrap_or(switch_ty);
                 if !switch_ty.is_integral() && !switch_ty.is_char() && !switch_ty.is_bool() {
                     span_mirbug!(self, term, "bad SwitchInt discr ty {:?}", switch_ty);
                 }
@@ -2107,6 +2108,66 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             }
                         }
                     }
+                    CastKind::Patternize => {
+                        let ty_from = op.ty(body, tcx);
+                        let cast_ty_to = CastTy::from_ty(*ty);
+                        match cast_ty_to {
+                            Some(CastTy::Pat(to)) => {
+                                if let Err(terr) = self.eq_types(
+                                    ty_from,
+                                    to,
+                                    location.to_locations(),
+                                    ConstraintCategory::Cast,
+                                ) {
+                                    span_mirbug!(
+                                        self,
+                                        rvalue,
+                                        "relating {:?} with {:?} yields {:?}",
+                                        ty_from,
+                                        to,
+                                        terr
+                                    )
+                                }
+                            }
+                            _ => {
+                                span_mirbug!(
+                                    self,
+                                    rvalue,
+                                    "Invalid Patternize cast {ty_from} -> {ty}",
+                                )
+                            }
+                        }
+                    }
+                    CastKind::StripPattern => {
+                        let ty_from = op.ty(body, tcx);
+                        let cast_ty_from = CastTy::from_ty(ty_from);
+                        match cast_ty_from {
+                            Some(CastTy::Pat(from)) => {
+                                if let Err(terr) = self.eq_types(
+                                    *ty,
+                                    from,
+                                    location.to_locations(),
+                                    ConstraintCategory::Cast,
+                                ) {
+                                    span_mirbug!(
+                                        self,
+                                        rvalue,
+                                        "relating {:?} with {:?} yields {:?}",
+                                        ty,
+                                        from,
+                                        terr
+                                    )
+                                }
+                            }
+                            _ => {
+                                span_mirbug!(
+                                    self,
+                                    rvalue,
+                                    "Invalid StripPattern cast {ty_from} -> {ty}",
+                                )
+                            }
+                        }
+                    }
                     CastKind::IntToFloat => {
                         let ty_from = op.ty(body, tcx);
                         let cast_ty_from = CastTy::from_ty(ty_from);
@@ -2427,6 +2488,11 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 ProjectionElem::Deref => {
                     let base_ty = Place::ty_from(borrowed_place.local, proj_base, body, tcx).ty;
 
+                    let base_ty = match *base_ty.kind() {
+                        ty::Pat(inner, _) => inner,
+                        _ => base_ty,
+                    };
+
                     debug!("add_reborrow_constraint - base_ty = {:?}", base_ty);
                     match base_ty.kind() {
                         ty::Ref(ref_region, _, mutbl) => {

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -462,6 +462,7 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
         ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
         // Type parameters from polymorphized functions.
         ty::Param(_) => build_param_type_di_node(cx, t),
+        ty::Pat(inner, _) => return type_di_node(cx, inner),
         _ => bug!("debuginfo: unexpected type in type_di_node(): {:?}", t),
     };
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -256,6 +256,9 @@ pub fn unsize_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             // HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
             (bx.bitcast(lldata, lldata_ty), bx.bitcast(llextra, llextra_ty))
         }
+        (&ty::Pat(a, a_pat), &ty::Pat(b, b_pat)) if a_pat == b_pat => {
+            unsize_ptr(bx, src, a, b, old_info)
+        }
         _ => bug!("unsize_ptr: called on bad types"),
     }
 }

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -219,7 +219,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             _ => bug!("{} cannot be cast to a fn ptr", operand.layout.ty),
                         }
                     }
-                    mir::CastKind::Pointer(PointerCast::UnsafeFnPointer) => {
+                    mir::CastKind::Patternize
+                    | mir::CastKind::StripPattern
+                    | mir::CastKind::Pointer(PointerCast::UnsafeFnPointer) => {
                         // This is a no-op at the LLVM level.
                         operand.val
                     }

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -25,6 +25,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         use rustc_middle::mir::CastKind::*;
         // FIXME: In which cases should we trigger UB when the source is uninit?
         match cast_kind {
+            Patternize | StripPattern => {
+                self.copy_op(src, dest, true)?;
+            }
+
             Pointer(PointerCast::Unsize) => {
                 let cast_ty = self.layout_of(cast_ty)?;
                 self.unsize_into(src, cast_ty, dest)?;
@@ -368,10 +372,14 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         dest: &PlaceTy<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx> {
         trace!("Unsizing {:?} of type {} into {:?}", *src, src.layout.ty, cast_ty.ty);
-        match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
+        let (src_ty, target_ty) = match (src.layout.ty.kind(), cast_ty.ty.kind()) {
+            (&ty::Pat(a, pat_a), &ty::Pat(b, pat_b)) if pat_a == pat_b => (a, b),
+            _ => (src.layout.ty, cast_ty.ty),
+        };
+        match (src_ty.kind(), target_ty.kind()) {
             (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(TypeAndMut { ty: c, .. }))
             | (&ty::RawPtr(TypeAndMut { ty: s, .. }), &ty::RawPtr(TypeAndMut { ty: c, .. })) => {
-                self.unsize_into_ptr(src, dest, *s, *c)
+                self.unsize_into_ptr(src, dest, s, c)
             }
             (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
                 assert_eq!(def_a, def_b);

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -491,7 +491,27 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
     ) -> InterpResult<'tcx, bool> {
         // Go over all the primitive types
         let ty = value.layout.ty;
-        match ty.kind() {
+        match *ty.kind() {
+            ty::Pat(inner, _) => {
+                let mut value = value.clone();
+                value.layout.ty = inner;
+                // First visit the inner type to report more targetted errors
+                // if the value is already not valid at the inner type.
+                self.visit_value(&value)?;
+                // Then check the extra pattern restrictions.
+                let scalar = self.read_immediate(&value, "initialized scalar value")?;
+                match (*scalar, value.layout.abi) {
+                    (Immediate::Scalar(scalar), Abi::Scalar(s))
+                    | (Immediate::ScalarPair(scalar, _), Abi::ScalarPair(s, _)) => {
+                        self.visit_scalar(scalar, s)?
+                    }
+                    other => span_bug!(
+                        self.ecx.cur_span(),
+                        "invalid abi {other:?} for pattern type {ty:?}"
+                    ),
+                }
+                Ok(true)
+            }
             ty::Bool => {
                 let value = self.read_scalar(value, "a boolean")?;
                 try_validation!(
@@ -545,11 +565,11 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
             }
             ty::Ref(_, ty, mutbl) => {
                 if matches!(self.ctfe_mode, Some(CtfeValidationMode::Const { .. }))
-                    && *mutbl == Mutability::Mut
+                    && mutbl == Mutability::Mut
                 {
                     // A mutable reference inside a const? That does not seem right (except if it is
                     // a ZST).
-                    let layout = self.ecx.layout_of(*ty)?;
+                    let layout = self.ecx.layout_of(ty)?;
                     if !layout.is_zst() {
                         throw_validation_failure!(self.path, { "mutable reference in a `const`" });
                     }
@@ -584,7 +604,6 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 // Nothing to check.
                 Ok(true)
             }
-            ty::Pat(..) => unimplemented!(),
             // The above should be all the primitive types. The rest is compound, we
             // check them by visiting their fields/variants.
             ty::Adt(..)
@@ -779,7 +798,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
             Abi::Scalar(scalar_layout) => {
                 if !scalar_layout.is_uninit_valid() {
                     // There is something to check here.
-                    let scalar = self.read_scalar(op, "initiailized scalar value")?;
+                    let scalar = self.read_scalar(op, "initialized scalar value")?;
                     self.visit_scalar(scalar, scalar_layout)?;
                 }
             }
@@ -789,7 +808,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
                 // the other must be init.
                 if !a_layout.is_uninit_valid() && !b_layout.is_uninit_valid() {
                     let (a, b) =
-                        self.read_immediate(op, "initiailized scalar value")?.to_scalar_pair();
+                        self.read_immediate(op, "initialized scalar value")?.to_scalar_pair();
                     self.visit_scalar(a, a_layout)?;
                     self.visit_scalar(b, b_layout)?;
                 }

compiler/rustc_const_eval/src/interpret/visitor.rs

@@ -49,6 +49,9 @@ pub trait Value<'mir, 'tcx, M: Machine<'mir, 'tcx>>: Sized {
         ecx: &InterpCx<'mir, 'tcx, M>,
         field: usize,
     ) -> InterpResult<'tcx, Self>;
+
+    /// Strip a layer of pattern types to get at the inner type
+    fn strip_pat_ty(self) -> Self;
 }
 
 /// A thing that we can project into given *mutable* access to `ecx`, and that has a layout.
@@ -88,6 +91,9 @@ pub trait ValueMut<'mir, 'tcx, M: Machine<'mir, 'tcx>>: Sized {
         ecx: &mut InterpCx<'mir, 'tcx, M>,
         field: usize,
     ) -> InterpResult<'tcx, Self>;
+
+    /// Strip a layer of pattern types to get at the inner type
+    fn strip_pat_ty(self) -> Self;
 }
 
 // We cannot have a general impl which shows that Value implies ValueMut. (When we do, it says we
@@ -131,6 +137,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> Value<'mir, 'tcx, M> for OpTy<'tc
     ) -> InterpResult<'tcx, Self> {
         ecx.operand_field(self, field)
     }
+
+    #[inline(always)]
+    fn strip_pat_ty(mut self) -> Self {
+        let ty::Pat(raw_ptr_ty, _) = *self.layout.ty.kind() else {
+            bug!("NonNull must contain a pattern type, but had {}", self.layout.ty)
+        };
+        self.layout.ty = raw_ptr_ty;
+        self
+    }
 }
 
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
@@ -179,6 +194,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
     ) -> InterpResult<'tcx, Self> {
         ecx.operand_field(self, field)
     }
+
+    #[inline(always)]
+    fn strip_pat_ty(mut self) -> Self {
+        let ty::Pat(raw_ptr_ty, _) = *self.layout.ty.kind() else {
+            bug!("NonNull must contain a pattern type, but had {}", self.layout.ty)
+        };
+        self.layout.ty = raw_ptr_ty;
+        self
+    }
 }
 
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> Value<'mir, 'tcx, M>
@@ -220,6 +244,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> Value<'mir, 'tcx, M>
     ) -> InterpResult<'tcx, Self> {
         ecx.mplace_field(self, field)
     }
+
+    #[inline(always)]
+    fn strip_pat_ty(mut self) -> Self {
+        let ty::Pat(raw_ptr_ty, _) = *self.layout.ty.kind() else {
+            bug!("NonNull must contain a pattern type, but had {}", self.layout.ty)
+        };
+        self.layout.ty = raw_ptr_ty;
+        self
+    }
 }
 
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
@@ -269,6 +302,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
     ) -> InterpResult<'tcx, Self> {
         ecx.mplace_field(self, field)
     }
+
+    #[inline(always)]
+    fn strip_pat_ty(mut self) -> Self {
+        let ty::Pat(raw_ptr_ty, _) = *self.layout.ty.kind() else {
+            bug!("NonNull must contain a pattern type, but had {}", self.layout.ty)
+        };
+        self.layout.ty = raw_ptr_ty;
+        self
+    }
 }
 
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
@@ -320,6 +362,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueMut<'mir, 'tcx, M>
     ) -> InterpResult<'tcx, Self> {
         ecx.place_field(self, field)
     }
+
+    #[inline(always)]
+    fn strip_pat_ty(mut self) -> Self {
+        let ty::Pat(raw_ptr_ty, _) = *self.layout.ty.kind() else {
+            bug!("NonNull must contain a pattern type, but had {}", self.layout.ty)
+        };
+        self.layout.ty = raw_ptr_ty;
+        self
+    }
 }
 
 macro_rules! make_value_visitor {
@@ -466,7 +517,7 @@ macro_rules! make_value_visitor {
                         );
                         // ... that contains a `NonNull`... (gladly, only a single field here)
                         assert_eq!(nonnull_ptr.layout().fields.count(), 1);
-                        let raw_ptr = nonnull_ptr.project_field(self.ecx(), 0)?; // the actual raw ptr
+                        let raw_ptr = nonnull_ptr.project_field(self.ecx(), 0)?.strip_pat_ty(); // the actual raw ptr
                         // ... whose only field finally is a raw ptr we can dereference.
                         self.visit_box(&raw_ptr)?;