Add impl const for Clone and derive_const for cmp and Default traits

library/core/src/clone.rs

@@ -575,7 +575,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
@@ -593,23 +594,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
@@ -618,7 +622,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,8 +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(Copy, Debug, Hash)]
-#[derive_const(Clone, PartialEq, Eq)]
+#[derive(Debug, Hash)]
+#[derive_const(Copy, Clone, PartialEq, Eq)]
 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_const(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};
@@ -5089,8 +5090,12 @@ 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]
@@ -5105,8 +5110,11 @@ where
  // 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;
  }
  }
 }

library/core/src/tuple.rs

@@ -120,7 +120,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},)+)

library/coretests/tests/clone.rs

@@ -121,3 +121,66 @@ fn cstr_metadata_is_length_with_nul() {
  let bytes: *const [u8] = p as *const [u8];
  assert_eq!(s.to_bytes_with_nul().len(), bytes.len());
 }
+
+#[test]
+fn test_const_clone() {
+ const {
+ let bool: bool = Default::default();
+ let char: char = Default::default();
+ let ascii_char: std::ascii::Char = Default::default();
+ let usize: usize = Default::default();
+ let u8: u8 = Default::default();
+ let u16: u16 = Default::default();
+ let u32: u32 = Default::default();
+ let u64: u64 = Default::default();
+ let u128: u128 = Default::default();
+ let i8: i8 = Default::default();
+ let i16: i16 = Default::default();
+ let i32: i32 = Default::default();
+ let i64: i64 = Default::default();
+ let i128: i128 = Default::default();
+ let f16: f16 = Default::default();
+ let f32: f32 = Default::default();
+ let f64: f64 = Default::default();
+ let f128: f128 = Default::default();
+
+ let bool_clone: bool = bool.clone();
+ let char_clone: char = char.clone();
+ let ascii_char_clone: std::ascii::Char = ascii_char.clone();
+
+ let usize_clone: usize = usize.clone();
+ let u8_clone: u8 = u8.clone();
+ let u16_clone: u16 = u16.clone();
+ let u32_clone: u32 = u32.clone();
+ let u64_clone: u64 = u64.clone();
+ let u128_clone: u128 = u128.clone();
+ let i8_clone: i8 = i8.clone();
+ let i16_clone: i16 = i16.clone();
+ let i32_clone: i32 = i32.clone();
+ let i64_clone: i64 = i64.clone();
+ let i128_clone: i128 = i128.clone();
+ let f16_clone: f16 = f16.clone();
+ let f32_clone: f32 = f32.clone();
+ let f64_clone: f64 = f64.clone();
+ let f128_clone: f128 = f128.clone();
+
+ assert!(bool == bool_clone);
+ assert!(char == char_clone);
+ assert!(ascii_char == ascii_char_clone);
+ assert!(usize == usize_clone);
+ assert!(u8 == u8_clone);
+ assert!(u16 == u16_clone);
+ assert!(u32 == u32_clone);
+ assert!(u64 == u64_clone);
+ assert!(u128 == u128_clone);
+ assert!(i8 == i8_clone);
+ assert!(i16 == i16_clone);
+ assert!(i32 == i32_clone);
+ assert!(i64 == i64_clone);
+ assert!(i128 == i128_clone);
+ assert!(f16 == f16_clone);
+ assert!(f32 == f32_clone);
+ assert!(f64 == f64_clone);
+ assert!(f128 == f128_clone);
+ }
+}

library/coretests/tests/lib.rs

@@ -16,10 +16,13 @@
 #![feature(char_internals)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
+#![feature(const_clone)]
 #![feature(const_cmp)]
 #![feature(const_convert)]
+#![feature(const_default)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
+#![feature(const_index)]
 #![feature(const_mul_add)]
 #![feature(const_ops)]
 #![feature(const_option_ops)]