Borrow scope for pattern matches - again

[axos88]

This issue seems to be similar to this one, but the referenced issue #6379, does not solve it:

playground

enum Either<A,B> {
    Left(A),
    Right(B)
}

enum Tree<'a, A, B> {
    ALeaf(A),
    BLeaf(B),
    ABranch(&'a mut Tree<'a, A, B>, A),
    BBranch(&'a mut Tree<'a, A, B>, B)
}

impl<'a, A: PartialOrd, B> Tree<'a, A ,B> {
    fn deep_fetch(&mut self, value: Either<A, B>) -> Result<&mut Self, (&mut Self, Either<A,B>)> {
        match (self, value) {
            (Tree::ABranch(ref mut a, ref v), Either::Left(vv)) if v > &vv => {
                a.deep_fetch(Either::Left(vv))
            }

            (this, _v) => Err((this, _v))
        }
    }
}

error[E0505]: cannot move out of `_` because it is borrowed
  --> src/lib.rs:20:14
   |
14 |     fn deep_fetch(&mut self, value: Either<A, B>) -> Result<&mut Self, (&mut Self, Either<A,B>)> {
   |                   - let's call the lifetime of this reference `'1`
15 |         match (&mut *self, value) {
16 |             (Tree::ABranch(ref mut a, ref v), Either::Left(vv)) if v > &vv => {
   |                            --------- borrow of value occurs here
17 |                 a.deep_fetch(Either::Left(vv))
   |                 ------------------------------ returning this value requires that borrow lasts for `'1`
...
20 |             (this, _v) => Err((this, _v))
   |              ^^^^ move out of value occurs here

[axos88]

It is also odd that if the pattern guard is removed, the compiler complains about mixing by ref and by move bindings.

[axos88]

If Copy is added to A, vv is bound by ref, and dereferenced (copied) when returned, then it compiles or not based on wether a match gueard is present.

[axos88]

Compiles:

impl<'a, A: PartialOrd + Copy, B> Tree<'a, A ,B> {
    fn deep_fetch(&mut self, value: Either<A, B>) -> Result<&mut Self, (&mut Self, Either<A,B>)> {
        match (self, value) {
            (Tree::ABranch(ref mut a, ref v), Either::Left(ref vv)) => 
                a.deep_fetch(Either::Left(*vv)),

            (this, _v) => Err((this, _v))
        }
    }
}

Doesn't:

impl<'a, A: PartialOrd + Copy, B> Tree<'a, A ,B> {
    fn deep_fetch(&mut self, value: Either<A, B>) -> Result<&mut Self, (&mut Self, Either<A,B>)> {
        match (self, value) {
            (Tree::ABranch(ref mut a, ref v), Either::Left(ref vv)) if v == vv => 
                a.deep_fetch(Either::Left(*vv)),

            (this, _v) => Err((this, _v))
        }
    }
}

[axos88]

Even simpler repro:

struct UBranch<'a>(&'a mut UBranch<'a>, u32);

impl<'a> UBranch<'a> {
    fn deep_fetch(&mut self, v2: u32) -> &mut Self {
        match self {
            UBranch(ref mut a, ref v) if v == &v2 => a.deep_fetch(v2),
            x => x
        }
    }
}