Migrate libraries from ptr::slice_from_raw_parts to .cast_slice

Paladynee · Paladynee · commit 14315f9793cd · 2026-05-06T03:46:10.000+02:00
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
@@ -204,12 +204,12 @@ impl Global {
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     fn alloc_impl_runtime(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
+            0 => Ok(layout.dangling_ptr().cast_slice(0)),
             // SAFETY: `layout` is non-zero in size,
             size => unsafe {
                 let raw_ptr = if zeroed { alloc_zeroed(layout) } else { alloc(layout) };
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, size))
+                Ok(ptr.cast_slice(size))
             },
         }
     }
@@ -261,7 +261,7 @@ impl Global {
                 if zeroed {
                     raw_ptr.add(old_size).write_bytes(0, new_size - old_size);
                 }
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
+                Ok(ptr.cast_slice(new_size))
             },
 
             // SAFETY: because `new_layout.size()` must be greater than or equal to `old_size`,
@@ -297,7 +297,7 @@ impl Global {
             // SAFETY: conditions must be upheld by the caller
             0 => unsafe {
                 self.deallocate(ptr, old_layout);
-                Ok(NonNull::slice_from_raw_parts(new_layout.dangling_ptr(), 0))
+                Ok(new_layout.dangling_ptr().cast_slice(0))
             },
 
             // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller
@@ -307,7 +307,7 @@ impl Global {
 
                 let raw_ptr = realloc_nonnull(ptr, old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
+                Ok(ptr.cast_slice(new_size))
             },
 
             // SAFETY: because `new_size` must be smaller than or equal to `old_layout.size()`,
@@ -388,7 +388,7 @@ impl Global {
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     const fn alloc_impl_const(layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
+            0 => Ok(layout.dangling_ptr().cast_slice(0)),
             // SAFETY: `layout` is non-zero in size,
             size => unsafe {
                 let raw_ptr = core::intrinsics::const_allocate(layout.size(), layout.align());
@@ -397,7 +397,7 @@ impl Global {
                     // SAFETY: the pointer returned by `const_allocate` is valid to write to.
                     ptr.write_bytes(0, size);
                 }
-                Ok(NonNull::slice_from_raw_parts(ptr, size))
+                Ok(ptr.cast_slice(size))
             },
         }
     }
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
@@ -226,9 +226,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// `range` must lie inside `0..self.capacity()`.
     #[inline]
     unsafe fn buffer_range(&self, range: Range<usize>) -> *mut [T] {
-        unsafe {
-            ptr::slice_from_raw_parts_mut(self.ptr().add(range.start), range.end - range.start)
-        }
+        unsafe { self.ptr().add(range.start).cast_slice(range.end - range.start) }
     }
 
     /// Returns `true` if the buffer is at full capacity.
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
@@ -139,6 +139,7 @@
 #![feature(pattern)]
 #![feature(pin_coerce_unsized_trait)]
 #![feature(ptr_alignment_type)]
+#![feature(ptr_cast_slice)]
 #![feature(ptr_internals)]
 #![feature(ptr_metadata)]
 #![feature(rev_into_inner)]
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
@@ -244,7 +244,7 @@ impl<T, A: Allocator> RawVec<T, A> {
 
         let me = ManuallyDrop::new(self);
         unsafe {
-            let slice = ptr::slice_from_raw_parts_mut(me.ptr() as *mut MaybeUninit<T>, len);
+            let slice = me.ptr().cast::<MaybeUninit<T>>().cast_slice(len);
             Box::from_raw_in(slice, ptr::read(&me.inner.alloc))
         }
     }
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
@@ -1160,10 +1160,7 @@ impl<T> Rc<[T]> {
             Rc::from_ptr(Rc::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| Global.allocate_zeroed(layout),
-                |mem| {
-                    ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)
-                        as *mut RcInner<[mem::MaybeUninit<T>]>
-                },
+                |mem| mem.cast::<T>().cast_slice(len) as *mut RcInner<[mem::MaybeUninit<T>]>,
             ))
         }
     }
@@ -1231,10 +1228,7 @@ impl<T, A: Allocator> Rc<[T], A> {
                 Rc::allocate_for_layout(
                     Layout::array::<T>(len).unwrap(),
                     |layout| alloc.allocate_zeroed(layout),
-                    |mem| {
-                        ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)
-                            as *mut RcInner<[mem::MaybeUninit<T>]>
-                    },
+                    |mem| mem.cast::<T>().cast_slice(len) as *mut RcInner<[mem::MaybeUninit<T>]>,
                 ),
                 alloc,
             )
