Add impl const for Clone

Author: Randl

library/core/src/clone.rs

@@ -576,7 +576,8 @@ mod impls {
         ($($t:ty)*) => {
             $(
                 #[stable(feature = "rust1", since = "1.0.0")]
-                impl Clone for $t {
+                #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+                impl const Clone for $t {
                     #[inline(always)]
                     fn clone(&self) -> Self {
                         *self
@@ -594,23 +595,26 @@ mod impls {
     }
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl Clone for ! {
+    #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+    impl const Clone for ! {
         #[inline]
         fn clone(&self) -> Self {
             *self
         }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<T: PointeeSized> Clone for *const T {
+    #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+    impl<T: PointeeSized> const Clone for *const T {
         #[inline(always)]
         fn clone(&self) -> Self {
             *self
         }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<T: PointeeSized> Clone for *mut T {
+    #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+    impl<T: PointeeSized> const Clone for *mut T {
         #[inline(always)]
         fn clone(&self) -> Self {
             *self
@@ -619,7 +623,8 @@ mod impls {
 
     /// Shared references can be cloned, but mutable references *cannot*!
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<T: PointeeSized> Clone for &T {
+    #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+    impl<T: PointeeSized> const Clone for &T {
         #[inline(always)]
         #[rustc_diagnostic_item = "noop_method_clone"]
         fn clone(&self) -> Self {

library/core/src/marker.rs

@@ -462,7 +462,9 @@ marker_impls! {
 // library, and there's no way to safely have this behavior right now.
 #[rustc_unsafe_specialization_marker]
 #[rustc_diagnostic_item = "Copy"]
-pub trait Copy: Clone {
+#[const_trait]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+pub trait Copy: [const] Clone {
     // Empty.
 }
 

library/core/src/ops/control_flow.rs

@@ -83,7 +83,8 @@ use crate::{convert, ops};
 #[must_use]
 // ControlFlow should not implement PartialOrd or Ord, per RFC 3058:
 // https://rust-lang.github.io/rfcs/3058-try-trait-v2.html#traits-for-controlflow
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Eq, Hash)]
+#[derive_const(Clone, Copy, PartialEq)]
 pub enum ControlFlow<B, C = ()> {
     /// Move on to the next phase of the operation as normal.
     #[stable(feature = "control_flow_enum_type", since = "1.55.0")]

library/core/src/ops/index_range.rs

@@ -9,7 +9,8 @@ use crate::ub_checks;
 ///
 /// (Normal `Range` code needs to handle degenerate ranges like `10..0`,
 ///  which takes extra checks compared to only handling the canonical form.)
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug, Eq)]
+#[derive_const(Clone, PartialEq)]
 pub(crate) struct IndexRange {
     start: usize,
     end: usize,

library/core/src/ops/range.rs

@@ -38,7 +38,8 @@ use crate::hash::Hash;
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeFull"]
 #[doc(alias = "..")]
-#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[derive(Eq, Hash)]
+#[derive_const(Copy, Clone, Default, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFull;
 
@@ -75,7 +76,8 @@ impl fmt::Debug for RangeFull {
 /// ```
 #[lang = "Range"]
 #[doc(alias = "..")]
-#[derive(Clone, Default, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Eq, Hash)]
+#[derive_const(Clone, Default, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Range<Idx> {
     /// The lower bound of the range (inclusive).
@@ -184,7 +186,8 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
 /// ```
 #[lang = "RangeFrom"]
 #[doc(alias = "..")]
-#[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Eq, Hash)]
+#[derive_const(Clone, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
@@ -266,7 +269,8 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeTo"]
 #[doc(alias = "..")]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Eq, Hash)]
+#[derive_const(Copy, Clone, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeTo<Idx> {
     /// The upper bound of the range (exclusive).
@@ -340,7 +344,8 @@ impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
 /// ```
 #[lang = "RangeInclusive"]
 #[doc(alias = "..=")]
-#[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186
+#[derive(Eq, Hash)]
+#[derive_const(Clone, PartialEq)] // not Copy -- see #27186
 #[stable(feature = "inclusive_range", since = "1.26.0")]
 pub struct RangeInclusive<Idx> {
     // Note that the fields here are not public to allow changing the
@@ -587,7 +592,8 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
 /// [slicing index]: crate::slice::SliceIndex
 #[lang = "RangeToInclusive"]
 #[doc(alias = "..=")]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Hash)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[stable(feature = "inclusive_range", since = "1.26.0")]
 pub struct RangeToInclusive<Idx> {
     /// The upper bound of the range (inclusive)
@@ -668,7 +674,8 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 ///
 /// [`BTreeMap::range`]: ../../std/collections/btree_map/struct.BTreeMap.html#method.range
 #[stable(feature = "collections_bound", since = "1.17.0")]
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Debug, Eq, Hash)]
+#[derive_const(Clone, Copy, PartialEq)]
 pub enum Bound<T> {
     /// An inclusive bound.
     #[stable(feature = "collections_bound", since = "1.17.0")]

library/core/src/slice/mod.rs

@@ -8,6 +8,7 @@
 
 use crate::cmp::Ordering::{self, Equal, Greater, Less};
 use crate::intrinsics::{exact_div, unchecked_sub};
+use crate::marker::Destruct;
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::num::NonZero;
 use crate::ops::{OneSidedRange, OneSidedRangeBound, Range, RangeBounds, RangeInclusive};
@@ -3785,10 +3786,12 @@ impl<T> [T] {
     /// [`copy_from_slice`]: slice::copy_from_slice
     /// [`split_at_mut`]: slice::split_at_mut
     #[stable(feature = "clone_from_slice", since = "1.7.0")]
+    #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+    #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
     #[track_caller]
-    pub fn clone_from_slice(&mut self, src: &[T])
+    pub const fn clone_from_slice(&mut self, src: &[T])
     where
-        T: Clone,
+        T: [const] Clone + [const] Destruct,
     {
         self.spec_clone_from(src);
     }
@@ -5089,31 +5092,43 @@ impl [f64] {
     }
 }
 
+#[const_trait]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
 trait CloneFromSpec<T> {
-    fn spec_clone_from(&mut self, src: &[T]);
+    fn spec_clone_from(&mut self, src: &[T])
+    where
+        T: [const] Destruct;
 }
 
-impl<T> CloneFromSpec<T> for [T]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+impl<T> const CloneFromSpec<T> for [T]
 where
-    T: Clone,
+    T: [const] Clone,
 {
     #[track_caller]
-    default fn spec_clone_from(&mut self, src: &[T]) {
+    default fn spec_clone_from(&mut self, src: &[T])
+    where
+        T: [const] Destruct,
+    {
         assert!(self.len() == src.len(), "destination and source slices have different lengths");
         // NOTE: We need to explicitly slice them to the same length
         // to make it easier for the optimizer to elide bounds checking.
         // But since it can't be relied on we also have an explicit specialization for T: Copy.
         let len = self.len();
         let src = &src[..len];
-        for i in 0..len {
-            self[i].clone_from(&src[i]);
+        // FIXME(const_hack): make this a `for idx in 0..self.len()` loop.
+        let mut idx = 0;
+        while idx < self.len() {
+            self[idx].clone_from(&src[idx]);
+            idx += 1;
         }
     }
 }
 
-impl<T> CloneFromSpec<T> for [T]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
+impl<T> const CloneFromSpec<T> for [T]
 where
-    T: Copy,
+    T: [const] Copy,
 {
     #[track_caller]
     fn spec_clone_from(&mut self, src: &[T]) {

library/core/src/tuple.rs

@@ -122,7 +122,8 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($T: Default),+> Default for ($($T,)+) {
+            #[rustc_const_unstable(feature = "const_default", issue = "143894")]
+            impl<$($T: ~const Default),+> const Default for ($($T,)+) {
                 #[inline]
                 fn default() -> ($($T,)+) {
                     ($({ let x: $T = Default::default(); x},)+)

tests/ui/traits/const-traits/const-clone.rs

@@ -0,0 +1,72 @@
+#![feature(
+    const_trait_impl, const_default, const_clone, ptr_alignment_type,
+    ascii_char, f16, f128, sync_unsafe_cell,
+)]
+#![allow(dead_code)]
+// core::default
+const UNIT: () = Default::default();
+const BOOL: bool = Default::default();
+const CHAR: char = Default::default();
+const ASCII_CHAR: std::ascii::Char = Default::default();
+const USIZE: usize = Default::default();
+const U8: u8 = Default::default();
+const U16: u16 = Default::default();
+const U32: u32 = Default::default();
+const U64: u64 = Default::default();
+const U128: u128 = Default::default();
+const I8: i8 = Default::default();
+const I16: i16 = Default::default();
+const I32: i32 = Default::default();
+const I64: i64 = Default::default();
+const I128: i128 = Default::default();
+const F16: f16 = Default::default();
+const F32: f32 = Default::default();
+const F64: f64 = Default::default();
+const F128: f128 = Default::default();
+// core::marker
+const PHANTOM: std::marker::PhantomData<()> = Default::default();
+// core::option
+const OPT: Option<i32> = Default::default();
+// core::iter::sources::empty
+const EMPTY: std::iter::Empty<()> = Default::default();
+// core::ptr::alignment
+const ALIGNMENT: std::ptr::Alignment = Default::default();
+// core::slice
+const SLICE: &[()] = Default::default();
+const MUT_SLICE: &mut [()] = Default::default();
+// core::str
+const STR: &str = Default::default();
+const MUT_STR: &mut str = Default::default();
+// core::cell
+const CELL: std::cell::Cell<()> = Default::default();
+const REF_CELL: std::cell::RefCell<()> = Default::default();
+const UNSAFE_CELL: std::cell::UnsafeCell<()> = Default::default();
+const SYNC_UNSAFE_CELL: std::cell::SyncUnsafeCell<()> = Default::default();
+const TUPLE: (u8, u16, u32, u64, u128, i8) = Default::default();
+
+// core::clone
+const UNIT_CLONE: () = UNIT.clone();
+//~^ ERROR: the trait bound `(): const Clone` is not satisfied
+const BOOL_CLONE: bool = BOOL.clone();
+const CHAR_CLONE: char = CHAR.clone();
+const ASCII_CHAR_CLONE: std::ascii::Char = ASCII_CHAR.clone();
+//~^ ERROR: the trait bound `Char: const Clone` is not satisfied
+const USIZE_CLONE: usize = USIZE.clone();
+const U8_CLONE: u8 = U8.clone();
+const U16_CLONE: u16 = U16.clone();
+const U32_CLONE: u32 = U32.clone();
+const U64_CLONE: u64 = U64.clone();
+const U128_CLONE: u128 = U128.clone();
+const I8_CLONE: i8 = I8.clone();
+const I16_CLONE: i16 = I16.clone();
+const I32_CLONE: i32 = I32.clone();
+const I64_CLONE: i64 = I64.clone();
+const I128_CLONE: i128 = I128.clone();
+const F16_CLONE: f16 = F16.clone();
+const F32_CLONE: f32 = F32.clone();
+const F64_CLONE: f64 = F64.clone();
+const F128_CLONE: f128 = F128.clone();
+const TUPLE_CLONE: (u8, u16, u32, u64, u128, i8)  = TUPLE.clone();
+//~^ ERROR: the trait bound `(u8, u16, u32, u64, u128, i8): const Clone` is not satisfied [E0277]
+
+fn main() {}

tests/ui/traits/const-traits/const-clone.stderr

@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `(): const Clone` is not satisfied
+  --> $DIR/const-clone.rs:48:29
+   |
+LL | const UNIT_CLONE: () = UNIT.clone();
+   |                             ^^^^^
+
+error[E0277]: the trait bound `Char: const Clone` is not satisfied
+  --> $DIR/const-clone.rs:52:55
+   |
+LL | const ASCII_CHAR_CLONE: std::ascii::Char = ASCII_CHAR.clone();
+   |                                                       ^^^^^
+
+error[E0277]: the trait bound `(u8, u16, u32, u64, u128, i8): const Clone` is not satisfied
+  --> $DIR/const-clone.rs:69:59
+   |
+LL | const TUPLE_CLONE: (u8, u16, u32, u64, u128, i8)  = TUPLE.clone();
+   |                                                           ^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.