Nested APITs are excessively opaque

[Jules-Bertholet]

I tried this code:

fn foo(iter: impl IntoIterator<IntoIter = impl Sized>) {
    iter.into_iter().next();
}

I expected to see this happen: compiles successfully

Instead, this happened:

error[E0599]: no method named `next` found for type parameter `impl Sized` in the current scope
 --> src/lib.rs:2:22
  |
1 | fn foo(iter: impl IntoIterator<IntoIter = impl Sized>) {
  |                                           ---------- method `next` not found for this type parameter
2 |     iter.into_iter().next();
  |                      ^^^^ method not found in `impl Sized`
  |
  = help: items from traits can only be used if the type parameter is bounded by the trait
help: the following trait defines an item `next`, perhaps you need to restrict type parameter `impl Sized` with it:
  |
1 | fn foo(iter: impl IntoIterator<IntoIter = impl Sized + Iterator>) {
  |                                                      ++++++++++

For more information about this error, try `rustc --explain E0599`.
error: could not compile `scratch` (lib) due to previous error

Meta

rustc --version --verbose:

rustc 1.76.0-nightly (f5dc2653f 2023-11-25)
binary: rustc
commit-hash: f5dc2653fdd8b5d177b2ccbd84057954340a89fc
commit-date: 2023-11-25
host: x86_64-unknown-linux-gnu
release: 1.76.0-nightly
LLVM version: 17.0.5

@rustbot label A-impl-trait T-types

[compiler-errors]

This is not an APIT problem:

fn foo<T: IntoIterator<IntoIter = I>, I>(iter: T) {
    iter.into_iter().next();
}

We don't currently have the ability to elaborated bounds that are required for well-formedness when types appear in associated type position.

This is particularly difficult to do, and also not necessarily clear whether we want to assume that I: Iterator as an elaborated bound. For the purposes of argument, we could instead require that I: Iterator for well-formedness of the T: IntoIterator<IntoIter = I> predicate, and make it an error of the definition of fn foo. I don't have a strong opinion, just trying to lay out the options.

[Jules-Bertholet]

Related example:

use core::fmt::Debug;
fn foo<T: IntoIterator<IntoIter = I, Item = It>, I: Iterator, It: Debug>(iter: T) {
    dbg!(iter.into_iter().next()); // error[E0277]: `<I as Iterator>::Item` doesn't implement `Debug`
}