unwrap in SliceIndex<usize>::get_unchecked instead

Author: bend-n

library/core/src/slice/index.rs

@@ -214,7 +214,8 @@ unsafe impl<T> SliceIndex<[T]> for usize {
     #[inline]
     fn get(self, slice: &[T]) -> Option<&T> {
         // SAFETY: `self` is checked to be in bounds.
-        if self < slice.len() { unsafe { Some(&*self.get_unchecked(slice)) } } else { None }
+        // The call to `add` is safe, as we check the bounds.
+        if self < slice.len() { unsafe { Some(&*slice.as_ptr().add(self)) } } else { None }
     }
 
     #[inline]
@@ -229,13 +230,14 @@ unsafe impl<T> SliceIndex<[T]> for usize {
         // SAFETY: the caller guarantees that `slice` is not dangling, so it
         // cannot be longer than `isize::MAX`. They also guarantee that
         // `self` is in bounds of `slice` so `self` cannot overflow an `isize`,
-        // so the call to `add` is safe.
+        // so we can `unwrap_unchecked`.
+        // We use `get().unwrap_unchecked()` for better codegen: see issue #116878
         unsafe {
             assert_unsafe_precondition!(
                 "slice::get_unchecked requires that the index is within the slice",
                 [T](this: usize, slice: *const [T]) => this < slice.len()
             );
-            slice.as_ptr().add(self)
+            self.get(&*slice).unwrap_unchecked() as *const _
         }
     }
 

library/core/src/slice/mod.rs

@@ -662,7 +662,7 @@ impl<T> [T] {
         // SAFETY: the caller must uphold most of the safety requirements for `get_unchecked`;
         // the slice is dereferenceable because `self` is a safe reference.
         // The returned pointer is safe because impls of `SliceIndex` have to guarantee that it is.
-        unsafe { &*index.get(self).unwrap_unchecked() }
+        unsafe { &*index.get_unchecked(self) }
     }
 
     /// Returns a mutable reference to an element or subslice, without doing