Allow const iterator implementations

Author: fee1-dead

library/core/src/array/mod.rs

@@ -11,6 +11,7 @@ use crate::error::Error;
 use crate::fmt;
 use crate::hash::{self, Hash};
 use crate::iter::TrustedLen;
+use crate::marker::Destruct;
 use crate::mem::{self, MaybeUninit};
 use crate::ops::{
     ChangeOutputType, ControlFlow, FromResidual, Index, IndexMut, NeverShortCircuit, Residual, Try,
@@ -852,23 +853,26 @@ where
 /// If `iter.next()` panicks, all items already yielded by the iterator are
 /// dropped.
 #[inline]
-fn try_collect_into_array<I, T, R, const N: usize>(
+const fn try_collect_into_array<I, T, R, const N: usize>(
     iter: &mut I,
 ) -> Result<R::TryType, IntoIter<T, N>>
 where
-    I: Iterator,
-    I::Item: Try<Output = T, Residual = R>,
-    R: Residual<[T; N]>,
+    I: ~const Iterator,
+    I::Item: ~const Try<Output = T, Residual = R>,
+    R: ~const Residual<[T; N]>,
+    T: ~const Destruct,
 {
     if N == 0 {
         // SAFETY: An empty array is always inhabited and has no validity invariants.
-        return Ok(Try::from_output(unsafe { mem::zeroed() }));
+        return Ok(Try::from_output(unsafe { MaybeUninit::zeroed().assume_init() }));
     }
 
     let mut array = MaybeUninit::uninit_array::<N>();
     let mut guard = Guard { array_mut: &mut array, initialized: 0 };
 
-    for _ in 0..N {
+    let mut i = 0;
+    // FIXME(const_trait_impl): replace with `for` loop
+    while i < N {
         match iter.next() {
             Some(item_rslt) => {
                 let item = match item_rslt.branch() {
@@ -892,6 +896,7 @@ where
                 return Err(unsafe { IntoIter::new_unchecked(array, alive) });
             }
         }
+        i += 1;
     }
 
     mem::forget(guard);
@@ -952,12 +957,17 @@ impl<T, const N: usize> Drop for Guard<'_, T, N> {
 /// Returns the next chunk of `N` items from the iterator or errors with an
 /// iterator over the remainder. Used for `Iterator::next_chunk`.
 #[inline]
-pub(crate) fn iter_next_chunk<I, const N: usize>(
+pub(crate) const fn iter_next_chunk<I, const N: usize>(
     iter: &mut I,
 ) -> Result<[I::Item; N], IntoIter<I::Item, N>>
 where
-    I: Iterator,
+    I: ~const Iterator,
+    I::Item: ~const Destruct,
 {
     let mut map = iter.map(NeverShortCircuit);
-    try_collect_into_array(&mut map).map(|NeverShortCircuit(arr)| arr)
+
+    match try_collect_into_array(&mut map) {
+        Ok(NeverShortCircuit(x)) => Ok(x),
+        Err(e) => Err(e),
+    }
 }

library/core/src/cmp.rs

@@ -281,7 +281,8 @@ pub macro PartialEq($item:item) {
 #[doc(alias = "!=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Eq"]
-pub trait Eq: PartialEq<Self> {
+#[const_trait]
+pub trait Eq: ~const PartialEq<Self> {
     // this method is used solely by #[deriving] to assert
     // that every component of a type implements #[deriving]
     // itself, the current deriving infrastructure means doing this
@@ -331,8 +332,9 @@ pub struct AssertParamIsEq<T: Eq + ?Sized> {
 /// let result = 2.cmp(&1);
 /// assert_eq!(Ordering::Greater, result);
 /// ```
-#[derive(Clone, Copy, Eq, Debug, Hash)]
-#[cfg_attr(not(bootstrap), derive_const(PartialOrd, Ord, PartialEq))]
+#[derive(Clone, Copy, Debug, Hash)]
+#[cfg_attr(bootstrap, derive(Ord, Eq))]
+#[cfg_attr(not(bootstrap), derive_const(PartialOrd, Ord, PartialEq, Eq))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(i8)]
 pub enum Ordering {
@@ -762,7 +764,7 @@ impl<T: Clone> Clone for Reverse<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Ord"]
 #[const_trait]
-pub trait Ord: Eq + PartialOrd<Self> {
+pub trait Ord: ~const Eq + ~const PartialOrd<Self> {
     /// This method returns an [`Ordering`] between `self` and `other`.
     ///
     /// By convention, `self.cmp(&other)` returns the ordering matching the expression
@@ -892,16 +894,6 @@ impl const PartialEq for Ordering {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
-#[cfg(bootstrap)]
-impl const Ord for Ordering {
-    #[inline]
-    fn cmp(&self, other: &Ordering) -> Ordering {
-        (*self as i32).cmp(&(*other as i32))
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
 #[cfg(bootstrap)]
@@ -1231,9 +1223,8 @@ pub const fn min<T: ~const Ord + ~const Destruct>(v1: T, v2: T) -> T {
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
 #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
 pub const fn min_by<T, F: ~const FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T
-where
+where 
     T: ~const Destruct,
-    F: ~const Destruct,
 {
     match compare(&v1, &v2) {
         Ordering::Less | Ordering::Equal => v1,
@@ -1318,8 +1309,6 @@ pub const fn max<T: ~const Ord + ~const Destruct>(v1: T, v2: T) -> T {
 pub const fn max_by<T, F: ~const FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T
 where
     T: ~const Destruct,
-    F: ~const Destruct,
-{
     match compare(&v1, &v2) {
         Ordering::Less | Ordering::Equal => v2,
         Ordering::Greater => v1,
@@ -1399,7 +1388,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 = "92391")]
+            impl const Eq for $t {}
         )*)
     }
 
@@ -1523,7 +1513,8 @@ mod impls {
     }
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl Eq for ! {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+    impl const Eq for ! {}
 
     #[unstable(feature = "never_type", issue = "35121")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]

library/core/src/iter/adapters/array_chunks.rs

@@ -24,7 +24,7 @@ where
     I: Iterator,
 {
     #[track_caller]
-    pub(in crate::iter) fn new(iter: I) -> Self {
+    pub(in crate::iter) const fn new(iter: I) -> Self {
         assert!(N != 0, "chunk size must be non-zero");
         Self { iter, remainder: None }
     }

library/core/src/iter/adapters/by_ref_sized.rs

@@ -1,7 +1,6 @@
-use crate::{
-    const_closure::ConstFnMutClosure,
-    ops::{NeverShortCircuit, Try},
-};
+use crate::const_closure::ConstFnMutClosure;
+use crate::marker::Destruct;
+use crate::ops::{NeverShortCircuit, Try};
 
 /// Like `Iterator::by_ref`, but requiring `Sized` so it can forward generics.
 ///
@@ -15,7 +14,7 @@ pub struct ByRefSized<'a, I>(pub &'a mut I);
 // to avoid accidentally calling the `&mut Iterator` implementations.
 
 #[unstable(feature = "std_internals", issue = "none")]
-impl<I: Iterator> Iterator for ByRefSized<'_, I> {
+impl<I: ~const Iterator> const Iterator for ByRefSized<'_, I> {
     type Item = I::Item;
 
     #[inline]
@@ -29,19 +28,25 @@ impl<I: Iterator> Iterator for ByRefSized<'_, I> {
     }
 
     #[inline]
-    fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+    fn advance_by(&mut self, n: usize) -> Result<(), usize>
+    where
+        I::Item: ~const Destruct,
+    {
         I::advance_by(self.0, n)
     }
 
     #[inline]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+    fn nth(&mut self, n: usize) -> Option<Self::Item>
+    where
+        I::Item: ~const Destruct,
+    {
         I::nth(self.0, n)
     }
 
     #[inline]
     fn fold<B, F>(self, init: B, mut f: F) -> B
     where
-        F: FnMut(B, Self::Item) -> B,
+        F: ~const FnMut(B, Self::Item) -> B + ~const Destruct,
     {
         // `fold` needs ownership, so this can't forward directly.
         I::try_fold(self.0, init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp))
@@ -51,8 +56,8 @@ impl<I: Iterator> Iterator for ByRefSized<'_, I> {
     #[inline]
     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
     where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
+        F: ~const FnMut(B, Self::Item) -> R + ~const Destruct,
+        R: ~const Try<Output = B>,
     {
         I::try_fold(self.0, init, f)
     }

library/core/src/iter/adapters/chain.rs

@@ -32,7 +32,7 @@ pub struct Chain<A, B> {
     b: Option<B>,
 }
 impl<A, B> Chain<A, B> {
-    pub(in super::super) fn new(a: A, b: B) -> Chain<A, B> {
+    pub(in super::super) const fn new(a: A, b: B) -> Chain<A, B> {
         Chain { a: Some(a), b: Some(b) }
     }
 }

library/core/src/iter/adapters/cloned.rs

@@ -19,7 +19,7 @@ pub struct Cloned<I> {
 }
 
 impl<I> Cloned<I> {
-    pub(in crate::iter) fn new(it: I) -> Cloned<I> {
+    pub(in crate::iter) const fn new(it: I) -> Cloned<I> {
         Cloned { it }
     }
 }

library/core/src/iter/adapters/copied.rs

@@ -22,7 +22,7 @@ pub struct Copied<I> {
 }
 
 impl<I> Copied<I> {
-    pub(in crate::iter) fn new(it: I) -> Copied<I> {
+    pub(in crate::iter) const fn new(it: I) -> Copied<I> {
         Copied { it }
     }
 }

library/core/src/iter/adapters/cycle.rs

@@ -16,7 +16,10 @@ pub struct Cycle<I> {
 }
 
 impl<I: Clone> Cycle<I> {
-    pub(in crate::iter) fn new(iter: I) -> Cycle<I> {
+    pub(in crate::iter) const fn new(iter: I) -> Cycle<I>
+    where
+        I: ~const Clone,
+    {
         Cycle { orig: iter.clone(), iter }
     }
 }

library/core/src/iter/adapters/enumerate.rs

@@ -19,7 +19,7 @@ pub struct Enumerate<I> {
     count: usize,
 }
 impl<I> Enumerate<I> {
-    pub(in crate::iter) fn new(iter: I) -> Enumerate<I> {
+    pub(in crate::iter) const fn new(iter: I) -> Enumerate<I> {
         Enumerate { iter, count: 0 }
     }
 }

library/core/src/iter/adapters/filter.rs

@@ -18,7 +18,7 @@ pub struct Filter<I, P> {
     predicate: P,
 }
 impl<I, P> Filter<I, P> {
-    pub(in crate::iter) fn new(iter: I, predicate: P) -> Filter<I, P> {
+    pub(in crate::iter) const fn new(iter: I, predicate: P) -> Filter<I, P> {
         Filter { iter, predicate }
     }
 }