actually fixed it

Author: xacrimon

compiler/rustc_hir/src/lang_items.rs

@@ -419,7 +419,8 @@ language_item_table! {
     CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
 
     // FIXME(xacrimon): Used for lowering of match/if let statements. will made obsolete by const PartialEq.
-    PatternConstEq,          sym::PatternConstEq,      pattern_const_eq,          Target::Trait,          GenericRequirement::None;
+    PatternConstEq,          sym::PatternConstEq,      pattern_const_eq,           Target::Trait,          GenericRequirement::None;
+    AggregateRawPtr,         sym::aggregate_raw_ptr,   aggregate_raw_ptr,          Target::Fn,             GenericRequirement::None;
 }
 
 pub enum GenericRequirement {

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

@@ -58,24 +58,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if self.should_optimize_subslice(prefix) {
             let elem_ty = prefix[0].ty;
             let prefix_valtree = self.simplify_const_pattern_slice_into_valtree(prefix);
-            let prefix_len = prefix.len() as u64;
-
-            //let suffix_len = suffix.len() as u64;
-            let midsection_offset = if opt_slice.is_some() {1} else {0};
-
-            // TODO: handle suffix offset
-
-            let src_path_subslice = place.clone_project(PlaceElem::Subslice {
-                from: 0 as u64,
-                to: if exact_size { prefix_len } else { min_length - prefix_len + midsection_offset }, // TODO: Is this correct?
-                from_end: !exact_size,
-            });
-
             let match_pair = self.valtree_to_match_pair(
                 src_path,
                 prefix.len() as u64,
                 prefix_valtree,
-                src_path_subslice,
+                place.clone(),
                 elem_ty,
             );
 
@@ -166,15 +153,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Ty::new_array(tcx, elem_ty, subslice_len),
         );
 
-        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!(),
-        };
-
+        // note: this is fine since we set range = Some in TestCase::Constant
+        // which notifies any eventual comparison code that it should subslice `place`
+        let pat_ty = Ty::new_slice(tcx, elem_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 };
+        let test_case = TestCase::Constant { value, range: Some(0..subslice_len) };
         let pattern = tcx.arena.alloc(Pat {
             ty: pat_ty,
             span: src_path.span,
@@ -236,7 +220,7 @@ impl<'pat, 'tcx> MatchPairTree<'pat, 'tcx> {
                 }
             }
 
-            PatKind::Constant { value } => TestCase::Constant { value },
+            PatKind::Constant { value } => TestCase::Constant { value, range: None },
 
             PatKind::AscribeUserType {
                 ascription: thir::Ascription { ref annotation, variance },

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

@@ -5,6 +5,8 @@
 //! 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;
@@ -1237,7 +1239,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> },
+    Constant { value: mir::Const<'tcx>, range: Option<Range<u64>> },
     Range(&'pat PatRange<'tcx>),
     Slice { len: usize, variable_length: bool },
     Deref { temp: Place<'tcx>, mutability: Mutability },
@@ -1313,6 +1315,7 @@ enum TestKind<'tcx> {
     /// `ty`,
     Eq {
         value: Const<'tcx>,
+        range: Option<Range<u64>>,
         // 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

@@ -20,8 +20,8 @@ use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, instrument};
 
-use crate::builder::Builder;
 use crate::builder::matches::{Candidate, MatchPairTree, Test, TestBranch, TestCase, TestKind};
+use crate::builder::{Builder, PlaceBuilder};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Identifies what test is needed to decide if `match_pair` is applicable.
@@ -36,7 +36,9 @@ 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 } => TestKind::Eq { value, ty: match_pair.pattern.ty },
+            TestCase::Constant { value, ref range } => {
+                TestKind::Eq { value, ty: match_pair.pattern.ty, range: range.clone() }
+            }
 
             TestCase::Range(range) => {
                 assert_eq!(range.ty, match_pair.pattern.ty);
@@ -142,7 +144,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.cfg.terminate(block, self.source_info(match_start_span), terminator);
             }
 
-            TestKind::Eq { value, ty } => {
+            TestKind::Eq { value, ref range, ty } => {
                 let tcx = self.tcx;
                 let success_block = target_block(TestBranch::Success);
                 let fail_block = target_block(TestBranch::Failure);
@@ -179,15 +181,37 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         ref_str_ty,
                     );
                 } else if !ty.is_scalar() {
+                    let new_place;
+                    let cmp_block;
+                    if let Some(range) = range {
+                        assert_eq!(range.start, 0);
+                        let elem_ty = ty.sequence_element_type(tcx);
+                        cmp_block = self.cfg.start_new_block();
+                        let subslice_ptr = self.subslice(
+                            block,
+                            cmp_block,
+                            place,
+                            place_ty.ty,
+                            test.span,
+                            elem_ty,
+                            range.end,
+                        );
+
+                        new_place = PlaceBuilder::from(subslice_ptr).deref().to_place(self);
+                    } else {
+                        cmp_block = block;
+                        new_place = place;
+                    }
+
                     // Use `PartialEq::eq` instead of `BinOp::Eq`
                     // (the binop can only handle primitives)
                     self.non_scalar_compare(
-                        block,
+                        cmp_block,
                         success_block,
                         fail_block,
                         source_info,
                         value,
-                        place,
+                        new_place,
                         ty,
                     );
                 } else {
@@ -290,6 +314,66 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
+    fn subslice(
+        &mut self,
+        block: BasicBlock,
+        target_block: BasicBlock,
+        input: Place<'tcx>,
+        input_ty: Ty<'tcx>,
+        span: Span,
+        elem_ty: Ty<'tcx>,
+        new_len: u64,
+    ) -> Place<'tcx> {
+        let tcx = self.tcx;
+        let source_info = self.source_info(span);
+
+        let temp_source_ptr = self.temp(Ty::new_ptr(tcx, input_ty, Mutability::Not), span);
+        self.cfg.push_assign(
+            block,
+            source_info,
+            temp_source_ptr,
+            Rvalue::RawPtr(Mutability::Not, input),
+        );
+
+        let elem_ptr_ty = Ty::new_ptr(tcx, elem_ty, Mutability::Not);
+        let slice_ptr_ty = Ty::new_ptr(tcx, Ty::new_slice(tcx, elem_ty), Mutability::Not);
+
+        let temp_elem_ptr = self.temp(elem_ptr_ty, span);
+        self.cfg.push_assign(
+            block,
+            source_info,
+            temp_elem_ptr,
+            Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(temp_source_ptr), elem_ptr_ty),
+        );
+
+        let temp_len = self.push_usize(block, source_info, new_len);
+
+        let aggregate_raw_ptr = Operand::function_handle(
+            tcx,
+            tcx.require_lang_item(LangItem::AggregateRawPtr, Some(span)),
+            [slice_ptr_ty.into(), elem_ptr_ty.into(), tcx.types.usize.into()],
+            span,
+        );
+
+        let subslice_ptr = self.temp(slice_ptr_ty, span);
+
+        self.cfg.terminate(block, source_info, TerminatorKind::Call {
+            func: aggregate_raw_ptr,
+            args: [Spanned { node: Operand::Move(temp_elem_ptr), span }, Spanned {
+                node: Operand::Move(temp_len),
+                span,
+            }]
+            .into(),
+            destination: subslice_ptr,
+            target: Some(target_block),
+            unwind: UnwindAction::Continue,
+            call_source: CallSource::Misc,
+            fn_span: source_info.span,
+        });
+
+        subslice_ptr
+    }
+
     /// Perform `let temp = <ty as Deref>::deref(&place)`.
     /// or `let temp = <ty as DerefMut>::deref_mut(&mut place)`.
     pub(super) fn call_deref(
@@ -582,7 +666,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             //
             // FIXME(#29623) we could use PatKind::Range to rule
             // things out here, in some cases.
-            (TestKind::SwitchInt, &TestCase::Constant { value })
+            (TestKind::SwitchInt, &TestCase::Constant { value, .. })
                 if is_switch_ty(match_pair.pattern.ty) =>
             {
                 // An important invariant of candidate sorting is that a candidate
@@ -636,7 +720,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 })
             }
 
