constify (DoubleEnded)Iterator for RepeatN

library/core/src/iter/sources/repeat_n.rs

@@ -1,5 +1,6 @@
 use crate::fmt;
 use crate::iter::{FusedIterator, TrustedLen, UncheckedIterator};
+use crate::marker::Destruct;
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -85,9 +86,18 @@ pub struct RepeatN<A> {
 
 impl<A> RepeatN<A> {
     /// If we haven't already dropped the element, return it in an option.
+    #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
     #[inline]
-    fn take_element(&mut self) -> Option<A> {
-        self.inner.take().map(|inner| inner.element)
+    const fn take_element(&mut self) -> Option<A>
+    where
+        A: [const] Destruct,
+    {
+        //FIXME(const-hack): revert this to a const closure when they are fine to use
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        const fn inner_element<T: [const] Destruct>(inner: RepeatNInner<T>) -> T {
+            inner.element
+        }
+        self.inner.take().map(inner_element)
     }
 }
 
@@ -103,7 +113,8 @@ impl<A: fmt::Debug> fmt::Debug for RepeatN<A> {
 }
 
 #[stable(feature = "iter_repeat_n", since = "1.82.0")]
-impl<A: Clone> Iterator for RepeatN<A> {
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+impl<A: [const] Clone + [const] Destruct> const Iterator for RepeatN<A> {
     type Item = A;
 
     #[inline]
@@ -156,14 +167,21 @@ impl<A: Clone> Iterator for RepeatN<A> {
 }
 
 #[stable(feature = "iter_repeat_n", since = "1.82.0")]
-impl<A: Clone> ExactSizeIterator for RepeatN<A> {
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+impl<A: [const] Clone + [const] Destruct> const ExactSizeIterator for RepeatN<A> {
     fn len(&self) -> usize {
-        self.inner.as_ref().map(|inner| inner.count.get()).unwrap_or(0)
+        //FIXME(const-hack): revert this to a const closure when they are fine to use
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        const fn inner_count<T>(inner: &RepeatNInner<T>) -> usize {
+            inner.count.get()
+        }
+        self.inner.as_ref().map(inner_count).unwrap_or(0)
     }
 }
 
 #[stable(feature = "iter_repeat_n", since = "1.82.0")]
-impl<A: Clone> DoubleEndedIterator for RepeatN<A> {
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+impl<A: [const] Clone + [const] Destruct> const DoubleEndedIterator for RepeatN<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         self.next()
@@ -182,16 +200,16 @@ impl<A: Clone> DoubleEndedIterator for RepeatN<A> {
     #[inline]
     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
     where
-        F: FnMut(B, A) -> R,
-        R: Try<Output = B>,
+        F: [const] FnMut(B, A) -> R + [const] Destruct,
+        R: [const] Try<Output = B>,
     {
         self.try_fold(init, f)
     }
 
     #[inline]
     fn rfold<B, F>(self, init: B, f: F) -> B
     where
-        F: FnMut(B, A) -> B,
+        F: [const] FnMut(B, A) -> B + [const] Destruct,
     {
         self.fold(init, f)
     }

library/core/src/iter/traits/double_ended.rs

@@ -137,13 +137,18 @@ pub const trait DoubleEndedIterator: [const] Iterator {
     /// [`Err(k)`]: Err
     #[inline]
     #[unstable(feature = "iter_advance_by", issue = "77404")]
-    #[rustc_non_const_trait_method]
-    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        for i in 0..n {
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
+    where
+        Self::Item: [const] Destruct,
+    {
+        //FIXME(const-hack): revert this to `for i in 0..n` when possible
+        let mut i: usize = 0;
+        while i < n {
             if self.next_back().is_none() {
                 // SAFETY: `i` is always less than `n`.
                 return Err(unsafe { NonZero::new_unchecked(n - i) });
             }
+            i += 1;
         }
         Ok(())
     }
@@ -191,8 +196,10 @@ pub const trait DoubleEndedIterator: [const] Iterator {
     /// ```
     #[inline]
     #[stable(feature = "iter_nth_back", since = "1.37.0")]
-    #[rustc_non_const_trait_method]
-    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
+    where
+        Self::Item: [const] Destruct,
+    {
         if self.advance_back_by(n).is_err() {
             return None;
         }

library/core/src/iter/traits/exact_size.rs

@@ -83,7 +83,8 @@
 /// assert_eq!(4, counter.len());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub trait ExactSizeIterator: Iterator {
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+pub const trait ExactSizeIterator: [const] Iterator {
     /// Returns the exact remaining length of the iterator.
     ///
     /// The implementation ensures that the iterator will return exactly `len()`
@@ -119,7 +120,11 @@ pub trait ExactSizeIterator: Iterator {
         // guaranteed by the trait. If this trait were rust-internal,
         // we could use debug_assert!; assert_eq! will check all Rust user
         // implementations too.
-        assert_eq!(upper, Some(lower));
+        //assert_eq!(upper, Some(lower));
+        //FIXME(review) assert_eq! is not const, what to put here?
+        if upper != Some(lower) {
+            panic!()
+        }
         lower
     }
 

library/core/src/iter/traits/iterator.rs

@@ -308,32 +308,54 @@ pub const trait Iterator {
     /// ```
     #[inline]
     #[unstable(feature = "iter_advance_by", issue = "77404")]
-    #[rustc_non_const_trait_method]
-    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
+    where
+        Self::Item: [const] Destruct,
+    {
         /// Helper trait to specialize `advance_by` via `try_fold` for `Sized` iterators.
-        trait SpecAdvanceBy {
+        const trait SpecAdvanceBy {
             fn spec_advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>;
         }
 
-        impl<I: Iterator + ?Sized> SpecAdvanceBy for I {
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        impl<I: [const] Iterator + ?Sized> const SpecAdvanceBy for I
+        where
+            I::Item: [const] Destruct,
+        {
             default fn spec_advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-                for i in 0..n {
+                //FIXME(const-hack): revert this to `for i in 0..n` when possible
+                let mut i: usize = 0;
+                while i < n {
                     if self.next().is_none() {
                         // SAFETY: `i` is always less than `n`.
                         return Err(unsafe { NonZero::new_unchecked(n - i) });
                     }
+                    i += 1;
                 }
                 Ok(())
             }
         }
 
-        impl<I: Iterator> SpecAdvanceBy for I {
+        #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+        impl<I: [const] Iterator> const SpecAdvanceBy for I
+        where
+            I::Item: [const] Destruct,
+        {
             fn spec_advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+                //FIXME(const-hack): revert this to a const closure when they are fine to use
+                #[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+                const fn try_minus_one<T: [const] Destruct>(
+                    n: NonZero<usize>,
+                    _: T,
+                ) -> Option<NonZero<usize>> {
+                    NonZero::new(n.get() - 1)
+                }
+
                 let Some(n) = NonZero::new(n) else {
                     return Ok(());
                 };
 
-                let res = self.try_fold(n, |n, _| NonZero::new(n.get() - 1));
+                let res = self.try_fold(n, try_minus_one);
 
                 match res {
                     None => Ok(()),
@@ -386,8 +408,10 @@ pub const trait Iterator {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_non_const_trait_method]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+    fn nth(&mut self, n: usize) -> Option<Self::Item>
+    where
+        Self::Item: [const] Destruct,
+    {
         self.advance_by(n).ok()?;
         self.next()
     }

tests/codegen-units/item-collection/opaque-return-impls.rs

@@ -73,12 +73,13 @@ pub fn foo3() -> Box<dyn Iterator<Item = usize>> {
 }
 
 //~ MONO_ITEM fn <Counter as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by
-//~ MONO_ITEM fn <Counter as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::{closure#0}
+//~ MONO_ITEM fn <I as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::try_minus_one::<usize>
 //~ MONO_ITEM fn <Counter as std::iter::Iterator>::advance_by
 //~ MONO_ITEM fn <Counter as std::iter::Iterator>::next
 //~ MONO_ITEM fn <Counter as std::iter::Iterator>::nth
 //~ MONO_ITEM fn <Counter as std::iter::Iterator>::size_hint
-//~ MONO_ITEM fn <Counter as std::iter::Iterator>::try_fold::<std::num::NonZero<usize>, {closure@<Counter as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::{closure#0}}, std::option::Option<std::num::NonZero<usize>>>
+//~ MONO_ITEM fn <Counter as std::iter::Iterator>::try_fold::<std::num::NonZero<usize>, fn(std::num::NonZero<usize>, usize) -> std::option::Option<std::num::NonZero<usize>> {<I as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::try_minus_one::<usize>}, std::option::Option<std::num::NonZero<usize>>>
+//~ MONO_ITEM fn <fn(std::num::NonZero<usize>, usize) -> std::option::Option<std::num::NonZero<usize>> {<I as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::try_minus_one::<usize>} as std::ops::FnMut<(std::num::NonZero<usize>, usize)>>::call_mut - shim(fn(std::num::NonZero<usize>, usize) -> std::option::Option<std::num::NonZero<usize>> {<I as std::iter::Iterator::advance_by::SpecAdvanceBy>::spec_advance_by::try_minus_one::<usize>})
 //~ MONO_ITEM fn <std::option::Option<std::num::NonZero<usize>> as std::ops::FromResidual<std::option::Option<std::convert::Infallible>>>::from_residual
 //~ MONO_ITEM fn <std::option::Option<std::num::NonZero<usize>> as std::ops::Try>::branch
 //~ MONO_ITEM fn <std::option::Option<std::num::NonZero<usize>> as std::ops::Try>::from_output