Returning the result of reborrowing in pattern matching causes compilation error

[WaffleLapkin]

This fails to compile on latest stable (and nightly) (playground):

fn f(a: &mut [u8]) -> &mut [u8] {
    match a {
        [b @ ..] if false => b,
        aa => aa,
    }
}

error[E0505]: cannot move out of `a` because it is borrowed
 --> src/main.rs:6:9
  |
3 |   fn f(a: &mut [u8]) -> &mut [u8] {
  |           - let's call the lifetime of this reference `'1`
4 | /     match a {
5 | |         [b @ ..] if false => b,
  | |          ------ borrow of `a[..]` occurs here
6 | |         aa => aa,
  | |         ^^ move out of `a` occurs here
7 | |     }
  | |_____- returning this value requires that `a[..]` is borrowed for `'1`

This seems like a bug in rustc, especially considering that any of the following are compiling just fine (playground):

fn f1(a: &mut [u8]) -> &mut [u8] {
    match a {
        b if false => b,
        aa => aa,
    }
}

fn f2(a: &mut [u8]) -> &mut [u8] {
    match a {
        b if false => b,
        [aa @ ..] => aa,
    }
}

fn f3(a: &mut [u8]) -> &mut [u8] {
    match a {
        [..] if false => a,
        [aa @ ..] => aa,
    }
}

---

Originally I've found this bug with code like this (playground):

fn original(a: &mut [u8]) -> &mut [u8] {
    match a {
        [.., b] if false => core::slice::from_mut(b),
        [aa @ ..] => aa,
        //^ cannot borrow `a[..]` as mutable more than once at a time
    }
}

Meta

rustc

• stable: 1.57.0
• nightly: 1.59.0-nightly (2021-12-13 8f117a77d0880ed59afc)

[WaffleLapkin]

@rustbot label +C-bug +A-slice +A-slice-patterns +A-borrow-checker +D-confusing

[estebank]

Triage: no change.

[Nadrieril]

This seems independent from slice patterns (play):

fn main() {}

fn f(a: &mut u8) -> &mut u8 {
    match a {
        &mut ref mut b if true => b,
        aa => unreachable!(), // ERROR: cannot move out of `a` because it is borrowed
    }
}

[Nadrieril]

Here's my analysis. Case A compiles:

fn main() {}
fn f(a: &mut u8) -> &mut u8 {
    match a {
        &mut ref mut b => b,
        aa => unreachable!(),
    }
}

Case B doesn't:

fn main() {}
fn f(a: &mut u8) -> &mut u8 {
    match a {
        &mut ref mut b if true => b,
        aa => unreachable!(), // ERROR: cannot move out of `a` because it is borrowed
    }
}

There shouldn't be a difference between these two, because match lowering adds fake edges in the MIR to ensure borrowck doesn't learn too much about unreachable branches and such. The reason there's a difference is that we add fake edges after we determine which branch to take but before establishing any bindings. With the guard there is now an edge from the first branch to the second after we establish the b mutable borrow.

Then, the known NLL limitation makes a borrowed for the whole function even in other branches, which is where the error comes from. I'm tempted to blame the NLL limitation here, because imo match lowering is doing something sensible.

[WaffleLapkin]

@Nadrieril what's the difference with the following example then?

fn main() {}
fn f(a: &mut u8) -> &mut u8 {
    match a {
        b if true => b,
        aa => unreachable!(),
    }
}

Wouldn't this be subject be the same borrowck limitation? Why reborrowing changes anything?