Improve compile error for borrowing mut while missing Sized trait bound

[wheird-lee]

Given the following code:

trait Modify {
    fn modify(&mut self) ;
}

impl<T> Modify for T  {
    fn modify(&mut self)  {
        // ...
    }
}

trait Foo {
    fn mute(&mut self) {
        self.modify();
    }
}

The current output is:

self.modify();
^^^^^^^^^^^^^ cannot borrow as mutable

Ideally the output should look like:

the size for values of type `Self` cannot be known at compilation time

add Sized trait bound and the code compiles successfully:

trait Modify {
    fn modify(&mut self) ;
}

impl<T> Modify for T  {
    fn modify(&mut self)  {
        // ...
    }
}

trait Foo: Sized {
    fn mute(&mut self) {
        self.modify();
    }
}

rust version: rustc 1.58.0 (02072b4 2022-01-11)

[wheird-lee]

okay..l realized the real reason is that I implies Modify for T: Sized, so maybe "trait not implied for Self" is more suitable?

[compiler-errors]

Oh lol, I think this is because of autoref.

It's trying to take &mut of self (i.e. grab a &mut &mut Self pointer) since that means T = &mut Self which is Sized, but the &mut self argument (i.e. self: &mut Self) is not mutable.

Wonder how much work it is to make autoref during method dispatch to skip taking &mut of a self method receiver in cases where it's known to fail (e.g. &mut self parameter shorthand syntax).

[wheird-lee]

well, I think you are right. It's my thoughtlessness.

[compiler-errors]

@Niiiiiil I think this is still worthwhile to keep open as an issue because of the confusing error message!

[QuineDot]

This came up on URLO in the context of an extension trait, and I'd like to point out how unhelpful the error is:

• Given that the signature is fn mute(&mut self) {, it's confusing to say

  error[E0596]: cannot borrow `self` as mutable, as it is not declared as mutable
    --> src/lib.rs:13:9
     |
  13 |         self.modify();
     |         ^^^^^^^^^^^^^ cannot borrow as mutable

• This is the only thing that is said, there is no suggestion
• You have to figure out it means the &mut Self is not mutable, vs. the referenced Self
• You have to know about method resolution to have a chance of understanding it's trying to create a &mut &mut self to call the implementation of &mut Self
• You have to know about implicit Sized bounds and where they aren't to have a chance of understanding why it's not calling an implementation of Self

It is a bit tricky though, as there are at least three possible suggestions:

• Change the signature to fn mute(mut self: &mut Self) {
• Add a Sized bound to trait Foo
• Add a ?Sized bound on the blanket implementation:

  impl<T: ?Sized> Modify for T  {

The last solution is the most correct in my opinion (but can only be applied if that implementation is local).

Finally, this variation:

    fn mute(self: &mut Self) {
        self.modify();
    }

Does give a suggestion:

help: consider making the binding mutable
   |
11 |     fn mute(mut self: &mut Self) {
   |             +++

Even though it's not the ideal suggestion. Let me know if I should file a separate bug for &mut self sugar disabling diagnostic suggestions. (If it exists I didn't find it.)

@rustbot label +D-confusing +D-terse +D-newcomer-roadblock