Add InfiniteIterator trait

This enables more ExactSizeIterator instances, specifically, those
for `Take`, where the sub-iterator is infinite, and `Zip` where the
one sub-iterator is infinite, and the other is exact sized.

Previously, in #146642,
I sought to add specific instances for `Zip<Repeat<A>, I>` and its
symmatrical mirror.

Introducing `InfiniteIterator` provides much broader support for
`ExactSizeIterator`.

For example,

```rust
[1, 2, 3].into_iter().chain(repeat(1)).take(5)
```

Will now happily resolve to an instance of `ExactSizeIterator`.

The downside of this approach is that, to avoid the overlapping instance
with `Zip`, I had to introduce a negative trait bound, which, IIUC,
isn't available outside of the compiler.

If anyone knows of a better way to handle the overlapping instances, or
a way I can expose something which triggers the negative instance, that
would be very helpful.

There's also a missing symmetrical instance for `Chain`. Solutions
are welcome.

Author: 414owen

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

@@ -1,4 +1,4 @@
-use crate::iter::{FusedIterator, TrustedLen};
+use crate::iter::{FusedIterator, InfiniteIterator, TrustedLen};
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -335,3 +335,15 @@ fn and_then_or_clear<T, U>(opt: &mut Option<T>, f: impl FnOnce(&mut T) -> Option
     }
     x
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<A, B> !ExactSizeIterator for Chain<A, B> {}
+
+// FIXME: Get this working with the symmetrical variant
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<A, B> InfiniteIterator for Chain<A, B>
+where
+    A: Iterator,
+    B: InfiniteIterator<Item = A::Item>,
+{
+}

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

@@ -2,7 +2,9 @@ use core::num::NonZero;
 
 use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::adapters::{SourceIter, TrustedRandomAccess, TrustedRandomAccessNoCoerce};
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen, UncheckedIterator};
+use crate::iter::{
+    FusedIterator, InPlaceIterable, InfiniteIterator, TrustedLen, UncheckedIterator,
+};
 use crate::ops::Try;
 
 /// An iterator that clones the elements of an underlying iterator.
@@ -188,3 +190,14 @@ unsafe impl<I: InPlaceIterable> InPlaceIterable for Cloned<I> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator> !ExactSizeIterator for Cloned<I> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<'a, I, T: 'a> InfiniteIterator for Cloned<I>
+where
+    I: InfiniteIterator<Item = &'a T>,
+    T: Clone,
+{
+}

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

@@ -1,6 +1,6 @@
 use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::adapters::{SourceIter, TrustedRandomAccess, TrustedRandomAccessNoCoerce};
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
+use crate::iter::{FusedIterator, InPlaceIterable, InfiniteIterator, TrustedLen};
 use crate::mem::{MaybeUninit, SizedTypeProperties};
 use crate::num::NonZero;
 use crate::ops::Try;
@@ -273,3 +273,14 @@ unsafe impl<I: InPlaceIterable> InPlaceIterable for Copied<I> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator> !ExactSizeIterator for Copied<I> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<'a, I, T> InfiniteIterator for Copied<I>
+where
+    I: InfiniteIterator<Item = &'a T>,
+    T: Copy + 'a,
+{
+}

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

@@ -1,4 +1,4 @@
-use crate::iter::FusedIterator;
+use crate::iter::{FusedIterator, InfiniteIterator};
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -107,3 +107,9 @@ where
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<I> FusedIterator for Cycle<I> where I: Clone + Iterator {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I> !ExactSizeIterator for Cycle<I> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: Clone + Iterator> InfiniteIterator for Cycle<I> {}

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

@@ -1,6 +1,6 @@
 use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::adapters::{SourceIter, TrustedRandomAccess, TrustedRandomAccessNoCoerce};
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused, TrustedLen};
+use crate::iter::{FusedIterator, InPlaceIterable, InfiniteIterator, TrustedFused, TrustedLen};
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -315,3 +315,9 @@ impl<I: Default> Default for Enumerate<I> {
         Enumerate::new(Default::default())
     }
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator> !ExactSizeIterator for Enumerate<I> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: InfiniteIterator> InfiniteIterator for Enumerate<I> {}

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

@@ -4,7 +4,7 @@ use core::ops::ControlFlow;
 
 use crate::fmt;
 use crate::iter::adapters::SourceIter;
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused};
+use crate::iter::{FusedIterator, InPlaceIterable, InfiniteIterator, TrustedFused};
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -214,3 +214,14 @@ unsafe impl<I: InPlaceIterable, P> InPlaceIterable for Filter<I, P> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, P> !ExactSizeIterator for Filter<I, P> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, P> InfiniteIterator for Filter<I, P>
+where
+    I: InfiniteIterator,
+    P: FnMut(&I::Item) -> bool,
+{
+}

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

