loan paths leaking into borrowck errors

[Manishearth]

pub fn main(){
    let maybe = Some(vec![true, true]);

    loop {
        if let Some(thing) = maybe {
        }
    }
}

(playpen)

gives the error

error[E0382]: use of partially moved value: `maybe`
 --> test.rs:7:30
  |
7 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here
  |
  = note: move occurs because `(maybe:std::prelude::v1::Some).0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error[E0382]: use of moved value: `(maybe:std::prelude::v1::Some).0`
 --> test.rs:7:21
  |
7 |         if let Some(thing) = maybe {
  |                     ^^^^^ value moved here in previous iteration of loop
  |
  = note: move occurs because `(maybe:std::prelude::v1::Some).0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error: aborting due to 2 previous errors

(maybe:std::prelude::v1::Some).0 seems to be MIR leaking into the UI

cc @jonathandturner @eddyb

[eddyb]

I think those are just the loan paths that borrowck uses. It's not like MIR is hooked up to it.

[eddyb]

cc @rust-lang/compiler

[nikomatsakis]

Yes, this is not MIR, but just regular loan-paths. Nonetheless, a suboptimal experience. I'm not sure what's the best way to present this. Probably we would want to (at minimum) filter on paths that the user couldn't write and try a more ambiguous phrasing (e.g., 'move occurs because bound value has type Vec<u8>')

(cc @estebank)

[nikomatsakis]

Or maybe we can give the name of the binding (when there is one)? That might take a bit of plumbing.

[estebank]

There probably should be only one move error in this code, should't it?

Would the following output be enough (with very small changes to the existing code)?

error[E0382]: use of partially moved value: `maybe`
 --> test.rs:7:30
  |
7 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here, because it has type `std::vec::Vec<bool>`, which does't implement the `Copy` trait

error: aborting due to previous error

[arielb1]

I think so.

[nikomatsakis]

@estebank that output looks good to me

[estebank]

I'll post a PR later today, but I'm not entirely convinced with the output, too long a label in my eyes:

error[E0382]: use of partially moved value: `maybe`
 --> file.rs:5:30
  |
5 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here because it has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error[E0382]: use of moved value: `maybe.0`
 --> file.rs:5:21
  |
5 |         if let Some(thing) = maybe {
  |                     ^^^^^ value moved here in previous iteration of loop because it has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error: aborting due to 2 previous errors

vs the current

error[E0382]: use of partially moved value: `maybe`
 --> file.rs:5:30
  |
5 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here
  |
  = note: move occurs because `(maybe:std::prelude::v1::Some).0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error[E0382]: use of moved value: `(maybe:std::prelude::v1::Some).0`
 --> file.rs:5:21
  |
5 |         if let Some(thing) = maybe {
  |                     ^^^^^ value moved here in previous iteration of loop
  |
  = note: move occurs because `(maybe:std::prelude::v1::Some).0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error: aborting due to previous error(s)

Three other alternatives I can think of are:

error[E0382]: use of partially moved value: `maybe`
 --> file.rs:5:30
  |
5 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here
  |                     because it has type `std::vec::Vec<bool>`
  |                     which does not implement the `Copy` trait

error[E0382]: use of moved value: `maybe.0`
 --> file.rs:5:21
  |
5 |         if let Some(thing) = maybe {
  |                     ^^^^^
  |                     |
  |                     value moved here in previous iteration of loop
  |                     because it has type `std::vec::Vec<bool>`
  |                     which does not implement the `Copy` trait

error: aborting due to 2 previous errors

error[E0382]: use of partially moved value: `maybe`
 --> file.rs:5:30
  |
5 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here because it has type `std::vec::Vec<bool>`
  = note: `std::vec::Vec<bool>` does not implement the `Copy` trait

error[E0382]: use of moved value: `maybe.0`
 --> file.rs:5:21
  |
5 |         if let Some(thing) = maybe {
  |                     ^^^^^ value moved here in previous iteration of loop because it has type `std::vec::Vec<bool>`
  = note: `std::vec::Vec<bool>` does not implement the `Copy` trait

error: aborting due to 2 previous errors

and

error[E0382]: use of partially moved value: `maybe`
 --> file.rs:5:30
  |
5 |         if let Some(thing) = maybe {
  |                     -----    ^^^^^ value used here after move
  |                     |
  |                     value moved here
  |
  = note: move occurs because `maybe.0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error[E0382]: use of moved value: `maybe.0`
 --> file.rs:5:21
  |
5 |         if let Some(thing) = maybe {
  |                     ^^^^^ value moved here in previous iteration of loop
  |
  = note: move occurs because `maybe.0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait

error: aborting due to previous error(s)

Does it make sense to refer to (maybe:std::prelude::v1::Some).0 as maybe.0? It is technically correct, if not very illuminating. Put in another way, when does (maybe:std::prelude::v1::Some).0 make sense, other than for rustc debugging output?