`let` and `if let` have different closure capture behaviors

[theemathas]

I tried this code:

#![expect(dead_code, irrefutable_let_patterns)]

struct Thing(String, String);

fn foo(x: Thing) {
    let closure = || {
        if let Thing(_a, _) = x {}
    };
    println!("{}", size_of_val(&closure));
}

fn bar(x: Thing) {
    let closure = || {
        match x {
            Thing(_a, _) => {}
        }
    };
    println!("{}", size_of_val(&closure));
}

fn baz(x: Thing) {
    let closure = || {
        let Thing(_a, _) = x;
    };
    println!("{}", size_of_val(&closure));
}

fn main() {
    foo(Thing(String::from("a"), String::from("b")));
    bar(Thing(String::from("a"), String::from("b")));
    baz(Thing(String::from("a"), String::from("b")));
}

I expected the three printed numbers to be the same. Instead, in editions 2021 and 2024, the code prints 48 then 24 then 24.

It seems that if let causes the entire value of x to be captured, but let and match only capture the relevant field. This seems inconsistent.

cc @Nadrieril @meithecatte

Meta

Reproducible on the playground with version 1.96.0-nightly (2026-03-12 3102493c71626b5912d1) and also on version 1.94.0.

However, testing on Godbolt with version 1.93.0 (which is before #138961), it prints 48 then 48 then 24.

[meithecatte]

I'll try to look into this in the next week or two. For now, a short comment: is there a particular reason you're checking size_of_val? Is this observable in drop order, for example?

[theemathas]

@meithecatte I used size_of_val because it was, to me, the clearest demonstration that the captures are different. I've written demonstrations of the differences observable via the borrow checker and via drop order below.

Differences via the borrow checker

#![expect(unused, irrefutable_let_patterns)]

struct Thing(String, String);

// errors
fn foo(x: Thing) {
    let closure = || {
        if let Thing(_a, _) = x {}
    };
    let _b = x.1;
}

// compiles
fn bar(x: Thing) {
    let closure = || {
        match x {
            Thing(_a, _) => {}
        }
    };
    let _b = x.1;
}

// compiles
fn baz(x: Thing) {
    let closure = || {
        let Thing(_a, _) = x;
    };
    let _b = x.1;
}

error[E0382]: use of moved value: `x.1`
  --> src/lib.rs:10:14
   |
 6 | fn foo(x: Thing) {
   |        - move occurs because `x` has type `Thing`, which does not implement the `Copy` trait
 7 |     let closure = || {
   |                   -- value moved into closure here
 8 |         if let Thing(_a, _) = x {}
   |                               - variable moved due to use in closure
 9 |     };
10 |     let _b = x.1;
   |              ^^^ value used here after move

For more information about this error, try `rustc --explain E0382`.

Differences via drop order

#![expect(unused, irrefutable_let_patterns)]

struct Thing(Inner, Inner);
struct Inner(&'static str);
impl Drop for Inner {
    fn drop(&mut self) {
        println!("{}", self.0);
    }
}

fn foo(x: Thing) {
    let closure = || {
        if let Thing(_a, _) = x {}
    };
    drop(closure);
    println!("before end");
}

fn bar(x: Thing) {
    let closure = || {
        match x {
            Thing(_a, _) => {}
        }
    };
    drop(closure);
    println!("before end");
}

fn baz(x: Thing) {
    let closure = || {
        let Thing(_a, _) = x;
    };
    drop(closure);
    println!("before end");
}

fn main() {
    foo(Thing(Inner("a"), Inner("b")));
    bar(Thing(Inner("a"), Inner("b")));
    baz(Thing(Inner("a"), Inner("b")));
}

a
b
before end
a
before end
b
a
before end
b

[Embers-of-the-Fire]

It seems that if let causes the entire value of x to be captured, but let and match only capture the relevant field. This seems inconsistent.

Deassembly result

core::ptr::drop_in_place<example::bar::{{closure}}>::hf4bbc377c7557212:
        push    rax
        mov     qword ptr [rsp], rdi
        call    qword ptr [rip + core::ptr::drop_in_place<alloc::string::String>::h80aba8a808c08991@GOTPCREL]
        pop     rax
        ret

core::ptr::drop_in_place<example::baz::{{closure}}>::h44c749f765cdacbf:
        push    rax
        mov     qword ptr [rsp], rdi
        call    qword ptr [rip + core::ptr::drop_in_place<alloc::string::String>::h80aba8a808c08991@GOTPCREL]
        pop     rax
        ret

core::ptr::drop_in_place<example::foo::{{closure}}>::hc4b817d2f4d89a6a:
        push    rax
        mov     qword ptr [rsp], rdi
        call    qword ptr [rip + core::ptr::drop_in_place<example::Thing>::hda5de758ddbcb884@GOTPCREL]
        pop     rax
        ret

And size_of_val also evaluates to 48, 24, 24.

[Embers-of-the-Fire]

And also MIR here:

fn foo::{closure#0}(_1: {closure@main.rs:7:19: 7:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    scope 1 {
        debug _a => _2;
        let _2: std::string::String;
    }

    bb0: {
        _2 = move ((_1.0: Thing).0: std::string::String);
        drop(_2) -> [return: bb1, unwind: bb4];
    }
    <...>
}

fn bar::{closure#0}(_1: {closure@main.rs:15:19: 15:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    let _2: std::string::String;
    scope 1 {
        debug _a => _2;
    }

    bb0: {
        _2 = move ((_1.0: Thing).0: std::string::String);
        drop(_2) -> [return: bb1, unwind: bb4];
    }
    <...>
}

No obvious difference :(.

Full MIR output

// WARNING: This output format is intended for human consumers only
// and is subject to change without notice. Knock yourself out.
// HINT: See also -Z dump-mir for MIR at specific points during compilation.
fn foo(_1: Thing) -> () {
    debug x => _1;
    let mut _0: ();
    let _2: {closure@main.rs:7:19: 7:21};
    let _3: ();
    let mut _4: std::fmt::Arguments<'_>;
    let mut _6: &usize;
    let _7: usize;
    let _8: &{closure@main.rs:7:19: 7:21};
    let mut _10: core::fmt::rt::Argument<'_>;
    let mut _11: &[u8; 4];
    let _12: &[core::fmt::rt::Argument<'_>; 1];
    let mut _13: &usize;
    scope 1 {
        debug closure => _2;
        let _5: (&usize,);
        scope 2 {
            debug args => _5;
            let _9: [core::fmt::rt::Argument<'_>; 1];
            scope 3 {
                debug args => _9;
            }
        }
    }

    bb0: {
        _2 = {closure@main.rs:7:19: 7:21} { x: move _1 };
        _8 = &_2;
        _7 = std::mem::size_of_val::<{closure@main.rs:7:19: 7:21}>(copy _8) -> [return: bb1, unwind: bb6];
    }

    bb1: {
        _6 = &_7;
        _5 = (move _6,);
        _13 = copy (_5.0: &usize);
        _10 = core::fmt::rt::Argument::<'_>::new_display::<usize>(copy _13) -> [return: bb2, unwind: bb6];
    }

    bb2: {
        _9 = [move _10];
        _11 = const b"\xc0\x01\n\x00";
        _12 = &_9;
        _4 = Arguments::<'_>::new::<4, 1>(move _11, copy _12) -> [return: bb3, unwind: bb6];
    }

    bb3: {
        _3 = _print(move _4) -> [return: bb4, unwind: bb6];
    }

    bb4: {
        drop(_2) -> [return: bb5, unwind continue];
    }

    bb5: {
        return;
    }

    bb6 (cleanup): {
        drop(_2) -> [return: bb7, unwind terminate(cleanup)];
    }

    bb7 (cleanup): {
        resume;
    }
}

alloc1 (size: 4, align: 1) {
    c0 01 0a 00                                     │ ....
}

fn foo::{closure#0}(_1: {closure@main.rs:7:19: 7:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    scope 1 {
        debug _a => _2;
        let _2: std::string::String;
    }

    bb0: {
        _2 = move ((_1.0: Thing).0: std::string::String);
        drop(_2) -> [return: bb1, unwind: bb4];
    }

    bb1: {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb3, unwind continue];
    }

    bb2 (cleanup): {
        resume;
    }

    bb3: {
        return;
    }

    bb4 (cleanup): {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb2, unwind terminate(cleanup)];
    }
}

fn bar(_1: Thing) -> () {
    debug x => _1;
    let mut _0: ();
    let _2: {closure@main.rs:15:19: 15:21};
    let _3: ();
    let mut _4: std::fmt::Arguments<'_>;
    let mut _6: &usize;
    let _7: usize;
    let _8: &{closure@main.rs:15:19: 15:21};
    let mut _10: core::fmt::rt::Argument<'_>;
    let mut _11: &[u8; 4];
    let _12: &[core::fmt::rt::Argument<'_>; 1];
    let mut _13: &usize;
    scope 1 {
        debug closure => _2;
        let _5: (&usize,);
        scope 2 {
            debug args => _5;
            let _9: [core::fmt::rt::Argument<'_>; 1];
            scope 3 {
                debug args => _9;
            }
        }
    }

    bb0: {
        _2 = {closure@main.rs:15:19: 15:21} { x: move _1 };
        _8 = &_2;
        _7 = std::mem::size_of_val::<{closure@main.rs:15:19: 15:21}>(copy _8) -> [return: bb1, unwind: bb6];
    }

    bb1: {
        _6 = &_7;
        _5 = (move _6,);
        _13 = copy (_5.0: &usize);
        _10 = core::fmt::rt::Argument::<'_>::new_display::<usize>(copy _13) -> [return: bb2, unwind: bb6];
    }

    bb2: {
        _9 = [move _10];
        _11 = const b"\xc0\x01\n\x00";
        _12 = &_9;
        _4 = Arguments::<'_>::new::<4, 1>(move _11, copy _12) -> [return: bb3, unwind: bb6];
    }

    bb3: {
        _3 = _print(move _4) -> [return: bb4, unwind: bb6];
    }

    bb4: {
        drop(_2) -> [return: bb5, unwind continue];
    }

    bb5: {
        return;
    }

    bb6 (cleanup): {
        drop(_2) -> [return: bb7, unwind terminate(cleanup)];
    }

    bb7 (cleanup): {
        resume;
    }
}

alloc1 (size: 4, align: 1) {
    c0 01 0a 00                                     │ ....
}

fn bar::{closure#0}(_1: {closure@main.rs:15:19: 15:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    let _2: std::string::String;
    scope 1 {
        debug _a => _2;
    }

    bb0: {
        _2 = move ((_1.0: Thing).0: std::string::String);
        drop(_2) -> [return: bb1, unwind: bb4];
    }

    bb1: {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb3, unwind continue];
    }

    bb2 (cleanup): {
        resume;
    }

    bb3: {
        return;
    }

    bb4 (cleanup): {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb2, unwind terminate(cleanup)];
    }
}

fn baz(_1: Thing) -> () {
    debug x => _1;
    let mut _0: ();
    let _2: {closure@main.rs:25:19: 25:21};
    let _3: ();
    let mut _4: std::fmt::Arguments<'_>;
    let mut _6: &usize;
    let _7: usize;
    let _8: &{closure@main.rs:25:19: 25:21};
    let mut _10: core::fmt::rt::Argument<'_>;
    let mut _11: &[u8; 4];
    let _12: &[core::fmt::rt::Argument<'_>; 1];
    let mut _13: &usize;
    scope 1 {
        debug closure => _2;
        let _5: (&usize,);
        scope 2 {
            debug args => _5;
            let _9: [core::fmt::rt::Argument<'_>; 1];
            scope 3 {
                debug args => _9;
            }
        }
    }

    bb0: {
        _2 = {closure@main.rs:25:19: 25:21} { x: move _1 };
        _8 = &_2;
        _7 = std::mem::size_of_val::<{closure@main.rs:25:19: 25:21}>(copy _8) -> [return: bb1, unwind: bb6];
    }

    bb1: {
        _6 = &_7;
        _5 = (move _6,);
        _13 = copy (_5.0: &usize);
        _10 = core::fmt::rt::Argument::<'_>::new_display::<usize>(copy _13) -> [return: bb2, unwind: bb6];
    }

    bb2: {
        _9 = [move _10];
        _11 = const b"\xc0\x01\n\x00";
        _12 = &_9;
        _4 = Arguments::<'_>::new::<4, 1>(move _11, copy _12) -> [return: bb3, unwind: bb6];
    }

    bb3: {
        _3 = _print(move _4) -> [return: bb4, unwind: bb6];
    }

    bb4: {
        drop(_2) -> [return: bb5, unwind continue];
    }

    bb5: {
        return;
    }

    bb6 (cleanup): {
        drop(_2) -> [return: bb7, unwind terminate(cleanup)];
    }

    bb7 (cleanup): {
        resume;
    }
}

alloc1 (size: 4, align: 1) {
    c0 01 0a 00                                     │ ....
}

fn baz::{closure#0}(_1: {closure@main.rs:25:19: 25:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    let _2: std::string::String;
    scope 1 {
        debug _a => _2;
    }

    bb0: {
        _2 = move ((_1.0: Thing).0: std::string::String);
        drop(_2) -> [return: bb1, unwind: bb4];
    }

    bb1: {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb3, unwind continue];
    }

    bb2 (cleanup): {
        resume;
    }

    bb3: {
        return;
    }

    bb4 (cleanup): {
        drop(((_1.0: Thing).1: std::string::String)) -> [return: bb2, unwind terminate(cleanup)];
    }
}

fn main() -> () {
    let mut _0: ();
    let _1: ();
    let mut _2: Thing;
    let mut _3: std::string::String;
    let mut _4: &str;
    let mut _5: std::string::String;
    let mut _6: &str;
    let _7: ();
    let mut _8: Thing;
    let mut _9: std::string::String;
    let mut _10: &str;
    let mut _11: std::string::String;
    let mut _12: &str;
    let _13: ();
    let mut _14: Thing;
    let mut _15: std::string::String;
    let mut _16: &str;
    let mut _17: std::string::String;
    let mut _18: &str;

    bb0: {
        _4 = const "1";
        _3 = <&str as Into<String>>::into(move _4) -> [return: bb1, unwind continue];
    }

    bb1: {
        _6 = const "2";
        _5 = <&str as Into<String>>::into(move _6) -> [return: bb2, unwind: bb12];
    }

    bb2: {
        _2 = Thing(move _3, move _5);
        _1 = foo(move _2) -> [return: bb3, unwind continue];
    }

    bb3: {
        _10 = const "1";
        _9 = <&str as Into<String>>::into(move _10) -> [return: bb4, unwind continue];
    }

    bb4: {
        _12 = const "2";
        _11 = <&str as Into<String>>::into(move _12) -> [return: bb5, unwind: bb11];
    }

    bb5: {
        _8 = Thing(move _9, move _11);
        _7 = bar(move _8) -> [return: bb6, unwind continue];
    }

    bb6: {
        _16 = const "1";
        _15 = <&str as Into<String>>::into(move _16) -> [return: bb7, unwind continue];
    }

    bb7: {
        _18 = const "2";
        _17 = <&str as Into<String>>::into(move _18) -> [return: bb8, unwind: bb10];
    }

    bb8: {
        _14 = Thing(move _15, move _17);
        _13 = baz(move _14) -> [return: bb9, unwind continue];
    }

    bb9: {
        return;
    }

    bb10 (cleanup): {
        drop(_15) -> [return: bb13, unwind terminate(cleanup)];
    }

    bb11 (cleanup): {
        drop(_9) -> [return: bb13, unwind terminate(cleanup)];
    }

    bb12 (cleanup): {
        drop(_3) -> [return: bb13, unwind terminate(cleanup)];
    }

    bb13 (cleanup): {
        resume;
    }
}

alloc3 (size: 1, align: 1) {
    32                                              │ 2
}

alloc2 (size: 1, align: 1) {
    31                                              │ 1
}

fn Thing(_1: String, _2: String) -> Thing {
    let mut _0: Thing;

    bb0: {
        _0 = Thing(move _1, move _2);
        return;
    }
}

// MIR FOR CTFE
fn Thing(_1: String, _2: String) -> Thing {
    let mut _0: Thing;

    bb0: {
        _0 = Thing(move _1, move _2);
        return;
    }
}

[Embers-of-the-Fire]

Well eventually found here :)

TL;DR if let implicitly suggests a else branch, while match encounters an exhaustive match.

- falseEdge -> [real:bb2, imaginary: bb1];
+ FakeRead(ForMatchedPlace(None), (_1.0: Thing));
+ unreachable;

MIR:

fn foo::{closure#0}(_1: {closure@main.rs:7:19: 7:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    scope 1 {
        debug _a => _2;
        let _2: std::string::String;
    }

    bb0: {
        PlaceMention((_1.0: Thing));
        falseEdge -> [real: bb2, imaginary: bb1];
    }

    bb1: {
        goto -> bb3;
    }

    bb2: {
        StorageLive(_2);
        _2 = move ((_1.0: Thing).0: std::string::String);
        _0 = const ();
        drop(_2) -> [return: bb4, unwind: bb7];
    }
    <...>

fn bar::{closure#0}(_1: {closure@main.rs:15:19: 15:21}) -> () {
    debug x => (_1.0: Thing);
    let mut _0: ();
    let _2: std::string::String;
    scope 1 {
        debug _a => _2;
    }

    bb0: {
        PlaceMention((_1.0: Thing));
        StorageLive(_2);
        _2 = move ((_1.0: Thing).0: std::string::String);
        _0 = const ();
        drop(_2) -> [return: bb2, unwind: bb5];
    }

    bb1: {
        FakeRead(ForMatchedPlace(None), (_1.0: Thing));
        unreachable;
    }

    bb2: {
        StorageDead(_2);
        goto -> bb3;
    }
    <...>

[Nadrieril]

@Embers-of-the-Fire closure capture is done on HIR, so the outcome in MIR is not that relevant. The question is just to fix closure capture analysis to be consistent.

[Embers-of-the-Fire]

@rustbot claim

[rustbot]

Error: Parsing assign command in comment failed: ...' assign' | error: specify user to assign to at >| ''...

Please file an issue on GitHub at triagebot if there's a problem with this bot, or reach out on #triagebot on Zulip.