@@ -1,5 +1,5 @@
 use crate::iter::adapters::SourceIter;
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused};
+use crate::iter::{FusedIterator, InPlaceIterable, InfiniteIterator, TrustedFused};
 use crate::mem::{ManuallyDrop, MaybeUninit};
 use crate::num::NonZero;
 use crate::ops::{ControlFlow, Try};
@@ -211,3 +211,12 @@ unsafe impl<I: InPlaceIterable, F> InPlaceIterable for FilterMap<I, F> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, F> !ExactSizeIterator for FilterMap<I, F> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<B, I: InfiniteIterator, F> InfiniteIterator for FilterMap<I, F> where
+    F: FnMut(I::Item) -> Option<B>
+{
+}

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

@@ -1,7 +1,7 @@
 use crate::iter::adapters::SourceIter;
 use crate::iter::{
-    Cloned, Copied, Empty, Filter, FilterMap, Fuse, FusedIterator, Map, Once, OnceWith,
-    TrustedFused, TrustedLen,
+    Cloned, Copied, Empty, Filter, FilterMap, Fuse, FusedIterator, InfiniteIterator, Map, Once,
+    OnceWith, TrustedFused, TrustedLen,
 };
 use crate::num::NonZero;
 use crate::ops::{ControlFlow, Try};
@@ -172,6 +172,26 @@ where
     }
 }
 
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator, U, F> !ExactSizeIterator for FlatMap<I, U, F> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, U, F> !ExactSizeIterator for FlatMap<I, U, F>
+where
+    I: ExactSizeIterator<Item = U>,
+    U: !ExactSizeIterator,
+{
+}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, U, F> InfiniteIterator for FlatMap<I, U, F>
+where
+    I: InfiniteIterator,
+    U: IntoIterator,
+    F: FnMut(I::Item) -> U,
+{
+}
+
 /// An iterator that flattens one level of nesting in an iterator of things
 /// that can be turned into iterators.
 ///
@@ -349,6 +369,20 @@ where
     }
 }
 
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator> !ExactSizeIterator for Flatten<I> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I> !ExactSizeIterator for Flatten<I>
+where
+    I: ExactSizeIterator,
+    I::Item: !ExactSizeIterator,
+{
+}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I> InfiniteIterator for Flatten<I> where I: InfiniteIterator<Item: IntoIterator> {}
+
 /// Real logic of both `Flatten` and `FlatMap` which simply delegate to
 /// this type.
 #[derive(Clone, Debug)]
@@ -712,6 +746,25 @@ where
 {
 }
 
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator, U> !ExactSizeIterator for FlattenCompat<I, U> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, U> !ExactSizeIterator for FlattenCompat<I, U>
+where
+    I: ExactSizeIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
+    U: Iterator + !ExactSizeIterator,
+{
+}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I, U> InfiniteIterator for FlattenCompat<I, U>
+where
+    I: InfiniteIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
+    U: Iterator,
+{
+}
+
 trait ConstSizeIntoIterator: IntoIterator {
     // FIXME(#31844): convert to an associated const once specialization supports that
     fn size() -> Option<usize>;

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

@@ -1,6 +1,6 @@
 use crate::fmt;
 use crate::iter::adapters::SourceIter;
-use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused};
+use crate::iter::{FusedIterator, InPlaceIterable, InfiniteIterator, TrustedFused};
 use crate::num::NonZero;
 use crate::ops::Try;
 
@@ -172,3 +172,9 @@ unsafe impl<I: InPlaceIterable, F> InPlaceIterable for Inspect<I, F> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator, F> !ExactSizeIterator for Inspect<I, F> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: InfiniteIterator, F> InfiniteIterator for Inspect<I, F> where F: FnMut(&I::Item) {}

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

@@ -1,6 +1,7 @@
 use crate::fmt;
 use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::adapters::{SourceIter, TrustedRandomAccess, TrustedRandomAccessNoCoerce};
+use crate::iter::traits::InfiniteIterator;
 use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused, TrustedLen, UncheckedIterator};
 use crate::num::NonZero;
 use crate::ops::Try;
@@ -239,3 +240,14 @@ unsafe impl<I: InPlaceIterable, F> InPlaceIterable for Map<I, F> {
     const EXPAND_BY: Option<NonZero<usize>> = I::EXPAND_BY;
     const MERGE_BY: Option<NonZero<usize>> = I::MERGE_BY;
 }
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<I: !ExactSizeIterator, F> !ExactSizeIterator for Map<I, F> {}
+
+#[stable(feature = "infinite_iterator_trait", since = "CURRENT_RUSTC_VERSION")]
+impl<B, I: Iterator, F> InfiniteIterator for Map<I, F>
+where
+    F: FnMut(I::Item) -> B,
+    I: InfiniteIterator + !ExactSizeIterator,
+{
+}