slow and stready

Author: xacrimon

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

@@ -61,7 +61,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if self.is_constant_pattern_subslice(prefix) && opt_slice.is_none() && suffix.len() == 0 {
             let elem_ty = prefix[0].ty;
             let prefix_valtree = self.simplify_const_pattern_slice_into_valtree(prefix);
-            tracing::warn!("reduced prefix ({:?}) to ({:?})", prefix, prefix_valtree);
+            //tracing::warn!("reduced prefix ({:?}) to ({:?})", prefix, prefix_valtree);
 
             let match_pair = self.valtree_to_match_pair(
                 src_path.ty,

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

@@ -10,7 +10,6 @@ use std::cmp::Ordering;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::{LangItem, RangeEnd};
 use rustc_middle::mir::*;
-use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -375,14 +374,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         mut val: Place<'tcx>,
         mut ty: Ty<'tcx>,
     ) {
-        //let mut expect_op = self.literal_operand(source_info.span, value);
-        //let expect = self.temp(value, source_info.span);
-        //self.cfg.push_assign(
-        //    block,
-        //    source_info,
-        //    expect,
-        //    Rvalue::Use(expect_op),
-        //);
+        let expect_ty = value.ty();
+        let expect_op = self.literal_operand(source_info.span, value);
+        let mut expect = self.temp(value.ty(), source_info.span);
+        self.cfg.push_assign(
+            block,
+            source_info,
+            expect,
+            Rvalue::Use(expect_op),
+        );
 
         match ty.kind() {
             ty::Ref(_, inner_ty, _) if inner_ty.is_slice() => {
@@ -435,6 +435,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             temp,
                             Rvalue::Use(Operand::Copy(val)),
                         );
+                        tracing::warn!("from {:?} to {:?}", val, temp);
                         val = temp;
                     }
                     _=> break,
@@ -445,65 +446,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         };
 
         (ty, val) = normalize_depth(ty, val);
-
-        // If we're using `b"..."` as a pattern, we need to insert an
-        // unsizing coercion, as the byte string has the type `&[u8; N]`.
-        //
-        // We want to do this even when the scrutinee is a reference to an
-        // array, so we can call `<[u8]>::eq` rather than having to find an
-        // `<[u8; N]>::eq`.
-        let unsize = |ty: Ty<'tcx>| match ty.kind() {
-            ty::Ref(region, rty, _) => match rty.kind() {
-                ty::Array(inner_ty, n) => Some((region, inner_ty, n)),
-                _ => None,
-            },
-            _ => None,
-        };
-        let opt_ref_ty = unsize(ty);
-        let opt_ref_test_ty = unsize(value.ty());
-        match (opt_ref_ty, opt_ref_test_ty) {
-            // nothing to do, neither is an array
-            (None, None) => {}
-            (Some((region, elem_ty, _)), _) | (None, Some((region, elem_ty, _))) => {
-                let tcx = self.tcx;
-                // make both a slice
-                ty = Ty::new_imm_ref(tcx, *region, Ty::new_slice(tcx, *elem_ty));
-                if opt_ref_ty.is_some() {
-                    let temp = self.temp(ty, source_info.span);
-                    self.cfg.push_assign(
-                        block,
-                        source_info,
-                        temp,
-                        Rvalue::Cast(
-                            CastKind::PointerCoercion(
-                                PointerCoercion::Unsize,
-                                CoercionSource::Implicit,
-                            ),
-                            Operand::Copy(val),
-                            ty,
-                        ),
-                    );
-                    val = temp;
-                }
-                if opt_ref_test_ty.is_some() {
-                    let slice = self.temp(ty, source_info.span);
-                    self.cfg.push_assign(
-                        block,
-                        source_info,
-                        slice,
-                        Rvalue::Cast(
-                            CastKind::PointerCoercion(
-                                PointerCoercion::Unsize,
-                                CoercionSource::Implicit,
-                            ),
-                            expect,
-                            ty,
-                        ),
-                    );
-                    expect = Operand::Move(slice);
-                }
-            }
-        }
+        (_, expect) = normalize_depth(expect_ty, expect);
 
         // Figure out the type on which we are calling `PartialEq`. This involves an extra wrapping
         // reference: we can only compare two `&T`, and then compare_ty will be `T`.
@@ -540,7 +483,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 const_: method,
             })),
             args: [Spanned { node: Operand::Copy(val), span: DUMMY_SP }, Spanned {
-                node: expect,
+                node: Operand::Copy(expect),
                 span: DUMMY_SP,
             }]
             .into(),