Allow const iterator implementations

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);
@@ -911,7 +916,7 @@ where
 ///
 /// To minimize indirection fields are still pub but callers should at least use
 /// `push_unchecked` to signal that something unsafe is going on.
-pub(crate) struct Guard<'a, T, const N: usize> {
+pub(crate) struct Guard<'a, T: ~const Destruct, const N: usize> {
  /// The array to be initialized.
  pub array_mut: &'a mut [MaybeUninit<T>; N],
  /// The number of items that have been initialized so far.
@@ -925,7 +930,7 @@ impl<T, const N: usize> Guard<'_, T, N> {
  ///
  /// No more than N elements must be initialized.
  #[inline]
- pub unsafe fn push_unchecked(&mut self, item: T) {
+ pub const unsafe fn push_unchecked(&mut self, item: T) {
  // SAFETY: If `initialized` was correct before and the caller does not
  // invoke this method more than N times then writes will be in-bounds
  // and slots will not be initialized more than once.
@@ -936,28 +941,51 @@ impl<T, const N: usize> Guard<'_, T, N> {
  }
 }
 
-impl<T, const N: usize> Drop for Guard<'_, T, N> {
+impl<T: ~const Destruct, const N: usize> const Drop for Guard<'_, T, N> {
  fn drop(&mut self) {
  debug_assert!(self.initialized <= N);
 
+ #[inline]
+ const fn drop_ct<T: ~const Destruct>(x: &mut [T]) {
+ let mut i = 0;
+ while i < x.len() {
+ // SAFETY: dropping the value, contains initialized objects
+ unsafe {
+ crate::ptr::read(&mut x[i]);
+ }
+ i += 1;
+ }
+ }
+ #[inline]
+ fn drop_rt<T>(x: &mut [T]) {
+ // SAFETY: slice contains initialized objects
+ unsafe { crate::ptr::drop_in_place(x) }
+ }
+
  // SAFETY: this slice will contain only initialized objects.
  unsafe {
- crate::ptr::drop_in_place(MaybeUninit::slice_assume_init_mut(
- &mut self.array_mut.get_unchecked_mut(..self.initialized),
- ));
+ let to_drop = MaybeUninit::slice_assume_init_mut(
+ self.array_mut.get_unchecked_mut(..self.initialized),
+ );
+ crate::intrinsics::const_eval_select((to_drop,), drop_ct, drop_rt);
  }
  }
 }
 
 /// 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)]
@@ -1233,7 +1225,6 @@ pub const fn min<T: ~const Ord + ~const Destruct>(v1: T, v2: T) -> T {
 pub const fn min_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 => v1,
@@ -1318,7 +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,
@@ -1399,7 +1389,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 +1514,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/const_closure.rs

@@ -25,6 +25,7 @@ pub(crate) struct ConstFnMutClosure<CapturedData, Function> {
  /// The Function of the Closure, must be: Fn(CapturedData, ClosureArgs) -> ClosureReturn
  pub func: Function,
 }
+
 impl<'a, CapturedData: ?Sized, Function> ConstFnMutClosure<&'a mut CapturedData, Function> {
  /// Function for creating a new closure.
  ///

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

@@ -15,8 +15,8 @@ pub struct Cycle<I> {
  iter: I,
 }
 
-impl<I: Clone> Cycle<I> {
- pub(in crate::iter) fn new(iter: I) -> Cycle<I> {
+impl<I: ~const Clone> Cycle<I> {
+ pub(in crate::iter) const fn new(iter: I) -> Cycle<I> {
  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 }
  }
 }

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

@@ -17,7 +17,7 @@ pub struct FilterMap<I, F> {
  f: F,
 }
 impl<I, F> FilterMap<I, F> {
- pub(in crate::iter) fn new(iter: I, f: F) -> FilterMap<I, F> {
+ pub(in crate::iter) const fn new(iter: I, f: F) -> FilterMap<I, F> {
  FilterMap { iter, f }
  }
 }