drop-checking is more permissive when patterns have guards

[dianne]

When pattern bindings are lowered to MIR, they're dropped in reverse-order of declaration (with some caveats when or-patterns are involved). However, by-ref bindings are created eagerly before anything else if guards are present, so that they can be used in guards (#49870). Because that affects the order in which drops are scheduled, this difference is observable through the drop check (playground link):

struct Struct<T>(T);
impl<T> Drop for Struct<T> {
    fn drop(&mut self) {}
}

fn main() {
    // This is an error: `short1` is dead before `long1` is dropped.
    match (Struct(&&0), 1) {
        (mut long1, ref short1) => long1.0 = &short1,
    }
    // This is OK: `short2`'s storage is live until after `long2`'s drop runs.
    match (Struct(&&0), 1) {
        (mut long2, ref short2) if true => long2.0 = &short2,
        _ => unreachable!(),
    }
}

Related: #142056

cc @rust-lang/lang since if this needs fixing it'll involve changing what programs are allowed. I imagine that needs a T-lang decision?

@rustbot label: +T-compiler +T-lang +A-MIR

[traviscross]

Interesting finding. Thanks @dianne; we'll discuss in an upcoming call.

[dianne]

One extra detail, in case it's relevant: this interacts with #142163 (test in-tree here):

// This depends on the binding modes of the final or-pattern alternatives (see #142163):
let res: &Result<u8, &u8> = &Ok(1);
match (Struct(&&0), res) {
    (mut long3, Ok(short3) | &Err(short3)) if true => long3.0 = &short3,
    //~^ ERROR `short3` does not live long enough
    _ => unreachable!(),
}
match (Struct(&&0), res) {
    (mut long4, &Err(short4) | Ok(short4)) if true => long4.0 = &short4,
    _ => unreachable!(),
}