E0106 "missing lifetime specifier" should be omitted when the signature is incorrect in an `impl` (E0186)

[kpreid]

Code

trait Foo {
    fn foo(&self) -> &str;
}

struct Example;
impl Foo for Example {
    fn foo() -> &str {
        "example"
    }
}

Current output

error[E0106]: missing lifetime specifier
 --> src/lib.rs:7:17
  |
7 |     fn foo() -> &str {
  |                 ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
7 |     fn foo() -> &'static str {
  |                  +++++++
help: instead, you are more likely to want to return an owned value
  |
7 |     fn foo() -> String {
  |                 ~~~~~~

error[E0186]: method `foo` has a `&self` declaration in the trait, but not in the impl
 --> src/lib.rs:7:5
  |
2 |     fn foo(&self) -> &str;
  |     ---------------------- `&self` used in trait
...
7 |     fn foo() -> &str {
  |     ^^^^^^^^^^^^^^^^ expected `&self` in impl

Desired output

error[E0186]: method `foo` has a `&self` declaration in the trait, but not in the impl
 --> src/lib.rs:7:5
  |
2 |     fn foo(&self) -> &str;
  |     ---------------------- `&self` used in trait
...
7 |     fn foo() -> &str {
  |     ^^^^^^^^^^^^^^^^ expected `&self` in impl

Rationale and extra context

When the function is a trait associated function, the signature must match (or refine) the trait’s, so E0106 and any other errors that would propose changes to the signature are misleading or at least not nearly as relevant as E0186 (or E0050 or E0053 or any other such mismatch). Therefore, they should be hidden.

This is particularly important for situations involving a missing self parameter, because (in my personal experience) it’s easy to forget to write self in the parameter list.

Rust Version

1.84.0

[samueltardieu]

I think this is another occurrence, without traits, but involving a wrong type for self:

struct S;
struct T;
impl T {
    fn f(self: &mut S) -> &mut S { self }
}

error[E0106]: missing lifetime specifier
 --> e.rs:6:27
  |
6 |     fn f(self: &mut S) -> &mut S { self }
  |                ------     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say which `self` it is borrowed from
help: consider introducing a named lifetime parameter
  |
6 |     fn f<'a>(self: &'a mut S) -> &'a mut S { self }
  |         ++++        ++            ++
error[E0307]: invalid `self` parameter type: `&mut S`
 --> e.rs:6:16
  |
6 |     fn f(self: &mut S) -> &mut S { self }
  |                ^^^^^^
  |
  = note: type of `self` must be `Self` or a type that dereferences to it