Suggest not using method call syntax when type can't be inferred

[dullbananas]

Code

struct S<T> {
    f: fn(T) -> T,
}

fn main() {
    let mut n = 0i32;
    let s = S {
        f: |x| x.clone(),
    };
    n = (s.f)(n);
}

Current output

error[E0282]: type annotations needed
 --> src/main.rs:8:13
  |
8 |         f: |x| x.clone(),
  |             ^  - type must be known at this point
  |
help: consider giving this closure parameter an explicit type
  |
8 |         f: |x: /* Type */| x.clone(),
  |              ++++++++++++

Desired output

error[E0282]: type annotations needed
 --> src/main.rs:8:13
  |
8 |         f: |x| x.clone(),
  |             ^  - type must be known at this point
  |
help: consider giving this closure parameter an explicit type
  |
8 |         f: |x: /* Type */| x.clone(),
  |              ++++++++++++
  |
help: consider calling the function directly
  |
8 |         f: |x| Clone::clone(&x),

Rationale and extra context

Calling the function directly gets rid of the "type annotations needed" error

Other cases

No response

Anything else?

No response

[fee1-dead]

I'm inclined to say that this isn't always a good suggestion to have, because the following case exists:

trait Foo {
    fn foo(&self);
}

struct S<T> {
    f: fn(T) -> T,
}

struct Bar;

impl Bar {
    fn foo(&self) {}
}

fn main() {
    let n = Bar;
    let s = S {
        f: |x| x.foo(),
    };
    n = (s.f)(n);
}

In this case, we really can't suggest using Foo::foo(&x). That is incorrect, since we'd want to suggest the inherent method instead. HOWEVER, it might be possible if there was a mechanism for seeing if inference will pass if we tried provisionally interpreting it as <_ as Trait>::method and seeing if more progress could be made, so this isn't entirely a bad suggestion to have either.