@@ -2325,7 +2319,7 @@ impl<T> Rc<[T]> {
             Self::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| Global.allocate(layout),
-                |mem| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut RcInner<[T]>,
+                |mem| mem.cast::<T>().cast_slice(len) as *mut RcInner<[T]>,
             )
         }
     }
@@ -2402,7 +2396,7 @@ impl<T, A: Allocator> Rc<[T], A> {
             Rc::<[T]>::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| alloc.allocate(layout),
-                |mem| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut RcInner<[T]>,
+                |mem| mem.cast::<T>().cast_slice(len) as *mut RcInner<[T]>,
             )
         }
     }
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
@@ -1306,10 +1306,7 @@ impl<T> Arc<[T]> {
             Arc::from_ptr(Arc::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| Global.allocate_zeroed(layout),
-                |mem| {
-                    ptr::slice_from_raw_parts_mut(mem as *mut T, len)
-                        as *mut ArcInner<[mem::MaybeUninit<T>]>
-                },
+                |mem| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[mem::MaybeUninit<T>]>,
             ))
         }
     }
@@ -1378,10 +1375,7 @@ impl<T, A: Allocator> Arc<[T], A> {
                 Arc::allocate_for_layout(
                     Layout::array::<T>(len).unwrap(),
                     |layout| alloc.allocate_zeroed(layout),
-                    |mem| {
-                        ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)
-                            as *mut ArcInner<[mem::MaybeUninit<T>]>
-                    },
+                    |mem| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[mem::MaybeUninit<T>]>,
                 ),
                 alloc,
             )
@@ -2270,7 +2264,7 @@ impl<T> Arc<[T]> {
             Self::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| Global.allocate(layout),
-                |mem| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut ArcInner<[T]>,
+                |mem| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[T]>,
             )
         }
     }
@@ -2349,7 +2343,7 @@ impl<T, A: Allocator> Arc<[T], A> {
             Arc::allocate_for_layout(
                 Layout::array::<T>(len).unwrap(),
                 |layout| alloc.allocate(layout),
-                |mem| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut ArcInner<[T]>,
+                |mem| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[T]>,
             )
         }
     }
diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs
@@ -232,7 +232,7 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {
             // invalidate raw pointers to it which some unsafe code might rely on.
             let vec_ptr = vec.as_mut().as_mut_ptr();
             let drop_offset = drop_ptr.offset_from_unsigned(vec_ptr);
-            let to_drop = ptr::slice_from_raw_parts_mut(vec_ptr.add(drop_offset), drop_len);
+            let to_drop = vec_ptr.add(drop_offset).cast_slice(drop_len);
             ptr::drop_in_place(to_drop);
         }
     }
diff --git a/library/alloc/src/vec/in_place_drop.rs b/library/alloc/src/vec/in_place_drop.rs
@@ -1,5 +1,5 @@
 use core::marker::PhantomData;
-use core::ptr::{self, NonNull, drop_in_place};
+use core::ptr::NonNull;
 
 use crate::alloc::Global;
 use crate::raw_vec::RawVec;
@@ -20,9 +20,7 @@ impl<T> InPlaceDrop<T> {
 impl<T> Drop for InPlaceDrop<T> {
     #[inline]
     fn drop(&mut self) {
-        unsafe {
-            ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.inner, self.len()));
-        }
+        unsafe { self.inner.cast_slice(self.len()).drop_in_place() }
     }
 }
 
@@ -42,7 +40,7 @@ impl<Src, Dest> Drop for InPlaceDstDataSrcBufDrop<Src, Dest> {
         unsafe {
             let _drop_allocation =
                 RawVec::<Src>::from_nonnull_in(self.ptr.cast::<Src>(), self.src_cap, Global);
-            drop_in_place(core::ptr::slice_from_raw_parts_mut::<Dest>(self.ptr.as_ptr(), self.len));
+            self.ptr.as_ptr().cast_slice(self.len).drop_in_place();
         };
     }
 }
diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs
@@ -115,7 +115,7 @@ impl<T, A: Allocator> IntoIter<T, A> {
     }
 
     fn as_raw_mut_slice(&mut self) -> *mut [T] {
-        ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), self.len())
+        self.ptr.as_ptr().cast_slice(self.len())
     }
 
     /// Drops remaining elements and relinquishes the backing allocation.
@@ -282,7 +282,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
     #[inline]
     fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         let step_size = self.len().min(n);
-        let to_drop = ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), step_size);
+        let to_drop = self.ptr.as_ptr().cast_slice(step_size);
         if T::IS_ZST {
             // See `next` for why we sub `end` here.
             self.end = self.end.wrapping_byte_sub(step_size);
@@ -457,9 +457,9 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
         }
         let to_drop = if T::IS_ZST {
             // ZST may cause unalignment
-            ptr::slice_from_raw_parts_mut(ptr::NonNull::<T>::dangling().as_ptr(), step_size)
+            ptr::NonNull::<T>::dangling().as_ptr().cast_slice(step_size)
         } else {
-            ptr::slice_from_raw_parts_mut(self.end as *mut T, step_size)
+            self.end.cast::<T>().cast_mut().cast_slice(step_size)
         };
         // SAFETY: same as for advance_by()
         unsafe {
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
@@ -1799,7 +1799,7 @@ impl<T, A: Allocator> Vec<T, A> {
                 return;
             }
             let remaining_len = self.len - len;
-            let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len);
+            let s = self.as_mut_ptr().add(len).cast_slice(remaining_len);
             self.len = len;
             ptr::drop_in_place(s);
         }
@@ -4251,7 +4251,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
             // use drop for [T]
             // use a raw slice to refer to the elements of the vector as weakest necessary type;
             // could avoid questions of validity in certain cases
-            ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len))
+            self.as_mut_ptr().cast_slice(self.len).drop_in_place()
         }
         // RawVec handles deallocation
     }
diff --git a/library/alloctests/lib.rs b/library/alloctests/lib.rs
@@ -35,6 +35,7 @@
 #![feature(iter_next_chunk)]
 #![feature(maybe_uninit_uninit_array_transpose)]
 #![feature(ptr_alignment_type)]
+#![feature(ptr_cast_slice)]
 #![feature(ptr_internals)]
 #![feature(rev_into_inner)]
 #![feature(sized_type_properties)]
