def new range type for pattern slicing

Author: xacrimon

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

@@ -4,6 +4,7 @@ use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
 use crate::builder::Builder;
 use crate::builder::expr::as_place::{PlaceBase, PlaceBuilder};
+use crate::builder::matches::util::Range;
 use crate::builder::matches::{FlatPat, MatchPairTree, TestCase};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -60,10 +61,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let prefix_valtree = self.simplify_const_pattern_slice_into_valtree(prefix);
             let match_pair = self.valtree_to_match_pair(
                 src_path,
-                prefix.len() as u64,
                 prefix_valtree,
                 place.clone(),
                 elem_ty,
+                Range::from_start(0..prefix.len() as u64),
                 opt_slice.is_some() || !suffix.is_empty(),
             );
 
@@ -89,16 +90,31 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             match_pairs.push(MatchPairTree::for_pattern(subslice, subslice_pat, self));
         }
 
-        match_pairs.extend(suffix.iter().rev().enumerate().map(|(idx, subpattern)| {
-            let end_offset = (idx + 1) as u64;
-            let elem = ProjectionElem::ConstantIndex {
-                offset: if exact_size { min_length - end_offset } else { end_offset },
-                min_length,
-                from_end: !exact_size,
-            };
-            let place = place.clone_project(elem);
-            MatchPairTree::for_pattern(place, subpattern, self)
-        }));
+        if self.should_optimize_subslice(suffix) {
+            let elem_ty = suffix[0].ty;
+            let suffix_valtree = self.simplify_const_pattern_slice_into_valtree(suffix);
+            let match_pair = self.valtree_to_match_pair(
+                src_path,
+                suffix_valtree,
+                place.clone(),
+                elem_ty,
+                Range::from_end(0..suffix.len() as u64),
+                true,
+            );
+
+            match_pairs.push(match_pair);
+        } else {
+            match_pairs.extend(suffix.iter().rev().enumerate().map(|(idx, subpattern)| {
+                let end_offset = (idx + 1) as u64;
+                let elem = ProjectionElem::ConstantIndex {
+                    offset: if exact_size { min_length - end_offset } else { end_offset },
+                    min_length,
+                    from_end: !exact_size,
+                };
+                let place = place.clone_project(elem);
+                MatchPairTree::for_pattern(place, subpattern, self)
+            }));
+        }
     }
 
     fn should_optimize_subslice(&self, subslice: &[Box<Pat<'tcx>>]) -> bool {
@@ -141,23 +157,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn valtree_to_match_pair<'pat>(
         &mut self,
         source_pattern: &'pat Pat<'tcx>,
-        subslice_len: u64,
         valtree: ty::ValTree<'tcx>,
         place: PlaceBuilder<'tcx>,
         elem_ty: Ty<'tcx>,
+        range: Range,
         subsliced: bool,
     ) -> MatchPairTree<'pat, 'tcx> {
         let tcx = self.tcx;
-        let const_ty = Ty::new_imm_ref(
-            tcx,
-            tcx.lifetimes.re_erased,
-            Ty::new_array(tcx, elem_ty, subslice_len),
-        );
+        let const_ty =
+            Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, Ty::new_array(tcx, elem_ty, range.len()));
 
         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: subsliced.then(|| 0..subslice_len) };
+        let test_case = TestCase::Constant { value, range: subsliced.then_some(range) };
         let pattern = tcx.arena.alloc(Pat {
             ty: pat_ty,
             span: source_pattern.span,

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

@@ -5,8 +5,6 @@
 //! This also includes code for pattern bindings in `let` statements and
 //! function parameters.
 
-use std::ops::Range;
-
 use rustc_abi::VariantIdx;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -21,6 +19,7 @@ use tracing::{debug, instrument};
 
 use crate::builder::ForGuard::{self, OutsideGuard, RefWithinGuard};
 use crate::builder::expr::as_place::PlaceBuilder;
+use crate::builder::matches::util::Range;
 use crate::builder::scope::DropKind;
 use crate::builder::{
     BlockAnd, BlockAndExtension, Builder, GuardFrame, GuardFrameLocal, LocalsForNode,
@@ -1239,7 +1238,7 @@ struct Ascription<'tcx> {
 enum TestCase<'pat, 'tcx> {
     Irrefutable { binding: Option<Binding<'tcx>>, ascription: Option<Ascription<'tcx>> },
     Variant { adt_def: ty::AdtDef<'tcx>, variant_index: VariantIdx },
-    Constant { value: mir::Const<'tcx>, range: Option<Range<u64>> },
+    Constant { value: mir::Const<'tcx>, range: Option<Range> },
     Range(&'pat PatRange<'tcx>),
     Slice { len: usize, variable_length: bool },
     Deref { temp: Place<'tcx>, mutability: Mutability },
@@ -1315,7 +1314,7 @@ enum TestKind<'tcx> {
     /// `ty`,
     Eq {
         value: Const<'tcx>,
-        range: Option<Range<u64>>,
+        range: Option<Range>,
         // Integer types are handled by `SwitchInt`, and constants with ADT
         // types are converted back into patterns, so this can only be `&str`,
         // `&[T]`, `f32` or `f64`.

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

@@ -36,8 +36,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             TestCase::Constant { .. } if match_pair.pattern.ty.is_bool() => TestKind::If,
             TestCase::Constant { .. } if is_switch_ty(match_pair.pattern.ty) => TestKind::SwitchInt,
-            TestCase::Constant { value, ref range } => {
-                TestKind::Eq { value, ty: match_pair.pattern.ty, range: range.clone() }
+            TestCase::Constant { value, range } => {
+                TestKind::Eq { value, ty: match_pair.pattern.ty, range }
             }
 
             TestCase::Range(range) => {
@@ -144,7 +144,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.cfg.terminate(block, self.source_info(match_start_span), terminator);
             }
 
-            TestKind::Eq { value, ref range, ty } => {
+            TestKind::Eq { value, range, ty } => {
                 let tcx = self.tcx;
                 let success_block = target_block(TestBranch::Success);
                 let fail_block = target_block(TestBranch::Failure);
@@ -182,6 +182,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     );
                 } else if !ty.is_scalar() {
                     let (place, block) = if let Some(range) = range {
+                        // TODO: range handling
                         assert_eq!(range.start, 0);
                         let target_block = self.cfg.start_new_block();
                         let subslice = self.subslice(

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

@@ -1,3 +1,5 @@
+use std::ops;
+
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_middle::mir::*;
 use rustc_middle::ty::Ty;
@@ -229,3 +231,24 @@ pub(crate) fn ref_pat_borrow_kind(ref_mutability: Mutability) -> BorrowKind {
         Mutability::Not => BorrowKind::Shared,
     }
 }
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub(super) struct Range {
+    pub(crate) start: u64,
+    pub(crate) end: u64,
+    pub(crate) from_end: bool,
+}
+
+impl Range {
+    pub(crate) fn from_start(range: ops::Range<u64>) -> Self {
+        Range { start: range.start, end: range.end, from_end: false }
+    }
+
+    pub(crate) fn from_end(range: ops::Range<u64>) -> Self {
+        Range { start: range.end, end: range.start, from_end: true }
+    }
+
+    pub(crate) fn len(&self) -> u64 {
+        todo!()
+    }
+}