constify the Eq, PartialOrd and Ord traits

Also constify the impls of basic types.

One potentially controversial part of this change is making Eq, a
marker trait, const. I chose to do this ease user adoption.
Otherwise, code which already has an Eq bound and uses it to
proxy a PartialEq bound would need to add a separate bound. This
would cause a litering of bounds in downstream types.

I also chose to inline default_chaining_impl() since this avoids
making the core comparison constness depend on const closures.
The code duplication is minimal.

Author: npmccallum

library/core/src/cmp.rs

@@ -31,6 +31,7 @@ pub(crate) use bytewise::BytewiseEq;
 use self::Ordering::*;
 use crate::marker::PointeeSized;
 use crate::ops::ControlFlow;
+use crate::marker::Destruct;
 
 /// Trait for comparisons using the equality operator.
 ///
@@ -335,7 +336,8 @@ pub macro PartialEq($item:item) {
 #[doc(alias = "!=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Eq"]
-pub trait Eq: PartialEq<Self> + PointeeSized {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const trait Eq: [const] PartialEq<Self> + PointeeSized {
     // this method is used solely by `impl Eq or #[derive(Eq)]` to assert that every component of a
     // type implements `Eq` itself. The current deriving infrastructure means doing this assertion
     // without using a method on this trait is nearly impossible.
@@ -958,7 +960,8 @@ impl<T: Clone> Clone for Reverse<T> {
 #[doc(alias = ">=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Ord"]
-pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const trait Ord: [const] Eq + [const] PartialOrd<Self> + PointeeSized {
     /// This method returns an [`Ordering`] between `self` and `other`.
     ///
     /// By convention, `self.cmp(&other)` returns the ordering matching the expression
@@ -1012,7 +1015,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[rustc_diagnostic_item = "cmp_ord_max"]
     fn max(self, other: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         if other < self { self } else { other }
     }
@@ -1051,7 +1054,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[rustc_diagnostic_item = "cmp_ord_min"]
     fn min(self, other: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         if other < self { other } else { self }
     }
@@ -1077,7 +1080,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[stable(feature = "clamp", since = "1.50.0")]
     fn clamp(self, min: Self, max: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         assert!(min <= max);
         if self < min {
@@ -1342,7 +1345,8 @@ pub macro Ord($item:item) {
 )]
 #[rustc_diagnostic_item = "PartialOrd"]
 #[allow(multiple_supertrait_upcastable)] // FIXME(sized_hierarchy): remove this
-pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const trait PartialOrd<Rhs: PointeeSized = Self>: [const] PartialEq<Rhs> + PointeeSized {
     /// This method returns an ordering between `self` and `other` values if one exists.
     ///
     /// # Examples
@@ -1454,50 +1458,59 @@ pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
     #[unstable(feature = "partial_ord_chaining_methods", issue = "none")]
     #[doc(hidden)]
     fn __chaining_lt(&self, other: &Rhs) -> ControlFlow<bool> {
-        default_chaining_impl(self, other, Ordering::is_lt)
+        // It's important that this only call `partial_cmp` once, not call `eq` then
+        // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
+        // `String`, for example, or similarly for other data structures (#108157).
+        match self.partial_cmp(other) {
+            Some(Equal) => ControlFlow::Continue(()),
+            Some(c) => ControlFlow::Break(c.is_lt()),
+            None => ControlFlow::Break(false),
+        }
     }
 
     /// Same as `__chaining_lt`, but for `<=` instead of `<`.
     #[inline]
     #[unstable(feature = "partial_ord_chaining_methods", issue = "none")]
     #[doc(hidden)]
     fn __chaining_le(&self, other: &Rhs) -> ControlFlow<bool> {
-        default_chaining_impl(self, other, Ordering::is_le)
+        // It's important that this only call `partial_cmp` once, not call `eq` then
+        // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
+        // `String`, for example, or similarly for other data structures (#108157).
+        match self.partial_cmp(other) {
+            Some(Equal) => ControlFlow::Continue(()),
+            Some(c) => ControlFlow::Break(c.is_le()),
+            None => ControlFlow::Break(false),
+        }
     }
 
     /// Same as `__chaining_lt`, but for `>` instead of `<`.
     #[inline]
     #[unstable(feature = "partial_ord_chaining_methods", issue = "none")]
     #[doc(hidden)]
     fn __chaining_gt(&self, other: &Rhs) -> ControlFlow<bool> {
-        default_chaining_impl(self, other, Ordering::is_gt)
+        // It's important that this only call `partial_cmp` once, not call `eq` then
+        // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
+        // `String`, for example, or similarly for other data structures (#108157).
+        match self.partial_cmp(other) {
+            Some(Equal) => ControlFlow::Continue(()),
+            Some(c) => ControlFlow::Break(c.is_gt()),
+            None => ControlFlow::Break(false),
+        }
     }
 
     /// Same as `__chaining_lt`, but for `>=` instead of `<`.
     #[inline]
     #[unstable(feature = "partial_ord_chaining_methods", issue = "none")]
     #[doc(hidden)]
     fn __chaining_ge(&self, other: &Rhs) -> ControlFlow<bool> {
-        default_chaining_impl(self, other, Ordering::is_ge)
-    }
-}
-
-fn default_chaining_impl<T, U>(
-    lhs: &T,
-    rhs: &U,
-    p: impl FnOnce(Ordering) -> bool,
-) -> ControlFlow<bool>
-where
-    T: PartialOrd<U> + PointeeSized,
-    U: PointeeSized,
-{
-    // It's important that this only call `partial_cmp` once, not call `eq` then
-    // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
-    // `String`, for example, or similarly for other data structures (#108157).
-    match <T as PartialOrd<U>>::partial_cmp(lhs, rhs) {
-        Some(Equal) => ControlFlow::Continue(()),
-        Some(c) => ControlFlow::Break(p(c)),
-        None => ControlFlow::Break(false),
+        // It's important that this only call `partial_cmp` once, not call `eq` then
+        // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
+        // `String`, for example, or similarly for other data structures (#108157).
+        match self.partial_cmp(other) {
+            Some(Equal) => ControlFlow::Continue(()),
+            Some(c) => ControlFlow::Break(c.is_ge()),
+            None => ControlFlow::Break(false),
+        }
     }
 }
 
@@ -1831,7 +1844,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialEq for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialEq for () {
         #[inline]
         fn eq(&self, _other: &()) -> bool {
             true
@@ -1849,7 +1863,8 @@ mod impls {
     macro_rules! eq_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl Eq for $t {}
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const Eq for $t {}
         )*)
     }
 
@@ -1897,7 +1912,8 @@ mod impls {
     macro_rules! partial_ord_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl PartialOrd for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const PartialOrd for $t {
                 #[inline]
                 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
                     match (*self <= *other, *self >= *other) {
@@ -1914,15 +1930,17 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialOrd for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialOrd for () {
         #[inline]
         fn partial_cmp(&self, _: &()) -> Option<Ordering> {
             Some(Equal)
         }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialOrd for bool {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialOrd for bool {
         #[inline]
         fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
             Some(self.cmp(other))
@@ -1936,7 +1954,8 @@ mod impls {
     macro_rules! ord_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl PartialOrd for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const PartialOrd for $t {
                 #[inline]
                 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
                     Some(crate::intrinsics::three_way_compare(*self, *other))
@@ -1946,7 +1965,8 @@ mod impls {
             }
 
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl Ord for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const Ord for $t {
                 #[inline]
                 fn cmp(&self, other: &Self) -> Ordering {
                     crate::intrinsics::three_way_compare(*self, *other)
@@ -1956,15 +1976,17 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl Ord for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Ord for () {
         #[inline]
         fn cmp(&self, _other: &()) -> Ordering {
             Equal
         }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl Ord for bool {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Ord for bool {
         #[inline]
         fn cmp(&self, other: &bool) -> Ordering {
             // Casting to i8's and converting the difference to an Ordering generates
@@ -2043,9 +2065,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized, B: PointeeSized> PartialOrd<&B> for &A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized, B: PointeeSized> const PartialOrd<&B> for &A
     where
-        A: PartialOrd<B>,
+        A: [const] PartialOrd<B>,
     {
         #[inline]
         fn partial_cmp(&self, other: &&B) -> Option<Ordering> {
@@ -2085,17 +2108,19 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Ord for &A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Ord for &A
     where
-        A: Ord,
+        A: [const] Ord,
     {
         #[inline]
         fn cmp(&self, other: &Self) -> Ordering {
             Ord::cmp(*self, *other)
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Eq for &A where A: Eq {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Eq for &A where A: [const] Eq {}
 
     // &mut pointers
 
@@ -2115,9 +2140,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized, B: PointeeSized> PartialOrd<&mut B> for &mut A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized, B: PointeeSized> const PartialOrd<&mut B> for &mut A
     where
-        A: PartialOrd<B>,
+        A: [const] PartialOrd<B>,
     {
         #[inline]
         fn partial_cmp(&self, other: &&mut B) -> Option<Ordering> {
@@ -2157,17 +2183,19 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Ord for &mut A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Ord for &mut A
     where
-        A: Ord,
+        A: [const] Ord,
     {
         #[inline]
         fn cmp(&self, other: &Self) -> Ordering {
             Ord::cmp(*self, *other)
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Eq for &mut A where A: Eq {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Eq for &mut A where A: [const] Eq {}
 
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]