MIR borrowck doesn't accept the example of iterating and updating a mutable reference

[nikomatsakis]

I expected this example from the NLL RFC to pass the MIR borrow checker:

struct List<T> {
    value: T,
    next: Option<Box<List<T>>>,
}

fn to_refs<T>(mut list: &mut List<T>) -> Vec<&mut T> {
    let mut result = vec![];
    loop {
        result.push(&mut list.value);
        if let Some(n) = list.next.as_mut() {
            list = n;
        } else {
            return result;
        }
    }
}

fn main() {
}

The idea here is that assigning to list is supposed to clear the existing borrows of list.{value,next}. However, it still gets errors for me:

lunch-box. rustc --stage1 iterate-mut-ref.rs  -Zborrowck=mir
error[E0499]: cannot borrow `list.value` as mutable more than once at a time
  --> iterate-mut-ref.rs:9:21
   |
9  |         result.push(&mut list.value);
   |                     ^^^^^^^^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
16 | }
   | - mutable borrow ends here

error[E0499]: cannot borrow `list.next` as mutable more than once at a time
  --> iterate-mut-ref.rs:10:26
   |
10 |         if let Some(n) = list.next.as_mut() {
   |                          ^^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
16 | }
   | - mutable borrow ends here

error[E0506]: cannot assign to `list` because it is borrowed
  --> iterate-mut-ref.rs:11:13
   |
9  |         result.push(&mut list.value);
   |                     --------------- borrow of `list` occurs here
10 |         if let Some(n) = list.next.as_mut() {
11 |             list = n;
   |             ^^^^^^^^ assignment to borrowed `list` occurs here

error: aborting due to 3 previous errors

cc @pnkfelix @arielb1

[nikomatsakis]

It turns out the code for this was just never written. What we need to do is "kill" the relevant borrows in the borrows.rs data flow code. The StorageDead case is doing something similar already, but specific to local variable places:

rust/src/librustc_mir/dataflow/impls/borrows.rs

Lines 265 to 268 in 707d070

	// FIXME: expand this to variables that are assigned over.
	if let Some(borrow_indexes) = self.local_map.get(&local) {
	sets.kill_all(borrow_indexes);
	}

We would need to handle this in the case of a general assignment, but there the Place values that can be assigned can be any sort of path, so we need to be handling them all.

[Yoric]

So, if I understand correctly, we want to duplicate/share the logics from StorageDead to Assign(ref lhs, _), right? I'm starting to look into it.

[Yoric]

As discussed with @pnkfelix over gitter, I'll try to first write a patch that works only if we Assign to a Local. Once this works, I'll see if I can understand what to do for a Place::Projection.

[nikomatsakis]

@Yoric great! that's a good starting point.

[Yoric]

I'm now trying to tackle down the next part, but I can't find anything useful in the RFC, so I'm a bit blind here.

Looking at projections, I see the following cases:

1. *a = expr
2. a.foo = expr
3. a[slice] = expr
4. a[literal] = expr
5. a[expr] = expr
6. downcasts (not entirely sure what they are)

I imagine that case 1. is basically the same thing as what I have done already and that cases for 3 and 5, there isn't anything we can do. What about cases 2, 4 and 6?