Suggest reborrowing mutable reference when move error ocurrs

[Aaron1011]

The following code:

struct Foo;
struct Wrapper<T>(T);

fn use_val<T>(_: &mut T) {}

impl Foo {
    fn call_it(&mut self) {
        use_val(&mut Wrapper(self));
        self;
    }
}

produces the following error:

error[E0382]: use of moved value: `self`
 --> src/lib.rs:9:9
  |
7 |     fn call_it(&mut self) {
  |                --------- move occurs because `self` has type `&mut Foo`, which does not implement the `Copy` trait
8 |         use_val(&mut Wrapper(self));
  |                              ---- value moved here
9 |         self;
  |         ^^^^ value used here after move

error: aborting due to previous error

When self is passed directly to use_val (e.g. use_val(self), a reborrow will automatically be inserted, allowing the code to compile. However, the fact that use_val takes an &mut T means that the compiler won't adjust the inferred type in any way (in this case, &mut Wrapper<&mut Foo>), leading to the move error.

The solution is to add an explicit reborrow (&mut Wrapper(&mut *self)), however, this wasn't obvious to me. It would be useful if the compiler could suggest inserting a reborrow in this situation.