Remove all matching on Ty from deconstruct_pat

Author: Nadrieril

compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

@@ -49,11 +49,10 @@ use super::usefulness::{MatchCheckCtxt, PatCtxt};
 
 use rustc_apfloat::ieee::{DoubleS, IeeeFloat, SingleS};
 use rustc_data_structures::captures::Captures;
-use rustc_index::vec::Idx;
 
 use rustc_hir::{HirId, RangeEnd};
 use rustc_middle::ty::subst::GenericArg;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::Ty;
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::VariantIdx;
 
@@ -93,16 +92,6 @@ impl IntRange {
         (*self.range.start(), *self.range.end())
     }
 
-    // The return value of `signed_bias` should be XORed with an endpoint to encode/decode it.
-    #[inline]
-    fn signed_bias(ty: Ty<'_>, ty_size: rustc_target::abi::Size) -> u128 {
-        match *ty.kind() {
-            ty::Int(_) => 1u128 << (ty_size.bits() as u128 - 1),
-            ty::Char | ty::Uint(_) => 0,
-            _ => bug!("invalid type for `IntRange`: {}", ty),
-        }
-    }
-
     #[inline]
     pub(super) fn from_bits<'tcx>(
         ty: Ty<'tcx>,
@@ -111,7 +100,11 @@ impl IntRange {
         hi: u128,
         end: &RangeEnd,
     ) -> IntRange {
-        let bias = IntRange::signed_bias(ty, ty_size);
+        let bias = if MatchCheckCtxt::is_signed_int(ty) {
+            1u128 << (ty_size.bits() as u128 - 1)
+        } else {
+            0
+        };
         // Perform a shift if the underlying types are signed,
         // which makes the interval arithmetic simpler.
         let (lo, hi) = (lo ^ bias, hi ^ bias);
@@ -555,7 +548,7 @@ pub(super) enum Constructor<'tcx> {
     /// String literals. Strings are not quite the same as `&[u8]` so we treat them separately.
     Str(&'tcx [u8]),
     /// Array and slice patterns.
-    Slice(Slice),
+    Slice(Slice, Ty<'tcx>),
     /// Constants that must not be matched structurally. They are treated as black
     /// boxes for the purposes of exhaustiveness: we must not inspect them, and they
     /// don't count towards making a match exhaustive.
@@ -593,36 +586,19 @@ impl<'tcx> Constructor<'tcx> {
 
     fn as_slice(&self) -> Option<Slice> {
         match self {
-            Slice(slice) => Some(*slice),
+            Slice(slice, _) => Some(*slice),
             _ => None,
         }
     }
 
-    pub(super) fn variant_index_for_adt(&self, adt: &'tcx ty::AdtDef) -> VariantIdx {
-        match *self {
-            Variant(idx) => idx,
-            Single => {
-                assert!(!adt.is_enum());
-                VariantIdx::new(0)
-            }
-            _ => bug!("bad constructor {:?} for adt {:?}", self, adt),
-        }
-    }
-
     /// The number of fields for this constructor. This must be kept in sync with
     /// `Fields::wildcards`.
     pub(super) fn arity(&self, pcx: PatCtxt<'_, '_, 'tcx>) -> usize {
         match self {
-            Single | Variant(_) => match pcx.ty.kind() {
-                ty::Adt(adt, ..) => {
-                    let variant = &adt.variants[self.variant_index_for_adt(adt)];
-                    pcx.cx.list_variant_nonhidden_fields(pcx.ty, variant).count()
-                }
-                _ => bug!("Unexpected type for `Single` constructor: {:?}", pcx.ty),
-            },
+            Single | Variant(_) => pcx.cx.list_variant_nonhidden_fields(pcx.ty, self).count(),
             Tuple(fs) => fs.len(),
             Ref(_) | BoxPat(_) => 1,
-            Slice(slice) => slice.arity(),
+            Slice(slice, _) => slice.arity(),
             Str(..)
             | Bool(..)
             | IntRange(..)
@@ -671,11 +647,11 @@ impl<'tcx> Constructor<'tcx> {
                 split_range.split(int_ranges.cloned());
                 split_range.iter().map(IntRange).collect()
             }
-            &Slice(Slice { kind: VarLen(self_prefix, self_suffix), array_len }) => {
+            &Slice(Slice { kind: VarLen(self_prefix, self_suffix), array_len }, ty) => {
                 let mut split_self = SplitVarLenSlice::new(self_prefix, self_suffix, array_len);
                 let slices = ctors.filter_map(|c| c.as_slice()).map(|s| s.kind);
                 split_self.split(slices);
-                split_self.iter().map(Slice).collect()
+                split_self.iter().map(|s| Slice(s, ty)).collect()
             }
             // Any other constructor can be used unchanged.
             _ => smallvec![self.clone()],
@@ -724,7 +700,7 @@ impl<'tcx> Constructor<'tcx> {
                 }
             }
             (Str(self_val), Str(other_val)) => self_val == other_val,
-            (Slice(self_slice), Slice(other_slice)) => self_slice.is_covered_by(*other_slice),
+            (Slice(self_slice, _), Slice(other_slice, _)) => self_slice.is_covered_by(*other_slice),
 
             // We are trying to inspect an opaque constant. Thus we skip the row.
             (Opaque, _) | (_, Opaque) => false,
@@ -765,7 +741,7 @@ impl<'tcx> Constructor<'tcx> {
                 .iter()
                 .filter_map(|c| c.as_int_range())
                 .any(|other| range.is_covered_by(other)),
-            Slice(slice) => used_ctors
+            Slice(slice, _) => used_ctors
                 .iter()
                 .filter_map(|c| c.as_slice())
                 .any(|other| slice.is_covered_by(other)),
@@ -866,8 +842,7 @@ impl<'tcx> SplitWildcard<'tcx> {
             //
             // The exception is: if we are at the top-level, for example in an empty match, we
             // sometimes prefer reporting the list of constructors instead of just `_`.
-            let report_when_all_missing = pcx.is_top_level
-                && !matches!(pcx.ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_));
+            let report_when_all_missing = pcx.is_top_level && !MatchCheckCtxt::is_numeric(pcx.ty);
             let ctor = if !self.matrix_ctors.is_empty() || report_when_all_missing {
                 if pcx.is_non_exhaustive {
                     Missing {
@@ -953,23 +928,16 @@ impl<'p, 'tcx> Fields<'p, 'tcx> {
         constructor: &Constructor<'tcx>,
     ) -> Self {
         let ret = match constructor {
-            Single | Variant(_) => match ty.kind() {
-                ty::Adt(adt, _) => {
-                    let variant = &adt.variants[constructor.variant_index_for_adt(adt)];
-                    let tys = cx.list_variant_nonhidden_fields(ty, variant).map(|(_, ty)| ty);
-                    Fields::wildcards_from_tys(cx, tys)
-                }
-                _ => bug!("Unexpected type for `Single` constructor: {:?}", ty),
-            },
+            Single | Variant(_) => {
+                let tys = cx.list_variant_nonhidden_fields(ty, constructor).map(|(_, ty)| ty);
+                Fields::wildcards_from_tys(cx, tys)
+            }
             Tuple(fs) => Fields::wildcards_from_tys(cx, fs.iter().map(|ty| ty.expect_ty())),
             Ref(ty) | BoxPat(ty) => Fields::wildcards_from_tys(cx, once(*ty)),
-            Slice(slice) => match *ty.kind() {
-                ty::Slice(ty) | ty::Array(ty, _) => {
-                    let arity = slice.arity();
-                    Fields::wildcards_from_tys(cx, (0..arity).map(|_| ty))
-                }
-                _ => bug!("bad slice pattern {:?} {:?}", constructor, ty),
-            },
+            Slice(slice, ty) => {
+                let arity = slice.arity();
+                Fields::wildcards_from_tys(cx, (0..arity).map(|_| *ty))
+            }
             Str(..)
             | Bool(..)
             | IntRange(..)
@@ -1068,7 +1036,7 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
                 // We return a wildcard for each field of `other_ctor`.
                 Fields::wildcards(cx, self.ty, other_ctor).iter_patterns().collect()
             }
-            (Slice(self_slice), Slice(other_slice))
+            (Slice(self_slice, inner_ty), Slice(other_slice, _))
                 if self_slice.arity() != other_slice.arity() =>
             {
                 // The only tricky case: two slices of different arity. Since `self_slice` covers
@@ -1079,10 +1047,6 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
                 match self_slice.kind {
                     FixedLen(_) => bug!("{:?} doesn't cover {:?}", self_slice, other_slice),
                     VarLen(prefix, suffix) => {
-                        let inner_ty = match *self.ty.kind() {
-                            ty::Slice(ty) | ty::Array(ty, _) => ty,
-                            _ => bug!("bad slice pattern {:?} {:?}", self.ctor, self.ty),
-                        };
                         let prefix = &self.fields.fields[..prefix];
                         let suffix = &self.fields.fields[self_slice.arity() - suffix..];
                         let wildcard: &_ =
@@ -1143,14 +1107,8 @@ impl<'p, 'tcx> fmt::Debug for DeconstructedPat<'p, 'tcx> {
 
         match &self.ctor {
             Single | Variant(_) | Tuple(_) => {
-                let variant = match self.ty.kind() {
-                    ty::Adt(adt, _) => Some(&adt.variants[self.ctor.variant_index_for_adt(adt)]),
-                    ty::Tuple(_) => None,
-                    _ => unreachable!(),
-                };
-
-                if let Some(variant) = variant {
-                    write!(f, "{}", variant.ident)?;
+                if let Some(ident) = MatchCheckCtxt::variant_ident(self.ty(), self.ctor()) {
+                    write!(f, "{}", ident)?;
                 }
 
                 // Without `cx`, we can't know which field corresponds to which, so we can't
@@ -1171,7 +1129,7 @@ impl<'p, 'tcx> fmt::Debug for DeconstructedPat<'p, 'tcx> {
                 let subpattern = self.iter_fields().next().unwrap();
                 write!(f, "box {:?}", subpattern)
             }
-            Slice(slice) => {
+            Slice(slice, _) => {
                 let mut subpatterns = self.fields.iter_patterns();
                 write!(f, "[")?;
                 match slice.kind {

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -24,12 +24,13 @@ use rustc_middle::mir::interpret::{
 };
 use rustc_middle::mir::{BorrowKind, Field, Mutability};
 use rustc_middle::thir::{Ascription, BindingMode, FieldPat, Pat, PatKind, PatRange, PatTyProj};
-use rustc_middle::ty::{self, ConstKind, DefIdTree, Ty, TyCtxt, VariantDef};
+use rustc_middle::ty::{self, ConstKind, DefIdTree, Ty, TyCtxt};
 use rustc_span::{Span, DUMMY_SP};
-use rustc_target::abi::Size;
+use rustc_target::abi::{Size, VariantIdx};
 
 use smallvec::{smallvec, SmallVec};
 use std::cmp::Ordering;
+use std::fmt::Display;
 
 #[derive(Clone, Debug)]
 crate enum PatternError {
@@ -734,18 +735,21 @@ fn pat_to_deconstructed<'p, 'tcx>(
                     fields = Fields::singleton(cx, DeconstructedPat::wildcard(inner_ty));
                 }
                 ty::Adt(adt, _) => {
-                    ctor = match pat.kind.as_ref() {
-                        PatKind::Leaf { .. } => Constructor::Single,
+                    let variant = match *pat.kind {
+                        PatKind::Leaf { .. } => {
+                            ctor = Constructor::Single;
+                            adt.non_enum_variant()
+                        }
                         PatKind::Variant { variant_index, .. } => {
-                            Constructor::Variant(*variant_index)
+                            ctor = Constructor::Variant(variant_index);
+                            &adt.variants[variant_index]
                         }
                         _ => bug!(),
                     };
-                    let variant = &adt.variants[ctor.variant_index_for_adt(adt)];
                     // For each field in the variant, we store the relevant index into `self.fields` if any.
                     let mut field_id_to_id: Vec<Option<usize>> =
                         (0..variant.fields.len()).map(|_| None).collect();
-                    let tys = cx.list_variant_nonhidden_fields(pat.ty, variant).enumerate().map(
+                    let tys = cx.list_variant_nonhidden_fields(pat.ty, &ctor).enumerate().map(
                         |(i, (field, ty))| {
                             field_id_to_id[field.index()] = Some(i);
                             ty
@@ -847,17 +851,19 @@ fn pat_to_deconstructed<'p, 'tcx>(
             fields = Fields::empty();
         }
         PatKind::Array { prefix, slice, suffix } | PatKind::Slice { prefix, slice, suffix } => {
-            let array_len = match pat.ty.kind() {
-                ty::Array(_, length) => Some(length.eval_usize(cx.tcx, cx.param_env) as usize),
-                ty::Slice(_) => None,
+            let (ty, array_len) = match pat.ty.kind() {
+                ty::Array(ty, length) => {
+                    (ty, Some(length.eval_usize(cx.tcx, cx.param_env) as usize))
+                }
+                ty::Slice(ty) => (ty, None),
                 _ => span_bug!(pat.span, "bad ty {:?} for slice pattern", pat.ty),
             };
             let kind = if slice.is_some() {
                 SliceKind::VarLen(prefix.len(), suffix.len())
             } else {
                 SliceKind::FixedLen(prefix.len() + suffix.len())
             };
-            ctor = Constructor::Slice(Slice::new(array_len, kind));
+            ctor = Constructor::Slice(Slice::new(array_len, kind), ty);
             fields = Fields::from_iter(cx, prefix.iter().chain(suffix).map(mkpat));
         }
         PatKind::Or { .. } => {
@@ -893,10 +899,13 @@ fn deconstructed_to_pat<'p, 'tcx>(
     let kind = match pat.ctor() {
         Single | Variant(_) => match pat.ty().kind() {
             ty::Adt(adt_def, substs) => {
-                let variant_index = pat.ctor().variant_index_for_adt(adt_def);
-                let variant = &adt_def.variants[variant_index];
+                let variant_index = match pat.ctor() {
+                    Variant(idx) => *idx,
+                    Single => VariantIdx::new(0),
+                    _ => bug!("bad constructor {:?} for adt", pat.ctor()),
+                };
                 let subpatterns = cx
-                    .list_variant_nonhidden_fields(pat.ty(), variant)
+                    .list_variant_nonhidden_fields(pat.ty(), pat.ctor())
                     .zip(subpatterns)
                     .map(|((field, _ty), pattern)| FieldPat { field, pattern })
                     .collect();
@@ -920,7 +929,7 @@ fn deconstructed_to_pat<'p, 'tcx>(
         // string literal pattern will never be reported as a non-exhaustiveness witness, so we
         // ignore this issue.
         Ref(_) | BoxPat(_) => PatKind::Deref { subpattern: subpatterns.next().unwrap() },
-        Slice(slice) => {
+        Slice(slice, _) => {
             match slice.kind {
                 SliceKind::FixedLen(_) => {
                     PatKind::Slice { prefix: subpatterns.collect(), slice: None, suffix: vec![] }
@@ -977,6 +986,14 @@ fn deconstructed_to_pat<'p, 'tcx>(
 }
 
 impl<'p, 'tcx> MatchCheckCtxt<'p, 'tcx> {
+    fn is_numeric(ty: Ty<'tcx>) -> bool {
+        matches!(ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_))
+    }
+
+    fn is_signed_int(ty: Ty<'tcx>) -> bool {
+        matches!(ty.kind(), ty::Int(_))
+    }
+
     fn is_uninhabited(&self, ty: Ty<'tcx>) -> bool {
         if self.tcx.features().exhaustive_patterns {
             self.tcx.is_ty_uninhabited_from(self.module, ty, self.param_env)
@@ -1109,22 +1126,23 @@ impl<'p, 'tcx> MatchCheckCtxt<'p, 'tcx> {
             ty::Ref(_, ty, _) => smallvec![Ref(*ty)],
             ty::Tuple(fs) => smallvec![Tuple(*fs)],
             ty::Array(sub_ty, len) => {
-                match len.try_eval_usize(cx.tcx, cx.param_env) {
+                let slice = match len.try_eval_usize(cx.tcx, cx.param_env) {
                     Some(len) => {
                         // The uninhabited case is already handled.
-                        smallvec![Slice(self::Slice::new(Some(len as usize), VarLen(0, 0)))]
+                        self::Slice::new(Some(len as usize), VarLen(0, 0))
                     }
                     None => {
                         // Treat arrays of a constant but unknown length like slices.
                         let kind =
                             if cx.is_uninhabited(sub_ty) { FixedLen(0) } else { VarLen(0, 0) };
-                        smallvec![Slice(self::Slice::new(None, kind))]
+                        self::Slice::new(None, kind)
                     }
-                }
+                };
+                smallvec![Slice(slice, sub_ty)]
             }
             ty::Slice(sub_ty) => {
                 let kind = if cx.is_uninhabited(sub_ty) { FixedLen(0) } else { VarLen(0, 0) };
-                smallvec![Slice(self::Slice::new(None, kind))]
+                smallvec![Slice(self::Slice::new(None, kind), sub_ty)]
             }
             // If `exhaustive_patterns` is disabled and our scrutinee is the never type, we don't
             // expose its emptiness and return `NonExhaustive` below. The exception is if the
@@ -1137,19 +1155,41 @@ impl<'p, 'tcx> MatchCheckCtxt<'p, 'tcx> {
         }
     }
 
+    /// Show the name of the variant corresponding to this constructor.
+    /// `ty` must be `ty::Adt`, and `ctor` must be a constructor for that type.
+    fn variant_ident(ty: Ty<'tcx>, ctor: &Constructor<'tcx>) -> Option<impl Display> {
+        match ty.kind() {
+            ty::Adt(adt, _) => {
+                let variant = match ctor {
+                    Constructor::Variant(idx) => &adt.variants[*idx],
+                    Constructor::Single => adt.non_enum_variant(),
+                    _ => return None,
+                };
+                Some(variant.ident)
+            }
+            _ => None,
+        }
+    }
+
     /// List the fields for this variant.
     /// In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide
     /// uninhabited fields in order not to reveal the uninhabitedness of the whole variant.
+    /// `ty` must be `ty::Adt`, and `ctor` must be a constructor for that type.
     fn list_variant_nonhidden_fields<'a>(
         &'a self,
         ty: Ty<'tcx>,
-        variant: &'a VariantDef,
+        ctor: &Constructor<'tcx>,
     ) -> impl Iterator<Item = (Field, Ty<'tcx>)> + Captures<'a> + Captures<'p> {
         let cx = self;
         let (adt, substs) = match ty.kind() {
             ty::Adt(adt, substs) => (adt, substs),
             _ => bug!(),
         };
+        let variant = match ctor {
+            Constructor::Variant(variant_index) => &adt.variants[*variant_index],
+            Constructor::Single => adt.non_enum_variant(),
+            _ => bug!("bad constructor {:?} for adt {:?}", ctor, ty),
+        };
         // Whether we must not match the fields of this variant exhaustively.
         let is_non_exhaustive = variant.is_field_list_non_exhaustive() && !adt.did.is_local();