Error E0053 (values differ in mutability) has a too general span

[mcpherrinm]

An example: http://is.gd/GuGCDC

:4:5: 7:4 error: method `add` has an incompatible type for trait: values differ in mutability [E0053]
:4     fn add(&self, _rhs: &mut Foo) -> Foo {
:5       println!("Adding!");
:6       *self
:7   }

A better error might have a span showing just the mut (or the parameter) and a suggested correct signature. Right now I have to go look the trait up, either in the code or the docs.

 fn add(&self, _rhs: &mut Foo) -> Foo {
                      ^~~
 Note: The correct signature would be
 fn add(&self, _rhs: &Foo) -> Foo {

[nham]

This appears to still be a problem. The Add trait has changed (so the example above no longer applies), but an updated example is:

use std::ops::Deref;

struct Foo(u8);

impl Deref for  Foo {
    type Target = u8;

    fn deref<'a>(&'a mut self) -> &'a u8 {
        &self.0
    }
}

fn main() {}

The result:

:8:5: 10:6 error: method `deref` has an incompatible type for trait: values differ in mutability [E0053]
:8     fn deref<'a>(&'a mut self) -> &'a u8 {
:9         &self.0
:10     }
error: aborting due to previous error

[oli-obk]

simplified version:

trait A {
    fn b(c: i32);
}

impl A for () {
    fn b(c: ()) {  }
}

This occurs because the check re-uses the type inference/relation code for creating the error message, but the type inference/relation code does not use sub-spans for checking inner types and thus doesn't/can't attach spans to the error object.

[estebank]

Current output:

error[E0053]: method `b` has an incompatible type for trait
 --> <anon>:6:13
  |
2 |     fn b(c: i32);
  |             --- type in trait
...
6 |     fn b(c: ()) {  }
  |             ^^ expected i32, found ()
  |
  = note: expected type `fn(i32)`
             found type `fn(())`

[Mark-Simulacrum]

Closing as fixed, tests already exist -- ui/mismatched_types/trait-impl-fn-incompatibility.rs.

trait A {
    fn b(c: &i32);
}

impl A for () {
    fn b(c: &mut i32) {  }
}

error[E0053]: method `b` has an incompatible type for trait
 --> test.rs:6:13
  |
2 |     fn b(c: &i32);
  |             ---- type in trait
...
6 |     fn b(c: &mut i32) {  }
  |             ^^^^^^^^ types differ in mutability
  |
  = note: expected type `fn(&i32)`
             found type `fn(&mut i32)`

error: aborting due to previous error(s)