no MIR errors but rip tests

Author: xacrimon

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

@@ -1,7 +1,6 @@
 use rustc_middle::mir::*;
 use rustc_middle::thir::{self, *};
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
-use rustc_span::Span;
 
 use crate::builder::Builder;
 use crate::builder::expr::as_place::{PlaceBase, PlaceBuilder};
@@ -56,22 +55,21 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ((prefix.len() + suffix.len()).try_into().unwrap(), false)
         };
 
-        if self.subslice_work_optimizing(prefix) && opt_slice.is_none() && suffix.is_empty() {
+        if self.should_optimize_subslice(prefix) {
             let elem_ty = prefix[0].ty;
             let prefix_valtree = self.simplify_const_pattern_slice_into_valtree(prefix);
 
-            let project = PlaceElem::Subslice {
+            let src_path_subslice = place.clone_project(PlaceElem::Subslice {
                 from: 0 as u64,
-                to: prefix.len() as u64, // TODO: look at this
+                to: prefix.len() as u64,
                 from_end: !exact_size,
-            };
+            });
 
             let match_pair = self.valtree_to_match_pair(
-                src_path.ty,
-                src_path.span,
+                src_path,
                 prefix.len() as u64,
                 prefix_valtree,
-                place.clone_project(project),
+                src_path_subslice,
                 elem_ty,
             );
 
@@ -91,7 +89,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let suffix_len = suffix.len() as u64;
             let subslice = place.clone_project(PlaceElem::Subslice {
                 from: prefix.len() as u64,
-                to: if exact_size { min_length - suffix_len } else { suffix_len }, // TODO: look at this
+                to: if exact_size { min_length - suffix_len } else { suffix_len },
                 from_end: !exact_size,
             });
             match_pairs.push(MatchPairTree::for_pattern(subslice, subslice_pat, self));
@@ -109,7 +107,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }));
     }
 
-    fn subslice_work_optimizing(&self, subslice: &[Box<Pat<'tcx>>]) -> bool {
+    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))
     }
 
@@ -148,8 +147,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
     fn valtree_to_match_pair<'pat>(
         &mut self,
-        src_pat_ty: Ty<'tcx>,
-        span: Span,
+        src_path: &'pat Pat<'tcx>,
         subslice_len: u64,
         valtree: ty::ValTree<'tcx>,
         place: PlaceBuilder<'tcx>,
@@ -162,16 +160,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Ty::new_array(tcx, elem_ty, subslice_len),
         );
 
-        let pat_ty = match src_pat_ty.kind() {
+        let pat_ty = match src_path.ty.kind() {
             ty::Slice(_) => Ty::new_slice(tcx, elem_ty),
             ty::Array(_, _) => Ty::new_array(tcx, elem_ty, subslice_len),
             _ => unreachable!(),
         };
 
-        let ty_cost = ty::Const::new(tcx, ty::ConstKind::Value(const_ty, valtree));
-        let value = Const::Ty(const_ty, r#ty_cost);
+        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 };
-        let pattern = tcx.arena.alloc(Pat { ty: pat_ty, span, kind: PatKind::Constant { value } });
+        let pattern = tcx.arena.alloc(Pat {
+            ty: pat_ty,
+            span: src_path.span,
+            kind: PatKind::Constant { value },
+        });
 
         MatchPairTree {
             place: Some(place.to_place(self)),

library/core/src/cmp/pattern.rs

@@ -1,3 +1,7 @@
+use crate::cmp::BytewiseEq;
+use crate::intrinsics::compare_bytes;
+use crate::mem;
+
 #[lang = "MatchLoweredCmp"]
 #[const_trait]
 trait MatchLoweredCmp<Rhs = Self>
@@ -39,7 +43,7 @@ where
     T: ~const MatchLoweredCmp,
 {
     #[rustc_allow_const_fn_unstable(const_trait_impl)]
-    fn do_match(&self, other: &Self) -> bool {
+    default fn do_match(&self, other: &Self) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -57,3 +61,22 @@ where
         true
     }
 }
+
+impl<T> const MatchLoweredCmp for [T]
+where
+    T: ~const MatchLoweredCmp + BytewiseEq<T>,
+{
+    #[rustc_allow_const_fn_unstable(core_intrinsics, const_trait_impl)]
+    fn do_match(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+
+        // SAFETY: `self` and `other` are references and are thus guaranteed to be valid.
+        // The two slices have been checked to have the same size above.
+        unsafe {
+            let size = mem::size_of_val(self);
+            compare_bytes(self.as_ptr() as *const u8, other.as_ptr() as *const u8, size) == 0
+        }
+    }
+}