Add function to clone a slice into a boxed slice

Author: calebsander

library/alloc/src/boxed.rs

@@ -1229,13 +1229,9 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
     ///
     /// println!("{:?}", boxed_slice);
     /// ```
+    #[inline]
     fn from(slice: &[T]) -> Box<[T]> {
-        let len = slice.len();
-        let buf = RawVec::with_capacity(len);
-        unsafe {
-            ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
-            buf.into_box(slice.len()).assume_init()
-        }
+        slice.to_boxed_slice()
     }
 }
 
@@ -1578,7 +1574,7 @@ impl<I> FromIterator<I> for Box<[I]> {
 impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A> {
     fn clone(&self) -> Self {
         let alloc = Box::allocator(self).clone();
-        self.to_vec_in(alloc).into_boxed_slice()
+        self.to_boxed_slice_in(alloc)
     }
 
     fn clone_from(&mut self, other: &Self) {

library/alloc/src/slice.rs

@@ -143,6 +143,7 @@ pub use hack::to_vec;
 // `test_permutations` test
 mod hack {
     use core::alloc::Allocator;
+    use core::mem::MaybeUninit;
 
     use crate::boxed::Box;
     use crate::vec::Vec;
@@ -163,10 +164,19 @@ mod hack {
         T::to_vec(s, alloc)
     }
 
+    #[inline]
+    pub fn to_boxed_slice<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Box<[T], A> {
+        T::to_boxed_slice(s, alloc)
+    }
+
     pub trait ConvertVec {
         fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
         where
             Self: Sized;
+
+        fn to_boxed_slice<A: Allocator>(s: &[Self], alloc: A) -> Box<[Self], A>
+        where
+            Self: Sized;
     }
 
     impl<T: Clone> ConvertVec for T {
@@ -203,6 +213,35 @@ mod hack {
             }
             vec
         }
+
+        #[inline]
+        default fn to_boxed_slice<A: Allocator>(s: &[Self], alloc: A) -> Box<[Self], A> {
+            struct DropGuard<T> {
+                dst: *mut T,
+                num_init: usize,
+            }
+            impl<T> Drop for DropGuard<T> {
+                #[inline]
+                fn drop(&mut self) {
+                    let init_slice = core::ptr::slice_from_raw_parts_mut(self.dst, self.num_init);
+                    // SAFETY: all elements in this slice have been initialized
+                    unsafe {
+                        core::ptr::drop_in_place(init_slice);
+                    }
+                }
+            }
+
+            let mut boxed = Box::new_uninit_slice_in(s.len(), alloc);
+            let mut guard =
+                DropGuard { dst: MaybeUninit::slice_as_mut_ptr(&mut boxed), num_init: 0 };
+            while guard.num_init < s.len() {
+                boxed[guard.num_init].write(s[guard.num_init].clone());
+                guard.num_init += 1;
+            }
+            core::mem::forget(guard);
+            // SAFETY: each element is initialized by the loop above
+            unsafe { boxed.assume_init() }
+        }
     }
 
     impl<T: Copy> ConvertVec for T {
@@ -218,6 +257,17 @@ mod hack {
             }
             v
         }
+
+        #[inline]
+        fn to_boxed_slice<A: Allocator>(s: &[Self], alloc: A) -> Box<[Self], A> {
+            let mut boxed = Box::new_uninit_slice_in(s.len(), alloc);
+            let boxed_ptr = MaybeUninit::slice_as_mut_ptr(&mut boxed);
+            // SAFETY: `boxed` contains `s.len()` elements and all are initialized
+            unsafe {
+                s.as_ptr().copy_to_nonoverlapping(boxed_ptr, s.len());
+                boxed.assume_init()
+            }
+        }
     }
 }
 
@@ -477,6 +527,49 @@ impl<T> [T] {
         hack::to_vec(self, alloc)
     }
 
+    /// Clones `self` into a new boxed slice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(slice_to_boxed)]
+    ///
+    /// let s = [1, 2, 3];
+    /// let x: Box<[i32]> = s.to_boxed_slice();
+    /// assert_eq!(&s, x.as_ref());
+    /// ```
+    #[inline]
+    #[unstable(feature = "slice_to_boxed", issue = "82725")]
+    pub fn to_boxed_slice(&self) -> Box<Self>
+    where
+        T: Clone,
+    {
+        self.to_boxed_slice_in(Global)
+    }
+
+    /// Clones `self` into a new boxed slice with an allocator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(allocator_api)]
+    ///
+    /// use std::alloc::System;
+    ///
+    /// let s = [1, 2, 3];
+    /// let x: Box<[i32], System> = s.to_boxed_slice_in(System);
+    /// assert_eq!(&s, x.as_ref());
+    /// ```
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    // #[unstable(feature = "slice_to_boxed", issue = "82725")]
+    pub fn to_boxed_slice_in<A: Allocator>(&self, alloc: A) -> Box<Self, A>
+    where
+        T: Clone,
+    {
+        hack::to_boxed_slice(self, alloc)
+    }
+
     /// Converts `self` into a vector without clones or allocation.
     ///
     /// The resulting vector can be converted back into a box via

library/std/src/sys/unix/fs.rs

@@ -464,8 +464,7 @@ impl Iterator for ReadDir {
                 let ret = DirEntry {
                     entry: *entry_ptr,
                     name: slice::from_raw_parts(name as *const u8, namelen as usize)
-                        .to_owned()
-                        .into_boxed_slice(),
+                        .to_boxed_slice(),
                     dir: Arc::clone(&self.inner),
                 };
                 if ret.name_bytes() != b"." && ret.name_bytes() != b".." {