Confusing lifetime error in the presence of a loop

[jyn514]

I just got the following error (playground):

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:9
  |
3 |     let slice = v.as_slice();
  |                 - immutable borrow occurs here
...
6 |         f(slice);
  |           ----- immutable borrow later used here
7 |         v.push(2);
  |         ^^^^^^^^^ mutable borrow occurs here

The error alone does not give you enough info to see what's going wrong: push is called after f(slice), why is the borrow still active? You need to look at the whole code to realize it's because f is called in the next loop iteration:

    for _ in 0..5 {
        f(slice);
        v.push(2);
    }

It would be nice to include this info in the error - I think there are already some errors that say "borrowed in the next loop iteration".

[crumblingstatue]

Here is a complete example

fn main() {
    let mut foo = 42;
    let r = &foo;

    loop {
        println!("{}", r);
        foo += 1;
    }
}

error[E0506]: cannot assign to `foo` because it is borrowed
 --> src/main.rs:7:9
  |
3 |     let r = &foo;
  |             ---- borrow of `foo` occurs here
...
6 |         println!("{}", r);
  |                        - borrow later used here
7 |         foo += 1;
  |         ^^^^^^^^ assignment to borrowed `foo` occurs here

If we change this into an example about moving, we get a nice explanation about the effects of the loop:

struct Movable(i32);

impl Movable {
    fn into_inner(self) -> i32 {
        self.0
    }
}

fn main() {
    let mut foo = Movable(42);

    loop {
        foo.0 += 1;
        println!("{}", foo.into_inner());
    }
}

error[E0382]: use of moved value: `foo.0`
  --> src/main.rs:13:9
   |
10 |     let mut foo = Movable(42);
   |         ------- move occurs because `foo` has type `Movable`, which does not implement the `Copy` trait
...
13 |         foo.0 += 1;
   |         ^^^^^^^^^^ value used here after move
14 |         println!("{}", foo.into_inner());
   |                            ------------ `foo` moved due to this method call, in previous iteration of loop
   |
note: this function takes ownership of the receiver `self`, which moves `foo`
  --> src/main.rs:4:19
   |
4  |     fn into_inner(self) -> i32 {
   |                   ^^^^

Maybe something similar is possible for E0502/E0506 as well.

[asquared31415]

I think these are technically different errors, borrowing versus assignment, but they are both extremely similar and would benefit from mentioning the loop if possible.

[crumblingstatue]

I think even if the design for a more helpful diagnostic is yet to be made, in the meantime adding a note at the end could help a lot too.

Note: The borrow occurs in a loop. or something similar