Borrow checker gives confusing error message when in loop

[ezyang]

When the borrow check fails in a loop, the error message can be quite confusing:

enum Nat {
    S(~Nat),
    Z
}
fn test(x: &mut Nat) {
    let mut p = &mut *x;
    loop {
        match p {
            &Z => break,
            &S(~ref mut n) => p = &mut *n
        }
    }
}

The borrow checker informs me:

Test.rs|43 col 16 error| cannot borrow `*(*p)#0` as mutable more than once at a time
Test.rs|43 col 16 n| second borrow of `*(*p)#0` as mutable occurs here

This message is confusing, because the two occurrences have the same line number and column. In fact, the error message is right: the borrow check only fails because it is being performed in a loop. The error message should mention something like that to the effect.

[treeman]

Still relevant:

enum Nat {
    S(Box<Nat>),
    Z
}
fn test(x: &mut Nat) {
    let mut p = &mut *x;
    loop {
        match p {
            &Z => break,
            &S(box ref mut n) => p = &mut *n
        }
    }
}

fn main() { }

Gives:

tst.rs:11:20: 11:29 error: cannot borrow `*p#0` as mutable more than once at a time
tst.rs:11             &S(box ref mut n) => p = &mut *n
                             ^~~~~~~~~
tst.rs:11:20: 11:29 note: previous borrow of `*p#0` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*p#0` until the borrow ends
tst.rs:11             &S(box ref mut n) => p = &mut *n
                             ^~~~~~~~~
tst.rs:14:2: 14:2 note: previous borrow ends here
tst.rs:6 fn test(x: &mut Nat) {
...
tst.rs:14 }
          ^

[nham]

Triage: The error looks better, but I'm not sure if it's good enough to close this issue. The updated code:

#![feature(box_patterns)]

enum Nat {
    S(Box<Nat>),
    Z
}
fn test(x: &mut Nat) {
    let mut p = &mut *x;
    loop {
        match p {
            &mut Nat::Z => break,
            &mut Nat::S(box ref mut n) => p = &mut *n
        }
    }
}

fn main() { }

And the new error message is:

iss10876.rs:12:29: 12:38 error: cannot borrow `*p.0` as mutable more than once at a time
iss10876.rs:12             &mut Nat::S(box ref mut n) => p = &mut *n
                                           ^~~~~~~~~
iss10876.rs:12:29: 12:38 note: previous borrow of `*p.0` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*p.0` until the borrow ends
iss10876.rs:12             &mut Nat::S(box ref mut n) => p = &mut *n
                                           ^~~~~~~~~
iss10876.rs:15:2: 15:2 note: previous borrow ends here
iss10876.rs:7 fn test(x: &mut Nat) {
...
iss10876.rs:15 }
               ^
iss10876.rs:12:43: 12:54 error: cannot assign to `p` because it is borrowed
iss10876.rs:12             &mut Nat::S(box ref mut n) => p = &mut *n
                                                         ^~~~~~~~~~~
iss10876.rs:12:29: 12:38 note: borrow of `p` occurs here
iss10876.rs:12             &mut Nat::S(box ref mut n) => p = &mut *n
                                           ^~~~~~~~~
error: aborting due to 2 previous errors

[estebank]

This was fixed in 5b150cf.

[arielb1]

No it wasn't. Only the formatting changed.

[estebank]

Current output:

error[E0499]: cannot borrow `p.0` as mutable more than once at a time
  --> src/main.rs:10:25
   |
10 |             &mut Nat::S(ref mut n) => p = &mut *n
   |                         ^^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
13 | }
   | - mutable borrow ends here

error[E0506]: cannot assign to `p` because it is borrowed
  --> src/main.rs:10:39
   |
10 |             &mut Nat::S(ref mut n) => p = &mut *n
   |                         ---------     ^^^^^^^^^^^ assignment to borrowed `p` occurs here
   |                         |
   |                         borrow of `p` occurs here

[estebank]

The code now compiles, even in stable. @arielb1 consequence of NLL?

[arielb1]

This looks like it (see also #10520, the infamous copy-vs-move problem). I couldn't find a concrete test for this at a quick look, however.

[estebank]

@arielb1 should we add a pass test, come up with a different case or just close?