Implement some conversions using Box::clone_from_ref

Author: zachs18

library/alloc/src/boxed/convert.rs

@@ -1,21 +1,15 @@
 use core::any::Any;
-#[cfg(not(no_global_oom_handling))]
-use core::clone::TrivialClone;
 use core::error::Error;
+#[cfg(not(no_global_oom_handling))]
+use core::fmt;
 use core::mem;
 use core::pin::Pin;
-#[cfg(not(no_global_oom_handling))]
-use core::{fmt, ptr};
 
 use crate::alloc::Allocator;
 #[cfg(not(no_global_oom_handling))]
 use crate::borrow::Cow;
 use crate::boxed::Box;
 #[cfg(not(no_global_oom_handling))]
-use crate::raw_vec::RawVec;
-#[cfg(not(no_global_oom_handling))]
-use crate::str::from_boxed_utf8_unchecked;
-#[cfg(not(no_global_oom_handling))]
 use crate::string::String;
 #[cfg(not(no_global_oom_handling))]
 use crate::vec::Vec;
@@ -62,35 +56,6 @@ where
     }
 }
 
-/// Specialization trait used for `From<&[T]>`.
-#[cfg(not(no_global_oom_handling))]
-trait BoxFromSlice<T> {
-    fn from_slice(slice: &[T]) -> Self;
-}
-
-#[cfg(not(no_global_oom_handling))]
-impl<T: Clone> BoxFromSlice<T> for Box<[T]> {
-    #[inline]
-    default fn from_slice(slice: &[T]) -> Self {
-        slice.to_vec().into_boxed_slice()
-    }
-}
-
-#[cfg(not(no_global_oom_handling))]
-impl<T: TrivialClone> BoxFromSlice<T> for Box<[T]> {
-    #[inline]
-    fn from_slice(slice: &[T]) -> Self {
-        let len = slice.len();
-        let buf = RawVec::with_capacity(len);
-        // SAFETY: since `T` implements `TrivialClone`, this is sound and
-        // equivalent to the above.
-        unsafe {
-            ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
-            buf.into_box(slice.len()).assume_init()
-        }
-    }
-}
-
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "box_from_slice", since = "1.17.0")]
 impl<T: Clone> From<&[T]> for Box<[T]> {
@@ -109,7 +74,7 @@ impl<T: Clone> From<&[T]> for Box<[T]> {
     /// ```
     #[inline]
     fn from(slice: &[T]) -> Box<[T]> {
-        <Self as BoxFromSlice<T>>::from_slice(slice)
+        Box::clone_from_ref(slice)
     }
 }
 
@@ -170,7 +135,7 @@ impl From<&str> for Box<str> {
     /// ```
     #[inline]
     fn from(s: &str) -> Box<str> {
-        unsafe { from_boxed_utf8_unchecked(Box::from(s.as_bytes())) }
+        Box::clone_from_ref(s)
     }
 }
 

library/alloc/src/ffi/c_str.rs

@@ -766,8 +766,7 @@ impl From<&CStr> for Box<CStr> {
     /// Converts a `&CStr` into a `Box<CStr>`,
     /// by copying the contents into a newly allocated [`Box`].
     fn from(s: &CStr) -> Box<CStr> {
-        let boxed: Box<[u8]> = Box::from(s.to_bytes_with_nul());
-        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }
+        Box::clone_from_ref(s)
     }
 }
 

library/std/src/ffi/os_str.rs

@@ -1285,8 +1285,7 @@ impl From<&OsStr> for Box<OsStr> {
     /// Copies the string into a newly allocated <code>[Box]&lt;[OsStr]&gt;</code>.
     #[inline]
     fn from(s: &OsStr) -> Box<OsStr> {
-        let rw = Box::into_raw(s.inner.into_box()) as *mut OsStr;
-        unsafe { Box::from_raw(rw) }
+        Box::clone_from_ref(s)
     }
 }
 

library/std/src/path.rs

@@ -1877,9 +1877,7 @@ impl From<&Path> for Box<Path> {
     ///
     /// This will allocate and clone `path` to it.
     fn from(path: &Path) -> Box<Path> {
-        let boxed: Box<OsStr> = path.inner.into();
-        let rw = Box::into_raw(boxed) as *mut Path;
-        unsafe { Box::from_raw(rw) }
+        Box::clone_from_ref(path)
     }
 }
 

library/std/src/sys/os_str/bytes.rs

@@ -321,12 +321,6 @@ impl Slice {
         self.inner.clone_into(&mut buf.inner)
     }
 
-    #[inline]
-    pub fn into_box(&self) -> Box<Slice> {
-        let boxed: Box<[u8]> = self.inner.into();
-        unsafe { mem::transmute(boxed) }
-    }
-
     #[inline]
     pub fn empty_box() -> Box<Slice> {
         let boxed: Box<[u8]> = Default::default();

library/std/src/sys/os_str/wtf8.rs

@@ -271,11 +271,6 @@ impl Slice {
         self.inner.clone_into(&mut buf.inner)
     }
 
-    #[inline]
-    pub fn into_box(&self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_box()) }
-    }
-
     #[inline]
     pub fn empty_box() -> Box<Slice> {
         unsafe { mem::transmute(Wtf8::empty_box()) }