constify comparison traits on slices

This currently involves manually inlining chaining_impl() to
avoid a dependency on const closures.

Author: npmccallum

library/core/src/slice/cmp.rs

@@ -23,18 +23,20 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq> Eq for [T] {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Eq> const Eq for [T] {}
 
 /// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Ord for [T] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Ord> const Ord for [T] {
     fn cmp(&self, other: &[T]) -> Ordering {
         SliceOrd::compare(self, other)
     }
 }
 
 #[inline]
-fn as_underlying(x: ControlFlow<bool>) -> u8 {
+const fn as_underlying(x: ControlFlow<bool>) -> u8 {
     // SAFETY: This will only compile if `bool` and `ControlFlow<bool>` have the same
     // size (which isn't guaranteed but this is libcore). Because they have the same
     // size, it's a niched implementation, which in one byte means there can't be
@@ -46,7 +48,8 @@ fn as_underlying(x: ControlFlow<bool>) -> u8 {
 
 /// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd> PartialOrd for [T] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialOrd> const PartialOrd for [T] {
     #[inline]
     fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {
         SlicePartialOrd::partial_compare(self, other)
@@ -95,9 +98,8 @@ impl<T: PartialOrd> PartialOrd for [T] {
 
 #[doc(hidden)]
 // intermediate trait for specialization of slice's PartialEq
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-trait SlicePartialEq<B> {
+const trait SlicePartialEq<B> {
     fn equal(&self, other: &[B]) -> bool;
 
     fn not_equal(&self, other: &[B]) -> bool {
@@ -155,68 +157,123 @@ where
 }
 
 #[doc(hidden)]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 // intermediate trait for specialization of slice's PartialOrd
-trait SlicePartialOrd: Sized {
+const trait SlicePartialOrd: Sized {
     fn partial_compare(left: &[Self], right: &[Self]) -> Option<Ordering>;
 }
 
 #[doc(hidden)]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 // intermediate trait for specialization of slice's PartialOrd chaining methods
-trait SliceChain: Sized {
+const trait SliceChain: Sized {
     fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool>;
     fn chaining_le(left: &[Self], right: &[Self]) -> ControlFlow<bool>;
     fn chaining_gt(left: &[Self], right: &[Self]) -> ControlFlow<bool>;
     fn chaining_ge(left: &[Self], right: &[Self]) -> ControlFlow<bool>;
 }
 
-type AlwaysBreak<B> = ControlFlow<B, crate::convert::Infallible>;
-
-impl<A: PartialOrd> SlicePartialOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd> const SlicePartialOrd for A {
     default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
-        let elem_chain = |a, b| match PartialOrd::partial_cmp(a, b) {
-            Some(Ordering::Equal) => ControlFlow::Continue(()),
-            non_eq => ControlFlow::Break(non_eq),
-        };
-        let len_chain = |a: &_, b: &_| ControlFlow::Break(usize::partial_cmp(a, b));
-        let AlwaysBreak::Break(b) = chaining_impl(left, right, elem_chain, len_chain);
-        b
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match PartialOrd::partial_cmp(&lhs[i], &rhs[i]) {
+                Some(Ordering::Equal) => {}
+                non_eq => return non_eq,
+            }
+            i += 1;
+        }
+
+        usize::partial_cmp(&left.len(), &right.len())
     }
 }
 
-impl<A: PartialOrd> SliceChain for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd> const SliceChain for A {
     default fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
-        chaining_impl(left, right, PartialOrd::__chaining_lt, usize::__chaining_lt)
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match PartialOrd::__chaining_lt(&lhs[i], &rhs[i]) {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(b) => return ControlFlow::Break(b),
+            }
+            i += 1;
+        }
+
+        usize::__chaining_lt(&left.len(), &right.len())
     }
     default fn chaining_le(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
-        chaining_impl(left, right, PartialOrd::__chaining_le, usize::__chaining_le)
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match PartialOrd::__chaining_le(&lhs[i], &rhs[i]) {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(b) => return ControlFlow::Break(b),
+            }
+            i += 1;
+        }
+
+        usize::__chaining_le(&left.len(), &right.len())
     }
     default fn chaining_gt(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
-        chaining_impl(left, right, PartialOrd::__chaining_gt, usize::__chaining_gt)
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match PartialOrd::__chaining_gt(&lhs[i], &rhs[i]) {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(b) => return ControlFlow::Break(b),
+            }
+            i += 1;
+        }
+
+        usize::__chaining_gt(&left.len(), &right.len())
     }
     default fn chaining_ge(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
-        chaining_impl(left, right, PartialOrd::__chaining_ge, usize::__chaining_ge)
-    }
-}
-
-#[inline]
-fn chaining_impl<'l, 'r, A: PartialOrd, B, C>(
-    left: &'l [A],
-    right: &'r [A],
-    elem_chain: impl Fn(&'l A, &'r A) -> ControlFlow<B>,
-    len_chain: impl for<'a> FnOnce(&'a usize, &'a usize) -> ControlFlow<B, C>,
-) -> ControlFlow<B, C> {
-    let l = cmp::min(left.len(), right.len());
-
-    // Slice to the loop iteration range to enable bound check
-    // elimination in the compiler
-    let lhs = &left[..l];
-    let rhs = &right[..l];
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match PartialOrd::__chaining_ge(&lhs[i], &rhs[i]) {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(b) => return ControlFlow::Break(b),
+            }
+            i += 1;
+        }
 
-    for i in 0..l {
-        elem_chain(&lhs[i], &rhs[i])?;
+        usize::__chaining_ge(&left.len(), &right.len())
     }
-
-    len_chain(&left.len(), &right.len())
 }
 
 // This is the impl that we would like to have. Unfortunately it's not sound.
@@ -232,46 +289,65 @@ where
 }
 */
 
-impl<A: AlwaysApplicableOrd> SlicePartialOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] AlwaysApplicableOrd> const SlicePartialOrd for A {
     fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
         Some(SliceOrd::compare(left, right))
     }
 }
 
 #[rustc_specialization_trait]