diff --git a/library/alloctests/tests/arc.rs b/library/alloctests/tests/arc.rs
@@ -107,7 +107,7 @@ fn eq_unsized() {
 fn eq_unsized_slice() {
     let a: Arc<[()]> = Arc::new([(); 3]);
     let ptr: *const () = Arc::into_raw(a.clone()).cast();
-    let b: Arc<[()]> = unsafe { Arc::from_raw(core::ptr::slice_from_raw_parts(ptr, 42)) };
+    let b: Arc<[()]> = unsafe { Arc::from_raw(ptr.cast_slice(42)) };
     assert!(a == a);
     assert!(!(a != a));
     assert!(a != b);
diff --git a/library/alloctests/tests/boxed.rs b/library/alloctests/tests/boxed.rs
@@ -104,7 +104,7 @@ pub struct ConstAllocator;
 unsafe impl Allocator for ConstAllocator {
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
+            0 => Ok(layout.dangling_ptr().cast_slice(0)),
             _ => unsafe {
                 let ptr = core::intrinsics::const_allocate(layout.size(), layout.align());
                 Ok(NonNull::new_unchecked(ptr as *mut [u8; 0] as *mut [u8]))
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
@@ -41,6 +41,7 @@
 #![feature(macro_metavar_expr_concat)]
 #![feature(vec_peek_mut)]
 #![feature(vec_try_remove)]
+#![feature(ptr_cast_slice)]
 #![allow(internal_features)]
 #![deny(fuzzy_provenance_casts)]
 #![deny(unsafe_op_in_unsafe_fn)]
diff --git a/library/alloctests/tests/rc.rs b/library/alloctests/tests/rc.rs
@@ -108,7 +108,7 @@ fn eq_unsized() {
 fn eq_unsized_slice() {
     let a: Rc<[()]> = Rc::new([(); 3]);
     let ptr: *const () = Rc::into_raw(a.clone()).cast();
-    let b: Rc<[()]> = unsafe { Rc::from_raw(core::ptr::slice_from_raw_parts(ptr, 42)) };
+    let b: Rc<[()]> = unsafe { Rc::from_raw(ptr.cast_slice(42)) };
     assert!(a == a);
     assert!(!(a != a));
     assert!(a != b);
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
@@ -2569,7 +2569,7 @@ fn test_box_zero_allocator() {
             } else {
                 unsafe { std::alloc::alloc(layout) }
             };
-            Ok(NonNull::slice_from_raw_parts(NonNull::new(ptr).ok_or(AllocError)?, layout.size()))
+            Ok(NonNull::new(ptr).ok_or(AllocError)?.cast_slice(layout.size()))
         }
 
         unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
diff --git a/library/core/src/iter/adapters/map_windows.rs b/library/core/src/iter/adapters/map_windows.rs
@@ -218,10 +218,8 @@ impl<T, const N: usize> Drop for Buffer<T, N> {
         // SAFETY: our invariant guarantees that N elements starting from
         // `self.start` are initialized. We drop them here.
         unsafe {
-            let initialized_part: *mut [T] = crate::ptr::slice_from_raw_parts_mut(
-                self.buffer_mut_ptr().add(self.start).cast(),
-                N,
-            );
+            let initialized_part: *mut [T] =
+                self.buffer_mut_ptr().add(self.start).cast::<T>().cast_slice(N);
             ptr::drop_in_place(initialized_part);
         }
     }
diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
@@ -1400,11 +1400,11 @@ impl<T> *const T {
     ///
     /// ```rust
     /// #![feature(ptr_cast_slice)]
+    ///
     /// // create a slice pointer when starting out with a pointer to the first element
     /// let x = [5, 6, 7];
-    /// let raw_pointer = x.as_ptr();
-    /// let slice = raw_pointer.cast_slice(3);
-    /// assert_eq!(unsafe { &*slice }[2], 7);
+    /// let raw_slice = x.as_ptr().cast_slice(3);
+    /// assert_eq!(unsafe { &*raw_slice }[2], 7);
     /// ```
     ///
     /// You must ensure that the pointer is valid and not null before dereferencing
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
@@ -1675,13 +1675,13 @@ impl<T> *mut T {
     /// #![feature(ptr_cast_slice)]
     ///
     /// let x = &mut [5, 6, 7];
-    /// let slice = x.as_mut_ptr().cast_slice(3);
+    /// let raw_mut_slice = x.as_mut_ptr().cast_slice(3);
     ///
     /// unsafe {
-    ///     (*slice)[2] = 99; // assign a value at an index in the slice
+    ///     (*raw_mut_slice)[2] = 99; // assign a value at an index in the slice
     /// };
     ///
-    /// assert_eq!(unsafe { &*slice }[2], 99);
+    /// assert_eq!(unsafe { &*raw_mut_slice }[2], 99);
     /// ```
     ///
     /// You must ensure that the pointer is valid and not null before dereferencing
@@ -1701,6 +1701,7 @@ impl<T> *mut T {
         slice_from_raw_parts_mut(self, len)
     }
 }
+
 impl<T> *mut MaybeUninit<T> {
     /// Casts from a maybe-uninitialized type to its initialized version.
     ///
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
@@ -1444,7 +1444,7 @@ impl<T> NonNull<[T]> {
     #[inline]
     pub const fn slice_from_raw_parts(data: NonNull<T>, len: usize) -> Self {
         // SAFETY: `data` is a `NonNull` pointer which is necessarily non-null
-        unsafe { Self::new_unchecked(super::slice_from_raw_parts_mut(data.as_ptr(), len)) }
+        unsafe { Self::new_unchecked(data.as_ptr().cast_slice(len)) }
     }
 
     /// Returns the length of a non-null raw slice.
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
diff --git a/library/std/src/alloc.rs b/library/std/src/alloc.rs
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
diff --git a/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs b/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs
diff --git a/library/std/src/sys/process/uefi.rs b/library/std/src/sys/process/uefi.rs

Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ impl<T, A: Allocator> RawVec<T, A> {`
`244`	`244`
`245`	`245`	`let me = ManuallyDrop::new(self);`
`246`	`246`	`unsafe {`
`247`		`- let slice = ptr::slice_from_raw_parts_mut(me.ptr() as *mut MaybeUninit<T>, len);`
	`247`	`+ let slice = me.ptr().cast::<MaybeUninit<T>>().cast_slice(len);`
`248`	`248`	`Box::from_raw_in(slice, ptr::read(&me.inner.alloc))`
`249`	`249`	`}`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1160,10 +1160,7 @@ impl<T> Rc<[T]> {`
`1160`	`1160`	`Rc::from_ptr(Rc::allocate_for_layout(`
`1161`	`1161`	`Layout::array::<T>(len).unwrap(),`
`1162`	`1162`	`\|layout\| Global.allocate_zeroed(layout),`
`1163`		`- \|mem\| {`
`1164`		`- ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)`
`1165`		`- as *mut RcInner<[mem::MaybeUninit<T>]>`
`1166`		`- },`
	`1163`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut RcInner<[mem::MaybeUninit<T>]>,`
`1167`	`1164`	`))`
`1168`	`1165`	`}`
`1169`	`1166`	`}`
`@@ -1231,10 +1228,7 @@ impl<T, A: Allocator> Rc<[T], A> {`
`1231`	`1228`	`Rc::allocate_for_layout(`
`1232`	`1229`	`Layout::array::<T>(len).unwrap(),`
`1233`	`1230`	`\|layout\| alloc.allocate_zeroed(layout),`
`1234`		`- \|mem\| {`
`1235`		`- ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)`
`1236`		`- as *mut RcInner<[mem::MaybeUninit<T>]>`
`1237`		`- },`
	`1231`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut RcInner<[mem::MaybeUninit<T>]>,`
`1238`	`1232`	`),`
`1239`	`1233`	`alloc,`
`1240`	`1234`	`)`
`@@ -2325,7 +2319,7 @@ impl<T> Rc<[T]> {`
`2325`	`2319`	`Self::allocate_for_layout(`
`2326`	`2320`	`Layout::array::<T>(len).unwrap(),`
`2327`	`2321`	`\|layout\| Global.allocate(layout),`
`2328`		`- \|mem\| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut RcInner<[T]>,`
	`2322`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut RcInner<[T]>,`
`2329`	`2323`	`)`
`2330`	`2324`	`}`
`2331`	`2325`	`}`
`@@ -2402,7 +2396,7 @@ impl<T, A: Allocator> Rc<[T], A> {`
`2402`	`2396`	`Rc::<[T]>::allocate_for_layout(`
`2403`	`2397`	`Layout::array::<T>(len).unwrap(),`
`2404`	`2398`	`\|layout\| alloc.allocate(layout),`
`2405`		`- \|mem\| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut RcInner<[T]>,`
	`2399`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut RcInner<[T]>,`
`2406`	`2400`	`)`
`2407`	`2401`	`}`
`2408`	`2402`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1306,10 +1306,7 @@ impl<T> Arc<[T]> {`
`1306`	`1306`	`Arc::from_ptr(Arc::allocate_for_layout(`
`1307`	`1307`	`Layout::array::<T>(len).unwrap(),`
`1308`	`1308`	`\|layout\| Global.allocate_zeroed(layout),`
`1309`		`- \|mem\| {`
`1310`		`- ptr::slice_from_raw_parts_mut(mem as *mut T, len)`
`1311`		`- as *mut ArcInner<[mem::MaybeUninit<T>]>`
`1312`		`- },`
	`1309`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[mem::MaybeUninit<T>]>,`
`1313`	`1310`	`))`
`1314`	`1311`	`}`
`1315`	`1312`	`}`
`@@ -1378,10 +1375,7 @@ impl<T, A: Allocator> Arc<[T], A> {`
`1378`	`1375`	`Arc::allocate_for_layout(`
`1379`	`1376`	`Layout::array::<T>(len).unwrap(),`
`1380`	`1377`	`\|layout\| alloc.allocate_zeroed(layout),`
`1381`		`- \|mem\| {`
`1382`		`- ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len)`
`1383`		`- as *mut ArcInner<[mem::MaybeUninit<T>]>`
`1384`		`- },`
	`1378`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[mem::MaybeUninit<T>]>,`
`1385`	`1379`	`),`
`1386`	`1380`	`alloc,`
`1387`	`1381`	`)`
`@@ -2270,7 +2264,7 @@ impl<T> Arc<[T]> {`
`2270`	`2264`	`Self::allocate_for_layout(`
`2271`	`2265`	`Layout::array::<T>(len).unwrap(),`
`2272`	`2266`	`\|layout\| Global.allocate(layout),`
`2273`		`- \|mem\| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut ArcInner<[T]>,`
	`2267`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[T]>,`
`2274`	`2268`	`)`
`2275`	`2269`	`}`
`2276`	`2270`	`}`
`@@ -2349,7 +2343,7 @@ impl<T, A: Allocator> Arc<[T], A> {`
`2349`	`2343`	`Arc::allocate_for_layout(`
`2350`	`2344`	`Layout::array::<T>(len).unwrap(),`
`2351`	`2345`	`\|layout\| alloc.allocate(layout),`
`2352`		`- \|mem\| ptr::slice_from_raw_parts_mut(mem.cast::<T>(), len) as *mut ArcInner<[T]>,`
	`2346`	`+ \|mem\| mem.cast::<T>().cast_slice(len) as *mut ArcInner<[T]>,`
`2353`	`2347`	`)`
`2354`	`2348`	`}`
`2355`	`2349`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {`
`232`	`232`	`// invalidate raw pointers to it which some unsafe code might rely on.`
`233`	`233`	`let vec_ptr = vec.as_mut().as_mut_ptr();`
`234`	`234`	`let drop_offset = drop_ptr.offset_from_unsigned(vec_ptr);`
`235`		`- let to_drop = ptr::slice_from_raw_parts_mut(vec_ptr.add(drop_offset), drop_len);`
	`235`	`+ let to_drop = vec_ptr.add(drop_offset).cast_slice(drop_len);`
`236`	`236`	`ptr::drop_in_place(to_drop);`
`237`	`237`	`}`
`238`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`use core::marker::PhantomData;`
`2`		`-use core::ptr::{self, NonNull, drop_in_place};`
	`2`	`+use core::ptr::NonNull;`
`3`	`3`
`4`	`4`	`use crate::alloc::Global;`
`5`	`5`	`use crate::raw_vec::RawVec;`
`@@ -20,9 +20,7 @@ impl<T> InPlaceDrop<T> {`
`20`	`20`	`impl<T> Drop for InPlaceDrop<T> {`
`21`	`21`	`#[inline]`
`22`	`22`	`fn drop(&mut self) {`
`23`		`- unsafe {`
`24`		`- ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.inner, self.len()));`
`25`		`- }`
	`23`	`+ unsafe { self.inner.cast_slice(self.len()).drop_in_place() }`
`26`	`24`	`}`
`27`	`25`	`}`
`28`	`26`
`@@ -42,7 +40,7 @@ impl<Src, Dest> Drop for InPlaceDstDataSrcBufDrop<Src, Dest> {`
`42`	`40`	`unsafe {`
`43`	`41`	`let _drop_allocation =`
`44`	`42`	`RawVec::<Src>::from_nonnull_in(self.ptr.cast::<Src>(), self.src_cap, Global);`
`45`		`- drop_in_place(core::ptr::slice_from_raw_parts_mut::<Dest>(self.ptr.as_ptr(), self.len));`
	`43`	`+ self.ptr.as_ptr().cast_slice(self.len).drop_in_place();`
`46`	`44`	`};`
`47`	`45`	`}`
`48`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1799,7 +1799,7 @@ impl<T, A: Allocator> Vec<T, A> {`
`1799`	`1799`	`return;`
`1800`	`1800`	`}`
`1801`	`1801`	`let remaining_len = self.len - len;`
`1802`		`- let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len);`
	`1802`	`+ let s = self.as_mut_ptr().add(len).cast_slice(remaining_len);`
`1803`	`1803`	`self.len = len;`
`1804`	`1804`	`ptr::drop_in_place(s);`
`1805`	`1805`	`}`
`@@ -4251,7 +4251,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {`
`4251`	`4251`	`// use drop for [T]`
`4252`	`4252`	`// use a raw slice to refer to the elements of the vector as weakest necessary type;`
`4253`	`4253`	`// could avoid questions of validity in certain cases`
`4254`		`- ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len))`
	`4254`	`+ self.as_mut_ptr().cast_slice(self.len).drop_in_place()`
`4255`	`4255`	`}`
`4256`	`4256`	`// RawVec handles deallocation`
`4257`	`4257`	`}`