`type_complexity` should not trigger on types using impl trait

[ronnodas]

Summary

The type_complexity lint suggests extracting the complex type as an alias, but this is not allowed (in stable Rust) when the type involves an impl Trait.

Lint Name

type_complexity

Reproducer

I tried this code:

use std::iter::{Map, Zip};

pub fn main() {
    for [x, y] in array_zip([1, 2, 3], [4, 5, 6]) {
        println!("{x} <-> {y}");
    }
}

pub fn array_zip<I, J>(
    left: I,
    right: J,
) -> Map<Zip<I::IntoIter, J::IntoIter>, impl FnMut((I::Item, I::Item)) -> [I::Item; 2]>
where
    I: IntoIterator,
    J: IntoIterator<Item = I::Item>,
{
    left.into_iter().zip(right).map(<[I::Item; 2]>::from)
}

I saw this happen:

    Checking playground v0.0.1 (/playground)
warning: very complex type used. Consider factoring parts into `type` definitions
  --> src/main.rs:12:6
   |
12 | ) -> Map<Zip<I::IntoIter, J::IntoIter>, impl FnMut((I::Item, I::Item)) -> [I::Item; 2]>
   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.96.0/index.html#type_complexity
   = note: `#[warn(clippy::type_complexity)]` on by default

warning: `playground` (bin "playground") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s

I expected to see this happen: No lints triggered.

Version

Playground, running 1.96.0 (stable)

Additional Labels

@rustbot label +I-suggestion-causes-error

[samueltardieu]

Isn't that also a problem with I and J? The bounds on the generic parameters won't be enforced in type aliases.

[ronnodas]

@samueltardieu As far as I understand, in a type alias that would be spelled as <I as IntoIterator>::IntoIter and the where bounds would still be necessary to use that type alias as the return type.

Eg, std::iter::zip could use a type alias as follows, and reduce the "complexity" in its return type in the sense of this lint:

type ZipIntoIter<A, B> = std::iter::Zip<<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter>;

pub fn zip<A, B>(a: A, b: B) -> ZipIntoIter<A, B>
where 
    A: IntoIterator,
    B: IntoIterator,
{ ... }

[samueltardieu]

Would you be able to indicate that the Item type of A and B is identical?

[ronnodas]

I'm not sure of the exact context of your question, std::array::zip does not need those to be the same type. Specifically about the example in the original post, if the impl FnMut is changed to fn then a type alias can be extracted to satisfy the lint.

use std::iter::{Map, Zip};

pub type ArrayZip<I, J> = Map<
    Zip<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>,
    fn((<I as IntoIterator>::Item, <I as IntoIterator>::Item)) -> [<I as IntoIterator>::Item; 2],
>;

pub fn main() {
    for [x, y] in array_zip([1, 2, 3], [4, 5, 6]) {
        println!("{x} <-> {y}");
    }
}

pub fn array_zip<I, J>(left: I, right: J) -> ArrayZip<I, J>
where
    I: IntoIterator,
    J: IntoIterator<Item = I::Item>,
{
    left.into_iter().zip(right).map(<[I::Item; 2]>::from)
}

The equality of I::Item and J::Item is only enforced by the where bounds, but that seems orthogonal to the issue. See also rust-lang/rust#21903.