Detect use of unnecessary dyn in function parameter

[tabokie]

What it does

Scan for all uses of a function, and check if the &dyn T can be replaced by &impl T.

Advantage

• Avoid the overhead introduced by dynamic dispatch

Drawbacks

Code bloat and compile overhead.

Example

// A private trait that takes a dyn reference.
trait Trait {
  fn f(writer: &mut dyn std::io::Write);
}

// Using that trait with concrete types.
fn use_trait(obj: impl Trait) {
  obj.f(&mut Vec::new());
}

Could be written as:

trait Trait {
  fn f(writer: &mut impl std::io::Write);
}

fn use_trait(obj: impl Trait) {
  obj.f(&mut Vec::new());
}

[y21]

The downside is that this can introduce a lot of monomorphization bloat if the function is called with lots of different types which can result in increased compile times and bigger code size, so I'm unsure if this should be a lint. Sounds like a tradeoff decision the user should make on a case by case basis

[tabokie]

Indeed. But then again, I think a lot of the "redundant"/"needless"/"useless"/"unnecessary" lints belong to this area of requiring a manual tradeoff. This particular lint is very helpful in my case where latency performance is crucial.

I'm not sure the complexity of this lint though. I'm not looking to add a default-allow lint that is also difficult to implement and maintain.