Closures can't be declared as diverging functions

[brson]

This looks inferrable.

fn main() {                                                                                                                                                                   
    let early_error: fn@(str) -> !  = {|msg|                                                                                                                                  
        fail                                                                                                                                                                  
    };                                                                                                                                                                        
}

../src/test/run-pass/infer-closure.rs:2:38: 4:5 warning: unable to infer kind of closure, defaulting to block
../src/test/run-pass/infer-closure.rs:2     let early_error: fn@(str) -> !  = {|msg|
../src/test/run-pass/infer-closure.rs:3         fail
../src/test/run-pass/infer-closure.rs:4     };
../src/test/run-pass/infer-closure.rs:2:38: 4:5 error: mismatched types: expected `fn@(++str) -> !` but found `fn&(<T2>) -> <T3>` (types differ)
../src/test/run-pass/infer-closure.rs:2     let early_error: fn@(str) -> !  = {|msg|
../src/test/run-pass/infer-closure.rs:3         fail
../src/test/run-pass/infer-closure.rs:4     };
../src/test/run-pass/infer-closure.rs:2:38: 4:5 error: cannot determine a type for this expression
../src/test/run-pass/infer-closure.rs:2     let early_error: fn@(str) -> !  = {|msg|
../src/test/run-pass/infer-closure.rs:3         fail
../src/test/run-pass/infer-closure.rs:4     };
error: aborting due to previous errors

[catamorphism]

In HEAD, I get a different error, but it's still wrong:

./src/test/run-pass/issue-1516.rs:1:47: 1:60 error: mismatched types: expected `fn@(str) -> !` but found `fn@(_|_) -> _|_` (return-by-value function found where non-returning function was expected)
./src/test/run-pass/issue-1516.rs:1 fn main() {  let early_error: fn@(str) -> !  = {|msg| fail }; }

This should compile.

[catamorphism]

Changed the title to reflect what seems to be the problem now.

[catamorphism]

I disagree with my past self about whether this should compile. Right now, in the AST, there's only one way to introduce a diverging function: by writing a ! in place of its return type. Return styles are never inferred. Making closure potentially-diverging would require significant changes. It's possible, but it would add more outside-of-the-type-system baggage, if you know what I mean.

I'm going to close this, but @brson or anyone else, please file an RFC if you feel strongly about it :-)