Add CloneToUninit::clone_to_init

This is necessary to properly support `Clone::clone_from`.

Author: a1phyr

library/core/src/clone.rs

@@ -439,6 +439,16 @@ pub struct AssertParamIsCopy<T: Copy + PointeeSized> {
 ///         // All fields of the struct have been initialized; therefore, the struct is initialized,
 ///         // and we have satisfied our `unsafe impl CloneToUninit` obligations.
 ///     }
+///
+///     unsafe fn clone_to_init(&self, dest: *mut u8) {
+///         // SAFETY: The caller must provide a `dest` such that these field offsets are valid
+///         // to write to.
+///         unsafe {
+///             let offset_of_contents = (&raw const self.contents).byte_offset_from_unsigned(self);
+///             self.contents.clone_to_init(dest.add(offset_of_contents));
+///             self.label.clone_to_init(dest.add(offset_of!(Self, label)));
+///         }
+///     }
 /// }
 ///
 /// fn main() {
@@ -509,6 +519,15 @@ pub unsafe trait CloneToUninit {
     /// cloned, and the second of the three calls to `Foo::clone()` unwinds, then the first `Foo`
     /// cloned should be dropped.)
     unsafe fn clone_to_uninit(&self, dest: *mut u8);
+
+    /// Clones `self` to `dest`
+    ///
+    /// This is similar to `Clone::clone_from`, but unsafe and dyn-compatible.
+    ///
+    /// # Safety
+    ///
+    /// `dest` must be a valid pointer to a valid value of the same concrete type than `self`.
+    unsafe fn clone_to_init(&self, dest: *mut u8);
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
@@ -518,6 +537,13 @@ unsafe impl<T: Clone> CloneToUninit for T {
         // SAFETY: we're calling a specialization with the same contract
         unsafe { <T as self::uninit::CopySpec>::clone_one(self, dest.cast::<T>()) }
     }
+
+    #[inline]
+    unsafe fn clone_to_init(&self, dest: *mut u8) {
+        // SAFETY: by contract, `dest` is a valid pointer to `T`
+        let dest = unsafe { dest.cast::<T>().as_mut_unchecked() };
+        dest.clone_from(self);
+    }
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
@@ -529,6 +555,15 @@ unsafe impl<T: Clone> CloneToUninit for [T] {
         // SAFETY: we're calling a specialization with the same contract
         unsafe { <T as self::uninit::CopySpec>::clone_slice(self, dest) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dest: *mut u8) {
+        // SAFETY: by contract, `dest` is a valid pointer to a `[T]` with the
+        // same length as `self`
+        let dest = unsafe { dest.with_metadata_of(self).as_mut_unchecked() };
+        dest.clone_from_slice(self);
+    }
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
@@ -539,18 +574,33 @@ unsafe impl CloneToUninit for str {
         // SAFETY: str is just a [u8] with UTF-8 invariant
         unsafe { self.as_bytes().clone_to_uninit(dest) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dest: *mut u8) {
+        // SAFETY: str is just a [u8] with UTF-8 invariant
+        unsafe { self.as_bytes().clone_to_init(dest) }
+    }
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for crate::ffi::CStr {
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dest: *mut u8) {
-        // SAFETY: For now, CStr is just a #[repr(trasnsparent)] [c_char] with some invariants.
+        // SAFETY: For now, CStr is just a #[repr(transparent)] [c_char] with some invariants.
         // And we can cast [c_char] to [u8] on all supported platforms (see: to_bytes_with_nul).
         // The pointer metadata properly preserves the length (so NUL is also copied).
         // See: `cstr_metadata_is_length_with_nul` in tests.
         unsafe { self.to_bytes_with_nul().clone_to_uninit(dest) }
     }
+
+    unsafe fn clone_to_init(&self, dest: *mut u8) {
+        // SAFETY: For now, CStr is just a #[repr(transparent)] [c_char] with some invariants.
+        // And we can cast [c_char] to [u8] on all supported platforms (see: to_bytes_with_nul).
+        // The pointer metadata properly preserves the length (so NUL is also copied).
+        // See: `cstr_metadata_is_length_with_nul` in tests.
+        unsafe { self.to_bytes_with_nul().clone_to_init(dest) }
+    }
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
@@ -561,6 +611,12 @@ unsafe impl CloneToUninit for crate::bstr::ByteStr {
         // SAFETY: ByteStr is a `#[repr(transparent)]` wrapper around `[u8]`
         unsafe { self.as_bytes().clone_to_uninit(dst) }
     }
+
+    #[inline]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: ByteStr is a `#[repr(transparent)]` wrapper around `[u8]`
+        unsafe { self.as_bytes().clone_to_uninit(dst) }
+    }
 }
 
 /// Implementations of `Clone` for primitive types.

library/core/src/wtf8.rs

@@ -594,4 +594,11 @@ unsafe impl CloneToUninit for Wtf8 {
         // SAFETY: we're just a transparent wrapper around [u8]
         unsafe { self.bytes.clone_to_uninit(dst) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: we're just a transparent wrapper around [u8]
+        unsafe { self.bytes.clone_to_init(dst) }
+    }
 }

library/std/src/ffi/os_str.rs

@@ -1345,6 +1345,13 @@ unsafe impl CloneToUninit for OsStr {
         // SAFETY: we're just a transparent wrapper around a platform-specific Slice
         unsafe { self.inner.clone_to_uninit(dst) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: we're just a transparent wrapper around a platform-specific Slice
+        unsafe { self.inner.clone_to_init(dst) }
+    }
 }
 
 #[stable(feature = "shared_from_slice2", since = "1.24.0")]

library/std/src/path.rs

@@ -3340,6 +3340,13 @@ unsafe impl CloneToUninit for Path {
         // SAFETY: Path is just a transparent wrapper around OsStr
         unsafe { self.inner.clone_to_uninit(dst) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: Path is just a transparent wrapper around OsStr
+        unsafe { self.inner.clone_to_init(dst) }
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

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

@@ -382,4 +382,11 @@ unsafe impl CloneToUninit for Slice {
         // SAFETY: we're just a transparent wrapper around [u8]
         unsafe { self.inner.clone_to_uninit(dst) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: we're just a transparent wrapper around [u8]
+        unsafe { self.inner.clone_to_init(dst) }
+    }
 }

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

@@ -329,4 +329,11 @@ unsafe impl CloneToUninit for Slice {
         // SAFETY: we're just a transparent wrapper around Wtf8
         unsafe { self.inner.clone_to_uninit(dst) }
     }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_init(&self, dst: *mut u8) {
+        // SAFETY: we're just a transparent wrapper around Wtf8
+        unsafe { self.inner.clone_to_init(dst) }
+    }
 }