Logic of borrowing in Rust

[giappi]

When trying to compile this code:

fn main()
{
    let mut t = vec![0, 1, 2, 3, 4, 5, 6, 7];
    t.push( t.len() );
}

I got a problem

error[E0502]: cannot borrow `t` as immutable because it is also borrowed as mutable
 --> src/main.rs:4:13
  |
4 |     t.push( t.len());
  |     -       ^      - mutable borrow ends here
  |     |       |
  |     |       immutable borrow occurs here
  |     mutable borrow occurs here

error: aborting due to previous error

To correct the code, we must split expression into two line:

let tmp = t.len(); // borrow ends here
t.push(tmp);

I think it would be very inconvenient if such instructions appear in many places.

I think the logic of Rust in above code is:

1. t.push(expression): borrow t first as mutable (but do nothing), and wait the expression has done.
2. t.len(): while t is borrowing as mutable, we borrow it again (as immutable) and we can not borrow, because it has already borrowed as mutable.

And I suggest changing logic to:

1. object.method(expression): evaluate expression first, we can borrow it as immutable many times to calculate something.
2. do object.method(...) with the result of the expression.
   Then we can write code more clearly.

---

This is just my thoughts. If something is not right, please give me some explanation. Thank you.

[mattico]

This is Two-Phase borrows: #46037
See also NLL: #43234

[steveklabnik]

Yup! And since it's not a bug, I'm going to give this a close. Or rather, the bug is already covered by those issues.