Borrowing error refers to ***borrow when borrow should be &mut i32

[birkenfeld]

Found on rustc 1.10.0-nightly (2174bd9 2016-04-14). Minimal example:

fn main() {
    let mut var = 0i32;
    let borrow = &mut var;
    || {
        let borrow_borrow = &borrow;
        *borrow = 1;
    };
}

The error is

src/main.rs:6:9: 6:20 error: cannot assign to `***borrow` because it is borrowed [E0506]
src/main.rs:6         *borrow = 1;
                      ^~~~~~~~~~~
src/main.rs:5:30: 5:36 note: borrow of `***borrow` occurs here
src/main.rs:5         let borrow_borrow = &borrow;
                                           ^~~~~~

Actually trying to assign to ***borrow or **borrow fails with the expected "i32 cannot be dereferenced".

[KalitaAlexey]

@birkenfeld In closure you have borrow_borrow, but use borrow. Is it ok?
Type of borrow_borrow is & &mut i32. You borrowed mutable borrow so you cannot use mutable borrow until borrow of mutable borrow exists.

[birkenfeld]

@KalitaAlexey I know. The point of the issue isn't that it should compile, but that the error message is strange: it refers to ***borrow which is probably invalid, but at least confusing.

[Thiez]

Not sure if this helps, but using a move closure as shown below changes the name in the error **borrow instead of ***borrow.

    let mut var = 0i32;
    let borrow = &mut var;
    move || {
        let borrow_borrow: &&mut i32 = &borrow;
        *borrow = 1;
    };

6:9: 6:20 error: cannot assign to `**borrow` because it is borrowed [E0506]
6         *borrow = 1;
          ^~~~~~~~~~~
5:41: 5:47 note: borrow of `**borrow` occurs here
5         let borrow_borrow: &&mut i32 = &borrow;
                                          ^~~~~~

[steveklabnik]

Triage: non-lexical lifetimes makes this code work. But without it, this error still happens.

Are there other code samples that trigger this error? Because eventually, in practice, nobody will see it, even if it's bad.

[jonas-schievink]

fn main() {
    let mut var = 0i32;
    let borrow = &mut var;
    || {
        let borrow_borrow = &borrow;
        *borrow = 1;
        let _use = borrow_borrow;
    };
}

gives (with NLL)

error[E0506]: cannot assign to `*borrow` because it is borrowed
 --> src/main.rs:6:9
  |
5 |         let borrow_borrow = &borrow;
  |                             ------- borrow of `*borrow` occurs here
6 |         *borrow = 1;
  |         ^^^^^^^^^^^ assignment to borrowed `*borrow` occurs here
7 |         let _use = borrow_borrow;
  |                    ------------- borrow later used here

So the diagnostic is fixed when NLL is enabled.

[pnkfelix]

Now that NLL is stably deployed for all editions, closing as fixed.