Missed opportunity for the "consider borrowing" hint

[Patryk27]

Given the following code:

pub struct NotCopy;

trait AsMutWhatever {}

impl AsMutWhatever for &mut NotCopy {}

pub fn case_1() {
    let mut not_copy = NotCopy; 
    
    takes_mut_not_copy(&mut not_copy);
    takes_mut_not_copy(&mut not_copy);
}

pub fn case_2(not_copy: &mut NotCopy) {
    takes_mut_not_copy(not_copy);
    takes_mut_not_copy(not_copy);
}

fn takes_mut_not_copy(_not_copy: impl AsMutWhatever) {
   // do nothing 
}

(playground link)

... the current output is:

error [E0382]: use of moved value: `not_copy`
  --> src/lib.rs:16:24
   |
14 | pub fn case_2(not_copy: &mut NotCopy) {
   |               -------- move occurs because `not_copy` has type `&mut NotCopy`, which does not implement the `Copy` trait
15 |     takes_mut_not_copy(not_copy);
   |                        -------- value moved here
16 |     takes_mut_not_copy(not_copy);
   |                        ^^^^^^^^ value used here after move

Ideally, this should also display the consider mutably borrowing 'not_copy': &mut *not_copy hint, since that's the solution to problem 🙂

[tgross35]

Is it supposed to suggest cloning over borrowing for even simple non-mut stuff?

let mut tmp = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let paths = fs::read_dir(tmp).unwrap();
tmp.pop();

(playground)

help: consider cloning the value if the performance cost is acceptable
  |
6 |     let paths = fs::read_dir(tmp.clone()).unwrap();
  |                                 ++++++++

That message is kind of weird, "consider cloning the value if the performance cost is acceptable". I can imagine some contexts where it's useful, like returning owned values made from references. But this is a pretty trivial case when passing &tmp by reference works better.

[estebank]

Current output:

error[E0382]: use of moved value: `not_copy`
  --> f75.rs:16:24
   |
14 | pub fn case_2(not_copy: &mut NotCopy) {
   |               -------- move occurs because `not_copy` has type `&mut NotCopy`, which does not implement the `Copy` trait
15 |     takes_mut_not_copy(not_copy);
   |                        -------- value moved here
16 |     takes_mut_not_copy(not_copy);
   |                        ^^^^^^^^ value used here after move
   |
note: consider changing this parameter type in function `takes_mut_not_copy` to borrow instead if owning the value isn't necessary
  --> f75.rs:19:34
   |
19 | fn takes_mut_not_copy(_not_copy: impl AsMutWhatever) {
   |    ------------------            ^^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
   |    |
   |    in this function

@tgross35 yes, borrowing would be a better suggestion here. That case is covered by #41708.

[estebank]

Current output:

error[E0382]: use of moved value: `not_copy`
  --> src/lib.rs:16:24
   |
14 | pub fn case_2(not_copy: &mut NotCopy) {
   |               -------- move occurs because `not_copy` has type `&mut NotCopy`, which does not implement the `Copy` trait
15 |     takes_mut_not_copy(not_copy);
   |                        -------- value moved here
16 |     takes_mut_not_copy(not_copy);
   |                        ^^^^^^^^ value used here after move
   |
note: consider changing this parameter type in function `takes_mut_not_copy` to borrow instead if owning the value isn't necessary
  --> src/lib.rs:19:34
   |
19 | fn takes_mut_not_copy(_not_copy: impl AsMutWhatever) {
   |    ------------------            ^^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
   |    |
   |    in this function
help: consider cloning the value if the performance cost is acceptable
   |
15 |     takes_mut_not_copy(not_copy).clone();
   |                                 ++++++++

I do not think that addressing the minimal solution to #41708 (which would be to explicitly look for an AsRef bound) would work for this (suggesting &mut that will continue working for the impl AsMutWhatever).