Borrow checker gets confused with a mutable pointer which should be moved

[eefriedman]

pub struct FragmentRepr(Vec<FragmentRepr>);
pub fn accepted(mut entry: &mut FragmentRepr) {
    loop {
        let FragmentRepr(ref mut discrs) = *{entry};
        entry = &mut discrs[0];
    }
}
pub fn rejected(mut entry: &mut FragmentRepr) {
    loop {
        let FragmentRepr(ref mut discrs) = *entry;
        entry = &mut discrs[0];
    }
}
fn main() {}

Rust accepts the first function, but rejects the second with "error: cannot borrow entry.0 as mutable more than once at a time". It would be nice not to be forced to insert random curly braces to convince the borrow checker that my code is correct.

[barosl]

I think the reason why the first is accepted is that blocks unintentionally move out the values of references in Rust. I believe this behavior is there by accident, so there's a question: is there an "official" way to do so?

[arielb1]

If entry isn't moved, then the issue here is that borrowck doesn't reason about &mut FragmentRepr lacking drop glue - any such drop glue could invalidate discrs in the second example.

[bluss]

@barosl I think the identity function solution is the best.

/// Identity function. Move the input to output.
fn moving<T>(x: T) -> T { x }

let current: &mut _;

// Force move like this
moving(current).next

// we can also write it like this:
let tmp = current;
tmp.next

// or this:
{current}.next

[steveklabnik]

Triage: so is this a bug or not?

[Mark-Simulacrum]

@arielb1 Is the bug here "that borrowck doesn't reason about &mut FragmentRepr lacking drop glue"?

[memoryruins]

Triage: both functions compile (as well as when applied to a FragmentRepr) on 2018 edition.
2015 errors:

error[E0499]: cannot borrow `entry.0` as mutable more than once at a time
  --> src/main.rs:11:26
   |
11 |         let FragmentRepr(ref mut discrs) = *entry;
   |                          ^^^^^^^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
14 | }
   | - mutable borrow ends here

error[E0506]: cannot assign to `entry` because it is borrowed
  --> src/main.rs:12:9
   |
11 |         let FragmentRepr(ref mut discrs) = *entry;
   |                          -------------- borrow of `entry` occurs here
12 |         entry = &mut discrs[0];
   |         ^^^^^^^^^^^^^^^^^^^^^^ assignment to borrowed `entry` occurs here

error: aborting due to 2 previous errors

rustc: 1.32.0

edit: removing fixed-by-nll tag as I am not certain how it affects drop glue. pointing this out in another triage thread.

[arielb1]

This is indeed intentionally fixed by NLL. &mut FragmentRepr can't possibly have drop glue (it is Copy).

[arielb1]

keywords: "copy-vs-move", "orphaned borrow". I seriously need to find the root test for this.

[arielb1]

duplicate of #46361

[arielb1]

The test is

rust/src/test/run-pass/nll/mutating_references.rs

Lines 1 to 26 in b139669

	// run-pass
	#![feature(nll)]
	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() {
	let mut list = List { value: 1, next: None };
	let vec = to_refs(&mut list);
	assert_eq!(vec![&mut 1], vec);
	}

[pnkfelix]

okay since this has a test I won't tag it as E-needstest. (Presumably when NLL is turned on across the board we'll just remove #![feature(nll)] from all those tests.)

But I'm still going to leave it open since our policy is to leave NLL-fixed-by-NLL bugs open until we turn NLL on across the board