-trait AlwaysApplicableOrd: SliceOrd + Ord {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+const trait AlwaysApplicableOrd: [const] SliceOrd + [const] Ord {}
 
 macro_rules! always_applicable_ord {
     ($([$($p:tt)*] $t:ty,)*) => {
-        $(impl<$($p)*> AlwaysApplicableOrd for $t {})*
+        $(
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl<$($p)*> const AlwaysApplicableOrd for $t {}
+        )*
     }
 }
 
 always_applicable_ord! {
     [] u8, [] u16, [] u32, [] u64, [] u128, [] usize,
     [] i8, [] i16, [] i32, [] i64, [] i128, [] isize,
     [] bool, [] char,
-    [T: ?Sized] *const T, [T: ?Sized] *mut T,
-    [T: AlwaysApplicableOrd] &T,
-    [T: AlwaysApplicableOrd] &mut T,
-    [T: AlwaysApplicableOrd] Option<T>,
+    [T: [const] AlwaysApplicableOrd] &T,
+    [T: [const] AlwaysApplicableOrd] &mut T,
+    [T: [const] AlwaysApplicableOrd] Option<T>,
 }
 
+impl<T: ?Sized> AlwaysApplicableOrd for *const T {}
+impl<T: ?Sized> AlwaysApplicableOrd for *mut T {}
+
 #[doc(hidden)]
 // intermediate trait for specialization of slice's Ord
-trait SliceOrd: Sized {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+const trait SliceOrd: Sized {
     fn compare(left: &[Self], right: &[Self]) -> Ordering;
 }
 
-impl<A: Ord> SliceOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] Ord> const SliceOrd for A {
     default fn compare(left: &[Self], right: &[Self]) -> Ordering {
-        let elem_chain = |a, b| match Ord::cmp(a, b) {
-            Ordering::Equal => ControlFlow::Continue(()),
-            non_eq => ControlFlow::Break(non_eq),
-        };
-        let len_chain = |a: &_, b: &_| ControlFlow::Break(usize::cmp(a, b));
-        let AlwaysBreak::Break(b) = chaining_impl(left, right, elem_chain, len_chain);
-        b
+        let l = cmp::min(left.len(), right.len());
+
+        // Slice to the loop iteration range to enable bound check
+        // elimination in the compiler
+        let lhs = &left[..l];
+        let rhs = &right[..l];
+
+        let mut i = 0;
+        while i < l {
+            match Ord::cmp(&lhs[i], &rhs[i]) {
+                Ordering::Equal => {}
+                non_eq => return non_eq,
+            }
+            i += 1;
+        }
+
+        usize::cmp(&left.len(), &right.len())
     }
 }
 
@@ -283,17 +359,19 @@ impl<A: Ord> SliceOrd for A {
 /// * For every `x` and `y` of this type, `Ord(x, y)` must return the same
 ///   value as `Ord::cmp(transmute::<_, u8>(x), transmute::<_, u8>(y))`.
 #[rustc_specialization_trait]
-unsafe trait UnsignedBytewiseOrd: Ord {}
+#[const_trait]
+unsafe trait UnsignedBytewiseOrd: [const] Ord {}
 
-unsafe impl UnsignedBytewiseOrd for bool {}
-unsafe impl UnsignedBytewiseOrd for u8 {}
-unsafe impl UnsignedBytewiseOrd for NonZero<u8> {}
-unsafe impl UnsignedBytewiseOrd for Option<NonZero<u8>> {}
-unsafe impl UnsignedBytewiseOrd for ascii::Char {}
+unsafe impl const UnsignedBytewiseOrd for bool {}
+unsafe impl const UnsignedBytewiseOrd for u8 {}
+unsafe impl const UnsignedBytewiseOrd for NonZero<u8> {}
+unsafe impl const UnsignedBytewiseOrd for Option<NonZero<u8>> {}
+unsafe impl const UnsignedBytewiseOrd for ascii::Char {}
 
 // `compare_bytes` compares a sequence of unsigned bytes lexicographically, so
 // use it if the requirements for `UnsignedBytewiseOrd` are fulfilled.
-impl<A: Ord + UnsignedBytewiseOrd> SliceOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] Ord + [const] UnsignedBytewiseOrd> const SliceOrd for A {
     #[inline]
     fn compare(left: &[Self], right: &[Self]) -> Ordering {
         // Since the length of a slice is always less than or equal to
@@ -318,7 +396,8 @@ impl<A: Ord + UnsignedBytewiseOrd> SliceOrd for A {
 }
 
 // Don't generate our own chaining loops for `memcmp`-able things either.
-impl<A: PartialOrd + UnsignedBytewiseOrd> SliceChain for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd + [const] UnsignedBytewiseOrd> const SliceChain for A {
     #[inline]
     fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
         match SliceOrd::compare(left, right) {