Revert "Assume slice len is bounded by allocation size"

rust-lang#77023 (comment)
suggests that the original PR introduced a significant perf regression.

This reverts commit e44784b / rust-lang#77023.

Author: nagisa

library/core/src/lib.rs

@@ -82,7 +82,6 @@
 #![feature(const_pin)]
 #![feature(const_fn)]
 #![feature(const_fn_union)]
-#![feature(const_assume)]
 #![cfg_attr(not(bootstrap), feature(const_impl_trait))]
 #![feature(const_fn_floating_point_arithmetic)]
 #![feature(const_fn_fn_ptr_basics)]

library/core/src/slice/mod.rs

@@ -79,16 +79,6 @@ pub use index::check_range;
 #[lang = "slice"]
 #[cfg(not(test))]
 impl<T> [T] {
-    /// The maximum, inclusive, length such that the slice is no larger than `isize::MAX` bytes.
-    /// This constant is used in `len` below.
-    const MAX_LEN_BOUND: usize = {
-        if mem::size_of::<T>() == 0 {
-            usize::MAX
-        } else {
-            isize::MAX as usize / mem::size_of::<T>()
-        }
-    };
-
     /// Returns the number of elements in the slice.
     ///
     /// # Examples
@@ -101,20 +91,11 @@ impl<T> [T] {
     #[rustc_const_stable(feature = "const_slice_len", since = "1.32.0")]
     #[inline]
     // SAFETY: const sound because we transmute out the length field as a usize (which it must be)
-    #[allow_internal_unstable(const_fn_union, const_assume)]
+    #[allow_internal_unstable(const_fn_union)]
     pub const fn len(&self) -> usize {
         // SAFETY: this is safe because `&[T]` and `FatPtr<T>` have the same layout.
         // Only `std` can make this guarantee.
-        let raw_len = unsafe { crate::ptr::Repr { rust: self }.raw.len };
-
-        // SAFETY: this assume asserts that `raw_len * size_of::<T>() <= isize::MAX`. All
-        // references must point to one allocation with size at most isize::MAX. Note that we the
-        // multiplication could appear to overflow until we have assumed the bound. This overflow
-        // would make additional values appear 'valid' and then `n > 1` the range of permissible
-        // length would no longer be the full or even a single range.
-        unsafe { crate::intrinsics::assume(raw_len <= Self::MAX_LEN_BOUND) };
-
-        raw_len
+        unsafe { crate::ptr::Repr { rust: self }.raw.len }
     }
 
     /// Returns `true` if the slice has a length of 0.