Uplifting captures to by-move is too conservative

[nagisa]

In code like this there’s some algorithm in place which makes the capture of variable x by-value rather than the default by-ref:

fn main(){
    let x = Some(vec![0]);
    (||{ 
        drop(x); // takes `x` by-value, therefore closure captures `x` by-value as well.
    })()
}

However, x will not be captured by-value when the x is matched on in a moving manner:

fn main() {
    let x = Some(vec![0]);
    (|| {
        match x { // cannot move out of captured outer variable in an `Fn` closure [E0507]
            Some(x) => {}, // attempting to move value to here
            None => {}
        }
    })()
}

It would be nice if the algorithm handled more cases (including one presented here).

[solson]

A similar test case without enums:

fn main(){
    let x = (vec![0],);
    (|| { 
        drop(x); // takes `x` by-value, therefore closure captures `x` by-value as well.
    })()
}

fn main(){
    let x = (vec![0],);
    (|| { 
        drop(x.0); // cannot move out of captured outer variable in an `Fn` closure [E0507]
    })()
}

Basically, as far as I can tell, the capture inference doesn't see drop(x.0) as a by-value use of x and so captures x by-ref. I think this is the same problem in @nagisa's examples, where matching x and extracting the contents in the Some case is also like accessing a subfield. (It's like (x as Some).0 in MIR-like syntax.)

[nagisa]

cc #30046? Might be a duplicate.

[Mark-Simulacrum]

Closing as duplicate of #30046.