Consolidate panicking functions in slice/index.rs

Consolidate all the panicking functions in `slice/index.rs` to use a single
`slice_index_fail` function, similar to how it is done in `str/traits.rs`.

Author: Kmeakin

library/core/src/slice/index.rs

@@ -34,36 +34,41 @@ where
 #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[track_caller]
-const fn slice_start_index_len_fail(index: usize, len: usize) -> ! {
-    const_panic!(
-        "slice start index is out of range for slice",
-        "range start index {index} out of range for slice of length {len}",
-        index: usize,
-        len: usize,
-    )
-}
-
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
-#[track_caller]
-const fn slice_end_index_len_fail(index: usize, len: usize) -> ! {
+const fn slice_index_fail(start: usize, end: usize, len: usize) -> ! {
+    if start > len {
+        const_panic!(
+            "slice start index is out of range for slice",
+            "range start index {start} out of range for slice of length {len}",
+            start: usize,
+            len: usize,
+        )
+    }
+
+    if end > len {
+        const_panic!(
+            "slice end index is out of range for slice",
+            "range end index {end} out of range for slice of length {len}",
+            end: usize,
+            len: usize,
+        )
+    }
+
+    if start > end {
+        const_panic!(
+            "slice index start is larger than end",
+            "slice index starts at {start} but ends at {end}",
+            start: usize,
+            end: usize,
+        )
+    }
+
+    // Only reachable if the range was a `RangeInclusive` or a
+    // `RangeToInclusive`, with `end == len`.
     const_panic!(
         "slice end index is out of range for slice",
-        "range end index {index} out of range for slice of length {len}",
-        index: usize,
-        len: usize,
-    )
-}
-
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
-#[track_caller]
-const fn slice_index_order_fail(index: usize, end: usize) -> ! {
-    const_panic!(
-        "slice index start is larger than end",
-        "slice index starts at {index} but ends at {end}",
-        index: usize,
+        "range end index {end} out of range for slice of length {len}",
         end: usize,
+        len: usize,
     )
 }
 
@@ -327,7 +332,7 @@ unsafe impl<T> const SliceIndex<[T]> for ops::IndexRange {
             // SAFETY: `self` is checked to be valid and in bounds above.
             unsafe { &*get_offset_len_noubcheck(slice, self.start(), self.len()) }
         } else {
-            slice_end_index_len_fail(self.end(), slice.len())
+            slice_index_fail(self.start(), self.end(), slice.len())
         }
     }
 
@@ -337,7 +342,7 @@ unsafe impl<T> const SliceIndex<[T]> for ops::IndexRange {
             // SAFETY: `self` is checked to be valid and in bounds above.
             unsafe { &mut *get_offset_len_mut_noubcheck(slice, self.start(), self.len()) }
         } else {
-            slice_end_index_len_fail(self.end(), slice.len())
+            slice_index_fail(self.start(), self.end(), slice.len())
         }
     }
 }
