dropck seems overconservative when dealing with matches at the end of a block

[sfackler]

#![feature(unsafe_destructor)]
struct A;

impl Drop for A {
    fn drop(&mut self) {}
}

struct B<'a> {
    a: &'a A,
}

#[unsafe_destructor]
impl<'a> Drop for B<'a> {
    fn drop(&mut self) {}
}

impl A {
    fn b(&self) -> B {
        B { a: self }
    }
}

fn main() {
    let a = A;
    match a.b() {
        _ => {}
    }
}

test.rs:25:11: 25:12 error: `a` does not live long enough
test.rs:25     match a.b() {
                     ^
test.rs:23:11: 28:2 note: reference must be valid for the destruction scope surrounding block at 23:10...
test.rs:23 fn main() {
test.rs:24     let a = A;
test.rs:25     match a.b() {
test.rs:26         _ => {}
test.rs:27     }
test.rs:28 }
test.rs:24:14: 28:2 note: ...but borrowed value is only valid for the block suffix following statement 0 at 24:13
test.rs:24     let a = A;
test.rs:25     match a.b() {
test.rs:26         _ => {}
test.rs:27     }
test.rs:28 }
error: aborting due to previous error

Adding anything after the match (like ; or ()) causes the error to go away.

cc @pnkfelix

[sfackler]

This may be a dup of #21114

[pnkfelix]

I think this might be a consequence of our rules for r-value temporaries, where the temporaries in the expression at the end of a block are assigned a lifetime longer than that of the let-bindings within the block itself.

But then again, that answer is not very satisfying without an example of what kind of unsoundness this is supposedly preventing. (I do not have an example ready on hand, but you've given me a place to start.)

[pnkfelix]

cc #22321

[pnkfelix]

also, cc #12032 ;)

[theemathas]

The problem does not require a match

Simpler reproduction code:

#![feature(unsafe_destructor)]

struct Foo;
struct FooRef<'a>(&'a Foo);

impl<'a> FooRef<'a> {
    fn borrow(&self) {}
}

#[unsafe_destructor]
impl<'a> Drop for FooRef<'a> {
    fn drop(&mut self) {}
}

fn main() {
    let x = Foo;
    FooRef(&x).borrow()
}

playpen

The error:

<anon>:17:13: 17:14 error: `x` does not live long enough
<anon>:17     FooRef(&x).borrow()
                      ^
<anon>:15:11: 18:2 note: reference must be valid for the destruction scope surrounding block at 15:10...
<anon>:15 fn main() {
<anon>:16     let x = Foo;
<anon>:17     FooRef(&x).borrow()
<anon>:18 }
<anon>:16:16: 18:2 note: ...but borrowed value is only valid for the block suffix following statement 0 at 16:15
<anon>:16     let x = Foo;
<anon>:17     FooRef(&x).borrow()
<anon>:18 }