cleanup 2

Author: xacrimon

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -702,17 +702,17 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     // We can't determine the actual callee here, so we have to do different checks
                     // than usual.
 
-                    if tcx.is_lang_item(trait_did, LangItem::PatternConstEq) {
-                        return;
-                    }
-
                     trace!("attempting to call a trait method");
                     let trait_is_const = tcx.is_const_trait(trait_did);
 
                     // Only consider a trait to be const if the const conditions hold.
                     // Otherwise, it's really misleading to call something "conditionally"
                     // const when it's very obviously not conditionally const.
                     if trait_is_const && has_const_conditions == Some(ConstConditionsHold::Yes) {
+                        if tcx.is_lang_item(trait_did, LangItem::PatternConstEq) {
+                            return;
+                        }
+
                         // Trait calls are always conditionally-const.
                         self.check_op(ops::ConditionallyConstCall {
                             callee,

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

@@ -64,6 +64,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 prefix_valtree,
                 place.clone(),
                 elem_ty,
+                opt_slice.is_some() || !suffix.is_empty(),
             );
 
             match_pairs.push(match_pair);
@@ -101,7 +102,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     fn should_optimize_subslice(&self, subslice: &[Box<Pat<'tcx>>]) -> bool {
-        // Only wasted effort if we're just comparing a single elememt anyway.
         subslice.len() > 1 && subslice.iter().all(|p| self.is_constant_pattern(p))
     }
 
@@ -140,11 +140,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
     fn valtree_to_match_pair<'pat>(
         &mut self,
-        src_path: &'pat Pat<'tcx>,
+        source_pattern: &'pat Pat<'tcx>,
         subslice_len: u64,
         valtree: ty::ValTree<'tcx>,
         place: PlaceBuilder<'tcx>,
         elem_ty: Ty<'tcx>,
+        subsliced: bool,
     ) -> MatchPairTree<'pat, 'tcx> {
         let tcx = self.tcx;
         let const_ty = Ty::new_imm_ref(
@@ -153,15 +154,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Ty::new_array(tcx, elem_ty, subslice_len),
         );
 
-        // note: this is fine since we set range = Some in TestCase::Constant
-        // which notifies any eventual comparison code that it should subslice `place`
-        let pat_ty = Ty::new_slice(tcx, elem_ty);
+        let pat_ty = if subsliced { Ty::new_slice(tcx, elem_ty) } else { source_pattern.ty };
         let ty_const = ty::Const::new(tcx, ty::ConstKind::Value(const_ty, valtree));
         let value = Const::Ty(const_ty, ty_const);
-        let test_case = TestCase::Constant { value, range: Some(0..subslice_len) };
+        let test_case = TestCase::Constant { value, range: subsliced.then(|| 0..subslice_len) };
         let pattern = tcx.arena.alloc(Pat {
             ty: pat_ty,
-            span: src_path.span,
+            span: source_pattern.span,
             kind: PatKind::Constant { value },
         });
 

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

@@ -181,37 +181,33 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         ref_str_ty,
                     );
                 } else if !ty.is_scalar() {
-                    let new_place;
-                    let cmp_block;
-                    if let Some(range) = range {
+                    let (place, block) = if let Some(range) = range {
                         assert_eq!(range.start, 0);
-                        let elem_ty = ty.sequence_element_type(tcx);
-                        cmp_block = self.cfg.start_new_block();
-                        let subslice_ptr = self.subslice(
+                        let target_block = self.cfg.start_new_block();
+                        let subslice = self.subslice(
                             block,
-                            cmp_block,
+                            target_block,
                             place,
                             place_ty.ty,
                             test.span,
-                            elem_ty,
+                            ty.sequence_element_type(tcx),
                             range.end,
                         );
 
-                        new_place = PlaceBuilder::from(subslice_ptr).deref().to_place(self);
+                        (subslice, target_block)
                     } else {
-                        cmp_block = block;
-                        new_place = place;
-                    }
+                        (place, block)
+                    };
 
                     // Use `PartialEq::eq` instead of `BinOp::Eq`
                     // (the binop can only handle primitives)
                     self.non_scalar_compare(
-                        cmp_block,
+                        block,
                         success_block,
                         fail_block,
                         source_info,
                         value,
-                        new_place,
+                        place,
                         ty,
                     );
                 } else {
@@ -371,7 +367,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             fn_span: source_info.span,
         });
 
-        subslice_ptr
+        PlaceBuilder::from(subslice_ptr).deref().to_place(self)
     }
 
     /// Perform `let temp = <ty as Deref>::deref(&place)`.
@@ -447,7 +443,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         );
     }
 
-    /// Compare two values using `<T as std::compare::pattern::PatternConstEq>::eq`.
+    /// Compare two values using `<T as std::cmp::pattern::PatternConstEq>::eq`
+    /// or `<T as std::cmp::PartialEq>::eq` if they depending on exposed const-capability.
     /// If the values are already references, just call it directly, otherwise
     /// take a reference to the values first and then call it.
     fn non_scalar_compare(