projection and coercion improvements

Author: xacrimon

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

@@ -63,8 +63,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let project = PlaceElem::Subslice {
                 from: 0 as u64,
                 to: prefix.len() as u64,
-                from_end: false,
-            }; // or use a projection??
+                from_end: !exact_size,
+            };
 
             let match_pair = self.valtree_to_match_pair(
                 src_path.ty,
@@ -81,7 +81,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let elem = ProjectionElem::ConstantIndex {
                     offset: idx as u64,
                     min_length,
-                    from_end: false,
+                    from_end: !exact_size,
                 };
                 MatchPairTree::for_pattern(place.clone_project(elem), subpattern, self)
             }));
@@ -157,7 +157,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         elem_ty: Ty<'tcx>,
     ) -> MatchPairTree<'pat, 'tcx> {
         let tcx = self.tcx;
-
         tracing::warn!("source pattern type: {:?}", src_pat_ty);
         let (const_ty, pat_ty) = match src_pat_ty.kind() { // wait is source path the wrong thing to care about?
             ty::Slice(_) => (

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

@@ -442,14 +442,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             (ty, place)
         };
 
-        match (ty.peel_refs().kind(), expect_ty.peel_refs().kind()) {
-            (ty::Slice(_), ty::Array(elem_ty, _)) => {
-                (_, expect) = coerce(expect_ty, expect, *elem_ty);
-            }
-            (ty::Array(elem_ty, _), ty::Slice(_)) => {
-                (ty, val) = coerce(ty, val, *elem_ty);
-            }
-            _ => (),
+        if let ty::Array(elem_ty, _) = ty.peel_refs().kind() {
+            (ty, val) = coerce(ty, val, *elem_ty);
+        }
+
+        if let ty::Array(elem_ty, _) = expect_ty.peel_refs().kind() {
+            (_, expect) = coerce(expect_ty, expect, *elem_ty);
         }
 
         // Figure out the type on which we are calling `PartialEq`. This involves an extra wrapping
@@ -468,8 +466,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             _ => span_bug!(source_info.span, "invalid type for non-scalar compare: {}", ty),
         };
 
-        tracing::warn!("compare_ty: {:?}", compare_ty);
-
         let eq_def_id =
             self.tcx.require_lang_item(LangItem::MatchLoweredCmp, Some(source_info.span));
         let method = trait_method(self.tcx, eq_def_id, sym::do_match, [compare_ty, compare_ty]);

library/core/src/cmp/pattern.rs

@@ -8,12 +8,15 @@ where
     fn do_match(&self, other: &Rhs) -> bool;
 }
 
+// other types?
+
 impl const MatchLoweredCmp for u8 {
     fn do_match(&self, other: &Self) -> bool {
         *self == *other
     }
 }
 
+// shouldn't be const
 impl const MatchLoweredCmp for str {
     #[rustc_allow_const_fn_unstable(const_trait_impl)]
     fn do_match(&self, other: &Self) -> bool {