Suggest `&foo` when passing `foo` to a function expecting `AsRef<T>`...

[oli-obk]

... and trying to use foo afterwards, which triggers

error[E0382]: use of moved value: foo

Example:

struct Bar;

impl AsRef<Bar> for Bar {
    fn as_ref(&self) -> &Bar {
        self
    }
}

fn foo<T: AsRef<Bar>>(_: T) {}

pub fn main() {
    let bar = Bar;
    foo(bar);
    let baa = bar;
}

currently yields

rustc 1.17.0 (56124baa9 2017-04-24)
error[E0382]: use of moved value: `bar`
  --> <anon>:15:9
   |
14 |     foo(bar);
   |         --- value moved here
15 |     let baa = bar;
   |         ^^^ value used here after move
   |
   = note: move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait

error: aborting due to previous error

I suggest that it should also contain

help: if you meant to borrow `bar` use `foo(&bar)`?

[nagisa]

AsRef is a library trait, so IMO we should not do that. Also to me "value moved here" is pretty much the "you need to use this as reference".

[oli-obk]

Also to me "value moved here" is pretty much the "you need to use this as reference".

While this might be obvious to us, I've had students struggling strongly with these errors. When I tell them "just add an ampersand", they're like "Oh, that makes total sense".

AsRef is a library trait, so IMO we should not do that.

I don't see that as reason not to do it. Could you elaborate?

[kennytm]

This should also handle AsMut, Borrow, BorrowMut.

[oli-obk]

AsMut and BorrowMut aren't as clear, since the object will be modified, so the user might also want to bar.clone(), but that can later be signalled through rust-lang/rfcs#1941 and/or multiple suggestions

[nagisa]

I don't see that as reason not to do it. Could you elaborate?

Obvious way of doing this would involve making AsRef a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved.

One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for "value moved here" if there’s a trait implementation for &T also), but then the problem of suggestion not being always correct kicks in.

So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.

[oli-obk]

making AsRef a language item or otherwise special in some other way.

I fully agree that that is not desirable

In clippy we have similar diagnostics which in this case would simply check for core::convert::AsRef (see https://github.com/Manishearth/rust-clippy/blob/master/clippy_lints/src/utils/paths.rs#L3 for all the paths that we resolve manually).

[rylev]

Triage: this still produces the same error message.

Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing AsRef, but that seems unlikely.

[oli-obk]

We have diagnostic items nowadays, so we can make AsRef a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late

[Dylan-DPC]

Current output:

warning: unused variable: `baa`
  --> src/main.rs:14:9
   |
14 |     let baa = bar;
   |         ^^^ help: if this is intentional, prefix it with an underscore: `_baa`
   |
   = note: `#[warn(unused_variables)]` on by default

error[[E0382]](https://doc.rust-lang.org/nightly/error_codes/E0382.html): use of moved value: `bar`
  --> src/main.rs:14:15
   |
12 |     let bar = Bar;
   |         --- move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait
13 |     foo(bar);
   |         --- value moved here
14 |     let baa = bar;
   |               ^^^ value used here after move
   |
note: consider changing this parameter type in function `foo` to borrow instead if owning the value isn't necessary
  --> src/main.rs:9:26
   |
9  | fn foo<T: AsRef<Bar>>(_: T) {}
   |    --- in this function  ^ this parameter takes ownership of the value

For more information about this error, try `rustc --explain E0382`.
warning: `playground` (bin "playground") generated 1 warning
error: could not compile `playground` (bin "playground") due to previous error; 1 warning emitted