borrow checker too restrictive in match statements, with confusing/confused compile errors

[makoConstruct]

struct Node{  left:Option<Box<Node>>  }

fn leftmost_child(n:& mut Node)-> & mut Node {
    let mut leftest = n;
    loop {
        match leftest.left.as_mut() {
            Some(nl) => leftest = &mut **nl,
            None => break,
        }
    }
    leftest
}

fn main(){}

yeilds

<anon>:6:9: 6:21 note: previous borrow of `leftest.left` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `leftest.left` until the borrow ends
<anon>:6        match leftest.left.as_mut() {
                      ^~~~~~~~~~~~
<anon>:12:2: 12:2 note: previous borrow ends here
<anon>:3 fn leftmost_child(n:& mut Node)-> & mut Node {
...
<anon>:12 }
          ^
<anon>:7:16: 7:35 error: cannot assign to `leftest` because it is borrowed
<anon>:7            Some(nl) => leftest = &mut **nl,
                                ^~~~~~~~~~~~~~~~~~~
<anon>:6:9: 6:21 note: borrow of `leftest` occurs here
<anon>:6        match leftest.left.as_mut() {
                      ^~~~~~~~~~~~
<anon>:11:2: 11:9 error: cannot borrow `*leftest` as mutable more than once at a time
<anon>:11   leftest
            ^~~~~~~
<anon>:6:9: 6:21 note: previous borrow of `leftest.left` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `leftest.left` until the borrow ends
<anon>:6        match leftest.left.as_mut() {
                      ^~~~~~~~~~~~
<anon>:12:2: 12:2 note: previous borrow ends here
<anon>:3 fn leftmost_child(n:& mut Node)-> & mut Node {
...
<anon>:12 }
          ^

http://is.gd/7aqog5
Note that there's another error about being unable to assign to leftest within the match body. Should borrowing forbid reassignment here?

[UserAB1236872]

This seems to be the same issue I'm having:

use std::cmp::Eq;

enum List<T: Eq> {
    Cons {
        val: T,
        next: Box<List<T>>,
    },
    Nil,
}

impl <T: Eq> List<T> {
    fn find_mut(&mut self, query: T) -> &mut List<T> {
        use List::{Cons, Nil};
        match *self {
            Nil => self,
            Cons{ref val, ref mut next} =>
            if *val == query { self } else { next.find_mut(query) },
        }
    }
}

The example is a bit useless, but that's about as minimal as I could get it. The actual case was a Binary Search Tree. Playground link, but the short version is you get the error cannot borrow '*self' as mutable because 'self.val' is also borrowed as immutable.

This is despite the fact that all the ref borrows will end upon return from the match. Without returning self from the Cons clause, it compiles fine. I can't even really find a good workaround for this without forcing T to implement the Copy trait.

[UserAB1236872]

Perhaps the title should be changed to something like "Borrow checker is too sensitive to borrows in pattern matching."

Another example has shown up on stack overflow.

[birkenfeld]

Doesn't look there anything diagnostic-related to do here.

[steveklabnik]

Triage: this code still does not compile

[shepmaster]

Note that this will be fine once NLL stabilizes:

struct Node {
    left: Option<Box<Node>>,
}

fn leftmost_child(n: &mut Node) -> &mut Node {
    let mut leftest = n;
    loop {
        match leftest.left {
            Some(ref mut nl) => leftest = &mut **nl,
            None => break,
        }
    }
    leftest
}

fn main() {}

Or more idiomatically:

struct Node {
    left: Option<Box<Node>>,
}

fn leftmost_child(n: &mut Node) -> &mut Node {
    let mut leftest = n;
    while let Some(ref mut nl) = leftest.left {
        leftest = nl;
    }
    leftest
}

fn main() {}

See also the canonical answer for this on Stack Overflow, which shows how to make it work before NLL.