core: make TrivialClone a subtrait of Copy and revert some associated unsafe

Author: joboet

library/core/src/array/mod.rs

@@ -9,6 +9,7 @@ use crate::clone::TrivialClone;
 use crate::cmp::Ordering;
 use crate::convert::Infallible;
 use crate::error::Error;
+use crate::fmt;
 use crate::hash::{self, Hash};
 use crate::intrinsics::transmute_unchecked;
 use crate::iter::{UncheckedIterator, repeat_n};
@@ -18,7 +19,6 @@ use crate::ops::{
 };
 use crate::ptr::{null, null_mut};
 use crate::slice::{Iter, IterMut};
-use crate::{fmt, ptr};
 
 mod ascii;
 mod drain;
@@ -444,9 +444,7 @@ impl<T: Clone> SpecArrayClone for T {
 impl<T: TrivialClone> SpecArrayClone for T {
     #[inline]
     fn clone<const N: usize>(array: &[T; N]) -> [T; N] {
-        // SAFETY: `TrivialClone` implies that this is equivalent to calling
-        // `Clone` on every element.
-        unsafe { ptr::read(array) }
+        *array
     }
 }
 

library/core/src/clone.rs

@@ -205,7 +205,7 @@ pub trait Clone: Sized {
 // implementations of `TrivialClone`. To keep it from appearing in error
 // messages, make it a `#[marker]` trait.
 #[marker]
-pub unsafe trait TrivialClone: Clone {}
+pub unsafe trait TrivialClone: Copy {}
 
 /// Derive macro generating an impl of the trait `Clone`.
 #[rustc_builtin_macro]

library/core/src/mem/maybe_uninit.rs

@@ -275,7 +275,7 @@ impl<T: Copy> Clone for MaybeUninit<T> {
 
 // SAFETY: the clone implementation is a copy, see above.
 #[unstable(feature = "trivial_clone", issue = "none")]
-unsafe impl<T> TrivialClone for MaybeUninit<T> where MaybeUninit<T>: Clone {}
+unsafe impl<T> TrivialClone for MaybeUninit<T> where MaybeUninit<T>: Copy {}
 
 #[stable(feature = "maybe_uninit_debug", since = "1.41.0")]
 impl<T> fmt::Debug for MaybeUninit<T> {

library/core/src/slice/mod.rs

@@ -3738,8 +3738,30 @@ impl<T> [T] {
     where
         T: Copy,
     {
-        // SAFETY: `T` implements `Copy`.
-        unsafe { copy_from_slice_impl(self, src) }
+        // The panic code path was put into a cold function to not bloat the
+        // call site.
+        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
+        #[cfg_attr(feature = "panic_immediate_abort", inline)]
+        #[track_caller]
+        const fn len_mismatch_fail(dst_len: usize, src_len: usize) -> ! {
+            const_panic!(
+                "copy_from_slice: source slice length does not match destination slice length",
+                "copy_from_slice: source slice length ({src_len}) does not match destination slice length ({dst_len})",
+                src_len: usize,
+                dst_len: usize,
+            )
+        }
+
+        if self.len() != src.len() {
+            len_mismatch_fail(self.len(), src.len());
+        }
+
+        // SAFETY: `self` is valid for `self.len()` elements by definition, and `src` was
+        // checked to have the same length. The slices cannot overlap because
+        // mutable references are exclusive.
+        unsafe {
+            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr(), self.len());
+        }
     }
 
     /// Copies elements from one part of the slice to another part of itself,
@@ -4878,38 +4900,6 @@ impl [f64] {
     }
 }
 
-/// Copies `src` to `dest`.
-///
-/// # Safety
-/// `T` must implement one of `Copy` or `TrivialClone`.
-#[track_caller]
-const unsafe fn copy_from_slice_impl<T: Clone>(dest: &mut [T], src: &[T]) {
-    // The panic code path was put into a cold function to not bloat the
-    // call site.
-    #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-    #[cfg_attr(feature = "panic_immediate_abort", inline)]
-    #[track_caller]
-    const fn len_mismatch_fail(dst_len: usize, src_len: usize) -> ! {
-        const_panic!(
-            "copy_from_slice: source slice length does not match destination slice length",
-            "copy_from_slice: source slice length ({src_len}) does not match destination slice length ({dst_len})",
-            src_len: usize,
-            dst_len: usize,
-        )
-    }
-
-    if dest.len() != src.len() {
-        len_mismatch_fail(dest.len(), src.len());
-    }
-
-    // SAFETY: `self` is valid for `self.len()` elements by definition, and `src` was
-    // checked to have the same length. The slices cannot overlap because
-    // mutable references are exclusive.
-    unsafe {
-        ptr::copy_nonoverlapping(src.as_ptr(), dest.as_mut_ptr(), dest.len());
-    }
-}
-
 trait CloneFromSpec<T> {
     fn spec_clone_from(&mut self, src: &[T]);
 }
@@ -4938,10 +4928,7 @@ where
 {
     #[track_caller]
     fn spec_clone_from(&mut self, src: &[T]) {
-        // SAFETY: `T` implements `TrivialClone`.
-        unsafe {
-            copy_from_slice_impl(self, src);
-        }
+        self.copy_from_slice(src);
     }
 }
 

library/core/src/slice/specialize.rs

@@ -1,5 +1,4 @@
 use crate::clone::TrivialClone;
-use crate::ptr;
 
 pub(super) trait SpecFill<T> {
     fn spec_fill(&mut self, value: T);
@@ -20,9 +19,7 @@ impl<T: Clone> SpecFill<T> for [T] {
 impl<T: TrivialClone> SpecFill<T> for [T] {
     fn spec_fill(&mut self, value: T) {
         for item in self.iter_mut() {
-            // SAFETY: `TrivialClone` indicates that this is equivalent to
-            // calling `Clone::clone`
-            *item = unsafe { ptr::read(&value) };
+            *item = value;
         }
     }
 }