progress

Author: xacrimon

Cargo.toml

@@ -93,3 +93,8 @@ codegen-units = 1
 # FIXME: LTO cannot be enabled for binaries in a workspace
 # <https://github.com/rust-lang/cargo/issues/9330>
 # lto = true
+
+[profile.release.package.rustc_mir_build]
+opt-level = 1
+[profile.release.package.rustc_driver]
+opt-level = 1

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

@@ -61,18 +61,19 @@ 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);
 
-            if let Some(match_pair) = self.valtree_to_match_pair(
+            let match_pair = self.valtree_to_match_pair(
                 src_path.ty,
                 src_path.span,
                 prefix.len() as u64,
                 prefix_valtree,
                 place.clone(),
                 elem_ty,
-            ) {
-                match_pairs.push(match_pair);
-                prefix_opt = true;
-            }
+            );
+
+            match_pairs.push(match_pair);
+            prefix_opt = true;
         }
 
         if !prefix_opt {
@@ -155,20 +156,28 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         valtree: ty::ValTree<'tcx>,
         place: PlaceBuilder<'tcx>,
         elem_ty: Ty<'tcx>,
-    ) -> Option<MatchPairTree<'pat, 'tcx>> {
+    ) -> MatchPairTree<'pat, 'tcx> {
         let tcx = self.tcx;
-        let (const_ty, pat_ty) = if src_pat_ty.is_slice() {
-            (
-                Ty::new_imm_ref(
+        tracing::warn!("valtree_to_match_pair: {:?} {:?}", subslice_len, src_pat_ty);
+
+        let (const_ty, pat_ty) = match src_pat_ty.kind() { 
+            ty::Slice(_) => {
+                (Ty::new_imm_ref(
                     tcx,
                     tcx.lifetimes.re_erased,
                     Ty::new_array(tcx, elem_ty, subslice_len),
                 ),
-                Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_slice(tcx, elem_ty)),
-            )
-        } else {
-            let arr_ty = Ty::new_array(tcx, elem_ty, subslice_len);
-            (arr_ty, arr_ty)
+                Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_slice(tcx, elem_ty)),)
+            }
+            ty::Array(_, _) => {
+                (Ty::new_imm_ref(
+                    tcx,
+                    tcx.lifetimes.re_erased,
+                    Ty::new_array(tcx, elem_ty, subslice_len),
+                ),
+                Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_array(tcx, elem_ty, subslice_len)),)
+            }
+            _ => todo!()
         };
 
         let r#const = ty::Const::new(tcx, ty::ConstKind::Value(const_ty, valtree));
@@ -182,12 +191,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let test_case = TestCase::Constant { value: r#const2 };
 
-        Some(MatchPairTree {
+        MatchPairTree {
             place: Some(place.to_place(self)),
             test_case,
             subpairs: Vec::new(),
             pattern,
-        })
+        }
     }
 }
 

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

@@ -375,18 +375,76 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         mut val: Place<'tcx>,
         mut ty: Ty<'tcx>,
     ) {
-        let mut expect = self.literal_operand(source_info.span, value);
+        //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),
+        //);
+
+        match ty.kind() {
+            ty::Ref(_, inner_ty, _) if inner_ty.is_slice() => {
+                let ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
+                let temp = self.temp(ty, source_info.span);
+                self.cfg.push_assign(
+                    block,
+                    source_info,
+                    temp,
+                    Rvalue::Ref(self.tcx.lifetimes.re_erased, BorrowKind::Shared, val),
+                );
+                ty = ref_ty;
+                val = temp;
+                tracing::warn!("slice ty sig: {:?}", ty);
+            }
+            ty::Ref(_, inner_ty, _) if inner_ty.is_array() => {
+                let ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
+                let temp = self.temp(ref_ty, source_info.span);
+                self.cfg.push_assign(
+                    block,
+                    source_info,
+                    temp,
+                    Rvalue::Ref(self.tcx.lifetimes.re_erased, BorrowKind::Shared, val),
+                );
 
-        let ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, ty);
-        let temp = self.temp(ty, source_info.span);
-        self.cfg.push_assign(
-            block,
-            source_info,
-            temp,
-            Rvalue::Ref(self.tcx.lifetimes.re_erased, BorrowKind::Shared, val),
-        );
-        ty = ref_ty;
-        val = temp;
+                ty = ref_ty;
+                val = temp;
+                tracing::warn!("arr ty sig: {:?}", ty);
+            }
+            ty::Ref(_, inner_ty, _) if inner_ty.is_str() => {
+                // nothing yet
+            }
+            _ => todo!("not yet, ty: {:?}", ty),
+        }        
+
+        let mut normalize_depth = |mut ty: Ty<'tcx>, mut val: Place<'tcx>| {
+            if !ty.is_ref() {
+                panic!("not a reference?");
+            }
+
+            loop {
+                match ty.kind() {
+                    ty::Ref(_, inner_ty @ _, _) if inner_ty.is_ref() => {
+                        tracing::warn!("descending from {:?} to {:?}", ty.kind(), inner_ty.kind());
+                        ty = *inner_ty;
+                        let temp = self.temp(ty, source_info.span);
+                        self.cfg.push_assign(
+                            block,
+                            source_info,
+                            temp,
+                            Rvalue::Use(Operand::Copy(val)),
+                        );
+                        val = temp;
+                    }
+                    _=> break,
+                }
+            }
+
+            (ty, val)
+        };
+
+        (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]`.