Auto merge of #153708 - Lars-Schumann:de-non_const-iterator-trait-methods, r=<try>

de-non_const `Iterator` trait methods


try-job: x86_64-rust-for-linux

Author: bors

library/core/src/array/mod.rs

@@ -1003,9 +1003,10 @@ impl<T: [const] Destruct> const Drop for Guard<'_, T> {
 /// dropped.
 ///
 /// Used for [`Iterator::next_chunk`].
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
 #[inline]
-pub(crate) fn iter_next_chunk<T, const N: usize>(
-    iter: &mut impl Iterator<Item = T>,
+pub(crate) const fn iter_next_chunk<T, const N: usize>(
+    iter: &mut impl [const] Iterator<Item = T>,
 ) -> Result<[T; N], IntoIter<T, N>> {
     let mut array = [const { MaybeUninit::uninit() }; N];
     let r = iter_next_chunk_erased(&mut array, iter);
@@ -1026,10 +1027,11 @@ pub(crate) fn iter_next_chunk<T, const N: usize>(
 ///
 /// Unfortunately this loop has two exit conditions, the buffer filling up
 /// or the iterator running out of items, making it tend to optimize poorly.
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
 #[inline]
-fn iter_next_chunk_erased<T>(
+const fn iter_next_chunk_erased<T>(
     buffer: &mut [MaybeUninit<T>],
-    iter: &mut impl Iterator<Item = T>,
+    iter: &mut impl [const] Iterator<Item = T>,
 ) -> Result<(), usize> {
     // if `Iterator::next` panics, this guard will drop already initialized items
     let mut guard = Guard { array_mut: buffer, initialized: 0 };

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

@@ -26,7 +26,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/chain.rs

@@ -33,7 +33,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

@@ -20,7 +20,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

@@ -21,7 +21,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

@@ -18,7 +18,11 @@ pub struct Cycle<I> {
 }
 
 impl<I: Clone> Cycle<I> {
-    pub(in crate::iter) fn new(iter: I) -> Cycle<I> {
+    #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+    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

@@ -20,7 +20,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

@@ -24,7 +24,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

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

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

@@ -186,7 +186,11 @@ pub struct Flatten<I: Iterator<Item: IntoIterator>> {
 }
 
 impl<I: Iterator<Item: IntoIterator>> Flatten<I> {
-    pub(in super::super) fn new(iter: I) -> Flatten<I> {
+    #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+    pub(in super::super) const fn new(iter: I) -> Flatten<I>
+    where
+        I: [const] Iterator,
+    {
         Flatten { inner: FlattenCompat::new(iter) }
     }
 }
@@ -363,7 +367,11 @@ where
     I: Iterator,
 {
     /// Adapts an iterator by flattening it, for use in `flatten()` and `flat_map()`.
-    fn new(iter: I) -> FlattenCompat<I, U> {
+    #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+    const fn new(iter: I) -> FlattenCompat<I, U>
+    where
+        I: [const] Iterator,
+    {
         FlattenCompat { iter: iter.fuse(), frontiter: None, backiter: None }
     }
 }