miri doesn't drop values moved into closures with `let _ = x`

[oli-obk]

The following code works fine if drop(x) is used instead of let _ = x. The closure function generated contains just a _0 = () and a return. Trans probably does some magic, but I haven't been able to locate it.

struct Foo<'a>(&'a mut bool);

impl<'a> Drop for Foo<'a> {
    fn drop(&mut self) {
        *self.0 = true;
    }
}

fn f<T: FnOnce()>(t: T) {
    t()
}

fn main() {
    let mut ran_drop = false;
    {
        let x = Foo(&mut ran_drop);
        let x = move || { let _ = x; };
        f(x);
    }
    assert!(ran_drop);
}

[solson]

@oli-obk Weird... the closure body ought to explicitly drop the closure environment argument in MIR.

[solson]

I figured out the problem here.

move || { let _ = x; }; never by-value uses any of its captures, so it's a closure whose inherent signature is fn(&self). When we call it through FnOnce::call_once (in f(x)), it has to use a shim.

Our shim acts like the following function, where self is the closure type and body is the closure fn:

fn call_once_shim(self) {
    body(&self)
    // NOTE: self should be dropped at the end of scope, but Miri doesn't do it.
}

As you can see in the shim code I linked above, we do add this self to a vec of temporaries to be freed when the stack frame is freed, but we don't ever execute the drop glue for it. (It's freed here.)

[solson]

Note that if you force the closure to by-value use a separate value to remove Miri's use of the shim, then the closure's drop glue is properly called, as in this test I added.

EDIT: Actually I think in that case the closure body itself will drop x, since it's a fn(self) signature closure, responsible for freeing the by-value self argument which contains the capture x.

EDIT 2: ...which I guess means the closure body executes the closure's drop glue, so I wasn't wrong, just imprecise. :P

[oli-obk]

Great analysis! I'll take this bug, drop code is my fault anyway ;)

[solson]

It would also be fixed once @arielb1's rewrite of these shims into explicit MIR bodies is done in rustc, but I'm not sure about the timeline on that. If it's hard to fix in Miri we can wait, otherwise it's fine to do it now.

EDIT: relevant rustc PR is here.