-            (TestKind::If, TestCase::Constant { value }) => {
+            (TestKind::If, TestCase::Constant { value, .. }) => {
                 fully_matched = true;
                 let value = value.try_eval_bool(self.tcx, self.typing_env()).unwrap_or_else(|| {
                     span_bug!(test.span, "expected boolean value but got {value:?}")
@@ -725,7 +809,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     }
                 }
             }
-            (TestKind::Range(range), &TestCase::Constant { value }) => {
+            (TestKind::Range(range), &TestCase::Constant { value, .. }) => {
                 fully_matched = false;
                 if !range.contains(value, self.tcx, self.typing_env())? {
                     // `value` is not contained in the testing range,
@@ -736,7 +820,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 }
             }
 
-            (TestKind::Eq { value: test_val, .. }, TestCase::Constant { value: case_val }) => {
+            (TestKind::Eq { value: test_val, .. }, TestCase::Constant { value: case_val, .. }) => {
                 if test_val == case_val {
                     fully_matched = true;
                     Some(TestBranch::Success)

library/core/src/intrinsics/mod.rs

@@ -4202,6 +4202,7 @@ pub const fn type_id<T: ?Sized + 'static>() -> u128 {
 /// This is used to implement functions like `slice::from_raw_parts_mut` and
 /// `ptr::from_raw_parts` in a way compatible with the compiler being able to
 /// change the possible layouts of pointers.
+#[cfg_attr(not(bootstrap), lang = "aggregate_raw_ptr")]
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]