Add a lint for equality bounds on generic parameters

[ftxqxd]

Since a lot of traits now use associated types, some code can be simplified, removing the need for some generic parameters. However, some code may not utilise this flexibility, treating associated types in the same way as usual type parameters (especially if the trait was only recently changed to use associated types, and code like Trait<T> was simply changed to Trait<Foo=T>). For example:

fn foo<T, I>(x: I) where T: Clone, I: Iterator<Item = T> { ... }
// should be
fn foo<I>(x: I) where I: Iterator, <I as Iterator>::Item: Clone { ... }

struct Foo<T, I> where I: Iterator, <I as Iterator>::Item = T { ... }
// should be
struct Foo<I> where I: Iterator { ... }

I think a lint could detect these redundant type parameters by warning whenever a type parameter is equated with anything in an equality bound. In other words, I think T = AnyType is always indicative of an unnecessary type parameter (although I’m not 100% sure on this—is there any example where that’s a valid thing to do?).

[ftxqxd]

I just realised that there are some cases where equality bounds on type parameters are useful. In particular, an equality bound on a type parameter in a different position from where the type parameter was introduced is still valid:

trait Foo<T> {
    fn frog(&self);
    fn turkey(&mut self) where T = u8;
}

[huonw]

It is currently impossible to avoid this with stable function sugar, e.g. there's no way to rewrite

fn call<F, T(f: F) -> T 
    where F: FnOnce(i32) -> T
{ 
    f(1)
}

to avoid the implicit Output = T constraint, without using feature gated things. (Of course this hypothetical lint could handle this sugar specially.)

[steveklabnik]

Since new lints have a big impact on users of rustc, the policy is that they should go through the RFC process like other user-facing changes. As such, I'm going to give this one a close, but if anyone comes across this ticket and wants this lint, consider adding it to clippy and/or writing up an RFC. Thanks!