Let-else does not drop temporaries at the end of the statement

[camsteffen]

This bug has already been identified but I wanted to open an issue for it.

The following code should print I've been dropped first. (playground)

#![feature(let_else)]

#[derive(Default)]
struct Droppy { inner: u32 }

impl Drop for Droppy {
    fn drop(&mut self) {
        println!("I've been dropped");
    }
}

fn main() {
    let 0 = Droppy::default().inner else { return };
    println!("Should have dropped 👆");
}

I believe there is an unanswered question: Should temporaries be dropped before the else block?

    let 1 = Droppy::default().inner else {
        println!("Should have dropped?????");
        return;
    };

@nikomatsakis said this issue is being investigated at #93628 (comment).

This issue has been assigned to @dingxiangfei2009 via this comment.

[camsteffen]

@rustbot assign @dingxiangfei2009 (I'm pretty sure you are working on this at #98574)

[camsteffen]

Should temporaries be dropped before the else block?

I think they should, since this would be consistent with if/else. (playground)

[est31]

Originally reported in: #93628 (comment)

There are also some variations of it: #93628 (comment)

I've made a little test case for it that doesn't rely on printf but instead can be ran as a run-pass test:

// run-pass
#![feature(let_else)]
#![allow(irrefutable_let_patterns)]

use std::cell::RefCell;

thread_local! {
    pub static LAST_DROPPED: RefCell<u32> = RefCell::new(0);
}

fn reset_last_dropped() {
    LAST_DROPPED.with(|d| {
        *d.borrow_mut() = 0;
    });
}

fn get_last_dropped() -> u32 {
    LAST_DROPPED.with(|d| *d.borrow())
}

struct Droppy(u32);

impl Drop for Droppy {
    fn drop(&mut self) {
        LAST_DROPPED.with(|d| {
            *d.borrow_mut() = self.0;
        });
    }
}

fn test_simple() {
    {
        reset_last_dropped();
        const LINE: u32 = line!();
        let _x = Droppy(LINE).0;
        assert_eq!(get_last_dropped(), LINE);
    }
    {
        reset_last_dropped();
        const LINE: u32 = line!();
        let _x = Droppy(LINE).0 else { return };
        assert_eq!(get_last_dropped(), LINE);
    }
}

fn test_borrow() {
    {
        reset_last_dropped();
        const LINE: u32 = line!();
        let _x = &Droppy(LINE).0;
        assert_eq!(get_last_dropped(), LINE);
    }
    {
        reset_last_dropped();
        const LINE: u32 = line!();
        let _x = &Droppy(LINE).0 else { return };
        assert_eq!(get_last_dropped(), LINE);
    }
}

fn main() {
    test_simple();
    test_borrow();
}

[dingxiangfei2009]

I believe the two tests in test_borrow shall be comparing to 0. The reason is that let _x = &(<expr>).0; actually extends the temporary <expr> to the end of the block at the moment, which is the desired outcome.

cc @est31

[est31]

@dingxiangfei2009 good point. What's important is that both the let-else and let-else free version are doing the same thing. Maybe one can add an additional block around the let _x = ... assert_eq!(...); and then add a second assert_eq to ensure it dropped after the block terminated?

Also note that when I wrote that test I didn't know about compiletest storing/checking the stdout of run-pass tests, so maybe you can simplify it a little by removing the thread local variable as well as the code that manages it, and instead printing to stdout at important places (and adding println!("Visited line {}", line!()) to a few places). Edit: nvm, it's not possible as the .stdout files are for compiler output, not runtime output of the tests.