handle suffixes

Author: xacrimon

compiler/rustc_hir/src/lang_items.rs

@@ -421,6 +421,7 @@ language_item_table! {
     // 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;
     AggregateRawPtr,         sym::aggregate_raw_ptr,   aggregate_raw_ptr,          Target::Fn,             GenericRequirement::None;
+    Offset,                  sym::offset,              offset,                     Target::Fn,             GenericRequirement::None;
 }
 
 pub enum GenericRequirement {

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

@@ -22,7 +22,7 @@ use tracing::{debug, instrument};
 
 use crate::builder::matches::util::Range;
 use crate::builder::matches::{Candidate, MatchPairTree, Test, TestBranch, TestCase, TestKind};
-use crate::builder::{Builder, PlaceBuilder};
+use crate::builder::{BlockAnd, BlockAndExtension, Builder, PlaceBuilder};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Identifies what test is needed to decide if `match_pair` is applicable.
@@ -182,21 +182,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         ref_str_ty,
                     );
                 } else if !ty.is_scalar() {
-                    let (place, block) = if let Some(range) = range {
-                        let target_block = self.cfg.start_new_block();
-                        let subslice = self.subslice(
-                            block,
-                            target_block,
-                            place,
-                            place_ty.ty,
-                            test.span,
-                            ty.sequence_element_type(tcx),
-                            range,
+                    let (block, place) = if let Some(range) = range {
+                        let mut block = block;
+                        let subslice = unpack!(
+                            block = self.subslice(
+                                block,
+                                place,
+                                place_ty.ty,
+                                test.span,
+                                ty.sequence_element_type(tcx),
+                                range,
+                            )
                         );
 
-                        (subslice, target_block)
+                        (block, subslice)
                     } else {
-                        (place, block)
+                        (block, place)
                     };
 
                     // Use `PartialEq::eq` instead of `BinOp::Eq`
@@ -310,20 +311,82 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    fn subslice(
+    fn offset(
         &mut self,
         block: BasicBlock,
-        target_block: BasicBlock,
+        ptr: Place<'tcx>,
+        offset: Place<'tcx>,
+        span: Span,
+    ) -> BlockAnd<Place<'tcx>> {
+        let ptr_ty = ptr.ty(&self.local_decls, self.tcx).ty;
+        let offset_ty = offset.ty(&self.local_decls, self.tcx).ty;
+
+        let tcx = self.tcx;
+        let func = Operand::function_handle(
+            tcx,
+            tcx.require_lang_item(LangItem::Offset, Some(span)),
+            [ptr_ty.into(), offset_ty.into()],
+            span,
+        );
+
+        let out = self.temp(ptr_ty, span);
+        let next_block = self.cfg.start_new_block();
+
+        self.cfg.terminate(block, self.source_info(span), TerminatorKind::Call {
+            func,
+            args: [Spanned { node: Operand::Copy(ptr), span }, Spanned {
+                node: Operand::Copy(offset),
+                span,
+            }]
+            .into(),
+            destination: out,
+            target: Some(next_block),
+            unwind: UnwindAction::Continue,
+            call_source: CallSource::Misc,
+            fn_span: span,
+        });
+
+        next_block.and(out)
+    }
+
+    fn subslice(
+        &mut self,
+        mut block: BasicBlock,
         input: Place<'tcx>,
         input_ty: Ty<'tcx>,
         span: Span,
         elem_ty: Ty<'tcx>,
         range: Range,
-    ) -> Place<'tcx> {
+    ) -> BlockAnd<Place<'tcx>> {
         let tcx = self.tcx;
         let source_info = self.source_info(span);
 
-        // TODO: handle range.from_end == true
+        let (ptr_offset, slice_len) = {
+            if !range.from_end {
+                let start = self.push_usize(block, source_info, range.start);
+                let len = self.push_usize(block, source_info, range.len());
+                (start, len)
+            } else {
+                let source_len = self.temp(tcx.types.usize, span);
+                self.cfg.push_assign(block, source_info, source_len, Rvalue::Len(input));
+
+                let start = self.temp(tcx.types.usize, span);
+                let from_end = self.push_usize(block, source_info, range.start);
+
+                self.cfg.push_assign(
+                    block,
+                    source_info,
+                    start,
+                    Rvalue::BinaryOp(
+                        BinOp::Sub,
+                        Box::new((Operand::Copy(source_len), Operand::Copy(from_end))),
+                    ),
+                );
+                let len = self.push_usize(block, source_info, range.len());
+
+                (start, len)
+            }
+        };
 
         let temp_source_ptr = self.temp(Ty::new_ptr(tcx, input_ty, Mutability::Not), span);
         self.cfg.push_assign(
@@ -336,31 +399,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         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 mut temp_elem_ptr = self.temp(elem_ptr_ty, span);
+        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),
         );
 
-        if range.start != 0 {
-            let offset = self.temp(elem_ptr_ty, span);
-            let offset_by = self.push_usize(block, source_info, range.start);
-            self.cfg.push_assign(
-                block,
-                source_info,
-                offset,
-                Rvalue::BinaryOp(
-                    BinOp::Offset,
-                    Box::new((Operand::Copy(temp_elem_ptr), Operand::Move(offset_by))),
-                ),
-            );
-
-            temp_elem_ptr = offset;
-        }
-
-        let temp_len = self.push_usize(block, source_info, range.len());
+        let updated_ptr = unpack!(block = self.offset(block, temp_elem_ptr, ptr_offset, span));
 
         let aggregate_raw_ptr = Operand::function_handle(
             tcx,
@@ -371,21 +418,24 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let subslice_ptr = self.temp(slice_ptr_ty, span);
 
+        let next_block = self.cfg.start_new_block();
+
         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),
+            args: [Spanned { node: Operand::Move(updated_ptr), span }, Spanned {
+                node: Operand::Move(slice_len),
                 span,
             }]
             .into(),
             destination: subslice_ptr,
-            target: Some(target_block),
+            target: Some(next_block),
             unwind: UnwindAction::Continue,
             call_source: CallSource::Misc,
             fn_span: source_info.span,
         });
 
-        PlaceBuilder::from(subslice_ptr).deref().to_place(self)
+        let subslice = PlaceBuilder::from(subslice_ptr).deref().to_place(self);
+        next_block.and(subslice)
     }
 
     /// Perform `let temp = <ty as Deref>::deref(&place)`.

library/core/src/intrinsics/mod.rs

@@ -1965,6 +1965,7 @@ pub const fn needs_drop<T: ?Sized>() -> bool {
 /// of bounds or arithmetic overflow occurs then this operation is undefined behavior.
 ///
 /// The stabilized version of this intrinsic is [`pointer::offset`].
+#[cfg_attr(not(bootstrap), lang = "offset")]
 #[must_use = "returns a new pointer rather than modifying its argument"]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]