Last uses aren't moved into closures by default

[brson]

This fails:

fn main() {                                                                                                                                                    
    let x = ~1;                                                                                                                                                
    let x_in_parent = ptr::addr_of(*x) as uint;                                                                                                                
    let f = fn@() -> uint {                                                                                                                                    
        ptr::addr_of(*x) as uint                                                                                                                               
    };                                                                                                                                                         
    let x_in_child = f();                                                                                                                                      
    assert x_in_parent == x_in_child;                                                                                                                          
} 

Rewriting it with a capture clause works:

fn main() {                                                                                                                                                    
    let x = ~1;                                                                                                                                                
    let x_in_parent = ptr::addr_of(*x) as uint;                                                                                                                
    let f = fn@[move x]() -> uint {                                                                                                                                    
        ptr::addr_of(*x) as uint                                                                                                                               
    };                                                                                                                                                         
    let x_in_child = f();                                                                                                                                      
    assert x_in_parent == x_in_child;                                                                                                                          
}      

This is a bit surprising and makes spawn not do the expected thing when written with the convenient block closure syntax. For this reason core::task uses fn~ closures with explicit capture clauses.

[nikomatsakis]

It occurs to me that the last use analysis might be doing the right thing (I don't know), but the trans code certainly is not. Right now, trans::closure decides whether to copy or move based purely on the capture clause. It shouldn't be a big deal to modify it to consult the last use table, but I'm not sure where to look (e.g., would the last use of the variable be the fn expr itself in this case?)

[nikomatsakis]

@marijnh, you'd know best (see previous comment)

[marijnh]

I initially punted on this because the act of closing over a variable doesn't have a node id associated with it the way regular mentions of a variable have. I agree it should be implemented. Assigning to myself.