@@ -423,10 +428,10 @@ unsafe impl<T> const SliceIndex<[T]> for ops::Range<usize> {
     fn index(self, slice: &[T]) -> &[T] {
         // Using checked_sub is a safe way to get `SubUnchecked` in MIR
         let Some(new_len) = usize::checked_sub(self.end, self.start) else {
-            slice_index_order_fail(self.start, self.end)
+            slice_index_fail(self.start, self.end, slice.len())
         };
         if self.end > slice.len() {
-            slice_end_index_len_fail(self.end, slice.len());
+            slice_index_fail(self.start, self.end, slice.len())
         }
         // SAFETY: `self` is checked to be valid and in bounds above.
         unsafe { &*get_offset_len_noubcheck(slice, self.start, new_len) }
@@ -435,10 +440,10 @@ unsafe impl<T> const SliceIndex<[T]> for ops::Range<usize> {
     #[inline]
     fn index_mut(self, slice: &mut [T]) -> &mut [T] {
         let Some(new_len) = usize::checked_sub(self.end, self.start) else {
-            slice_index_order_fail(self.start, self.end)
+            slice_index_fail(self.start, self.end, slice.len())
         };
         if self.end > slice.len() {
-            slice_end_index_len_fail(self.end, slice.len());
+            slice_index_fail(self.start, self.end, slice.len())
         }
         // SAFETY: `self` is checked to be valid and in bounds above.
         unsafe { &mut *get_offset_len_mut_noubcheck(slice, self.start, new_len) }
@@ -553,7 +558,7 @@ unsafe impl<T> const SliceIndex<[T]> for ops::RangeFrom<usize> {
     #[inline]
     fn index(self, slice: &[T]) -> &[T] {
         if self.start > slice.len() {
-            slice_start_index_len_fail(self.start, slice.len());
+            slice_index_fail(self.start, slice.len(), slice.len())
         }
         // SAFETY: `self` is checked to be valid and in bounds above.
         unsafe { &*self.get_unchecked(slice) }
@@ -562,7 +567,7 @@ unsafe impl<T> const SliceIndex<[T]> for ops::RangeFrom<usize> {
     #[inline]
     fn index_mut(self, slice: &mut [T]) -> &mut [T] {
         if self.start > slice.len() {
-            slice_start_index_len_fail(self.start, slice.len());
+            slice_index_fail(self.start, slice.len(), slice.len())
         }
         // SAFETY: `self` is checked to be valid and in bounds above.
         unsafe { &mut *self.get_unchecked_mut(slice) }
@@ -678,15 +683,15 @@ unsafe impl<T> const SliceIndex<[T]> for ops::RangeInclusive<usize> {
     #[inline]
     fn index(self, slice: &[T]) -> &[T] {
         if *self.end() >= slice.len() {
-            slice_end_index_len_fail(*self.end(), slice.len());
+            slice_index_fail(self.start, self.end, slice.len())
         }
         self.into_slice_range().index(slice)
     }
 
     #[inline]
     fn index_mut(self, slice: &mut [T]) -> &mut [T] {
         if *self.end() >= slice.len() {
-            slice_end_index_len_fail(*self.end(), slice.len());
+            slice_index_fail(self.start, self.end, slice.len())
         }
         self.into_slice_range().index_mut(slice)
     }
@@ -840,22 +845,22 @@ where
     let len = bounds.end;
 
     let end = match range.end_bound() {
-        ops::Bound::Included(&end) if end >= len => slice_end_index_len_fail(end, len),
+        ops::Bound::Included(&end) if end >= len => slice_index_fail(0, end, len),
         // Cannot overflow because `end < len` implies `end < usize::MAX`.
         ops::Bound::Included(&end) => end + 1,
 
-        ops::Bound::Excluded(&end) if end > len => slice_end_index_len_fail(end, len),
+        ops::Bound::Excluded(&end) if end > len => slice_index_fail(0, end, len),
         ops::Bound::Excluded(&end) => end,
 
         ops::Bound::Unbounded => len,
     };
 
     let start = match range.start_bound() {
-        ops::Bound::Excluded(&start) if start >= end => slice_index_order_fail(start, end),
+        ops::Bound::Excluded(&start) if start >= end => slice_index_fail(start, end, len),
         // Cannot overflow because `start < end` implies `start < usize::MAX`.
         ops::Bound::Excluded(&start) => start + 1,
 
-        ops::Bound::Included(&start) if start > end => slice_index_order_fail(start, end),
+        ops::Bound::Included(&start) if start > end => slice_index_fail(start, end, len),
         ops::Bound::Included(&start) => start,
 
         ops::Bound::Unbounded => 0,
@@ -985,22 +990,22 @@ pub(crate) fn into_slice_range(
     (start, end): (ops::Bound<usize>, ops::Bound<usize>),
 ) -> ops::Range<usize> {
     let end = match end {
-        ops::Bound::Included(end) if end >= len => slice_end_index_len_fail(end, len),
+        ops::Bound::Included(end) if end >= len => slice_index_fail(0, end, len),
         // Cannot overflow because `end < len` implies `end < usize::MAX`.
         ops::Bound::Included(end) => end + 1,
 
-        ops::Bound::Excluded(end) if end > len => slice_end_index_len_fail(end, len),
+        ops::Bound::Excluded(end) if end > len => slice_index_fail(0, end, len),
         ops::Bound::Excluded(end) => end,
 
         ops::Bound::Unbounded => len,
     };
 
     let start = match start {
-        ops::Bound::Excluded(start) if start >= end => slice_index_order_fail(start, end),
+        ops::Bound::Excluded(start) if start >= end => slice_index_fail(start, end, len),
         // Cannot overflow because `start < end` implies `start < usize::MAX`.
         ops::Bound::Excluded(start) => start + 1,
 
-        ops::Bound::Included(start) if start > end => slice_index_order_fail(start, end),
+        ops::Bound::Included(start) if start > end => slice_index_fail(start, end, len),
         ops::Bound::Included(start) => start,
 
         ops::Bound::Unbounded => 0,

library/coretests/tests/slice.rs

@@ -1513,7 +1513,7 @@ mod slice_index {
             data: [0; 1];
 
             bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
-            message: "but ends at 1";
+            message: "out of range";
         }
     } // panic_cases!
 }