Generic type can't be inferred through lambda block

[brson]

type actor<T> = {                                                                                                                                              
    unused: bool                                                                                                                                               
};                                                                                                                                                             

type self<T> = {                                                                                                                                               
    unused: bool                                                                                                                                               
};                                                                                                                                                             

fn act<T:send>(+behavior: sendfn(self<T>)) -> actor<T> {                                                                                                       
    {unused: true}                                                                                                                                             
}                                                                                                                                                              

tag in {                                                                                                                                                       
    preprocess([u8]);                                                                                                                                          
    exit;                                                                                                                                                      
}                                                                                                                                                              

fn mk() -> actor<in> {                                                                                                                                         
    act {|self|                                                                                                                                                
    }                                                                                                                                                          
}                                                                                                                                                              

fn main() {                                                                                                                                                    
}

../src/test/run-pass/block-infer.rs:19:4: 19:7 error: cannot determine a type for this expression
../src/test/run-pass/block-infer.rs:19     act {|self|

Writing act::<in> allows it to work.

[brson]

Writing act::<in> {|self: self<in>| doesn't work either.

[brson]

This doesn't have to do with lambda blocks at all. The following also doesn't work:

type actor<T> = {                                                                                                                                                             
    unused: bool                                                                                                                                                              
};                                                                                                                                                                            

fn act2<T:send>() -> actor<T> {                                                                                                                                               
}                                                                                                                                                                             

enum in {                                                                                                                                                                     
    preprocess([u8]),                                                                                                                                                         
    exit                                                                                                                                                                      
}                                                                                                                                                                             

fn mk() -> actor<in> {                                                                                                                                                        
    act2()                                                                                                                                                                    
}                                                                                                                                                                             

fn main() {                                                                                                                                                                   
}