narrow the bug down to place locations

Author: xacrimon

compiler/rustc_mir_build/src/builder/matches/match_pair.rs

@@ -30,16 +30,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
     // We don't consider an empty subslice as a constant pattern subslice.
     fn is_constant_pattern_subslice(&self, subslice: &[Box<Pat<'tcx>>]) -> bool {
-        !subslice.is_empty() && subslice.iter().all(|p| self.is_constant_pattern(p))
+        subslice.len() > 1 && subslice.iter().all(|p| self.is_constant_pattern(p))
     }
 
     // TODO: expand beyond u8
     fn is_constant_pattern(&self, pat: &Pat<'tcx>) -> bool {
         if let PatKind::Constant { value } = pat.kind
             && let Const::Ty(_, const_) = value
             && let ty::ConstKind::Value(ty, valtree) = const_.kind()
+            && let ty::ValTree::Leaf(scalar) = valtree
             && self.tcx.types.u8 == ty
-            && matches!(valtree, ty::ValTree::Leaf(_))
+            && scalar.to_u8() != b'_'
         {
             true
         } else {
@@ -78,7 +79,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         valtree: ty::ValTree<'tcx>,
         place: PlaceBuilder<'tcx>,
         elem_ty: Ty<'tcx>,
-    ) -> MatchPairTree<'pat, 'tcx> {
+    ) -> Option<MatchPairTree<'pat, 'tcx>> {
         let tcx = self.tcx;
         let (const_ty, pat_ty) = if base_pat_ty.is_slice() {
             (
@@ -91,9 +92,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             )
         } else {
             //let arr_ty = Ty::new_array(tcx, elem_ty, subslice_len);
-            let arr_ty = Ty::new_slice(tcx, elem_ty);
-            let pat_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, arr_ty);
-            (arr_ty, pat_ty)
+            //let arr_ty = Ty::new_imm_ref(
+            //    tcx,
+            //    tcx.lifetimes.re_erased,
+            //    Ty::new_array(tcx, elem_ty, subslice_len),
+            //);
+            //let pat_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_slice(tcx, elem_ty));
+            //(arr_ty, pat_ty)
+            return None;
         };
 
         let r#const = ty::Const::new(tcx, ty::ConstKind::Value(const_ty, valtree));
@@ -107,12 +113,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let test_case = TestCase::Constant { value: r#const2 };
 
-        MatchPairTree {
+        Some(MatchPairTree {
             place: Some(place.to_place(self)),
             test_case,
             subpairs: Vec::new(),
             pattern,
-        }
+        })
     }
 
     /// Builds [`MatchPairTree`] subtrees for the prefix/middle/suffix parts of an
@@ -143,6 +149,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ((prefix.len() + suffix.len()).try_into().unwrap(), false)
         };
 
+        let mut not = false;
+
         // Here we try to special-case constant pattern subslices into valtrees to generate
         // nicer MIR.
         // Try to perform simplification of a constant pattern slice `prefix` sequence into
@@ -151,16 +159,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let elem_ty = prefix[0].ty;
             let prefix_valtree = self.simplify_const_pattern_slice_into_valtree(prefix);
             // FIXME(jieyouxu): triple check these place calculations!
-            let match_pair = self.valtree_to_match_pair(
+            if let Some(match_pair) = self.valtree_to_match_pair(
                 base_pat.ty,
                 base_pat.span,
                 prefix.len() as u64,
                 prefix_valtree,
                 place.base().into(),
                 elem_ty,
-            );
-            match_pairs.push(match_pair);
-        } else {
+            ) {
+                match_pairs.push(match_pair);
+                not = true;
+            }
+        }
+
+        if !not {
             match_pairs.extend(prefix.iter().enumerate().map(|(idx, subpattern)| {
                 let elem =
                     ProjectionElem::ConstantIndex { offset: idx as u64, min_length, from_end: false };