Last use analysis doesn't doesn't move out results of anonymous functions

[brson]

Both of these r's generate errors about copying noncopyable values, but they should be moves.

fn apply<T>(s: str, f: fn(str) -> T) -> T {                                                                                                                                   
    g(s) {|v|                                                                                                                                                                 
        let r = f(v);                                                                                                                                                         
        r                                                                                                                                                                     
    }                                                                                                                                                                         
}                                                                                                                                                                             

fn apply2<T>(s: str, f: fn(str) -> T) -> T {                                                                                                                                  
    g(s, fn&(v: str) -> T {                                                                                                                                                   
        let r = f(v);                                                                                                                                                         
        r                                                                                                                                                                     
    })                                                                                                                                                                        
}                                                                                                                                                                             

fn g<T>(s: str, f: fn(str) -> T) -> T {                                                                                                                                       
    f(s)                                                                                                                                                                      
}                                                                                                                                                                             

fn main() {                                                                                                                                                                   
}