mismatched types: expected fn&() -> ! but found fn&() -> _|_

[ben0x539]

This fails:

fn foo(f: fn() -> !) {}

fn main() {
    foo(|| {fail });
}

with

foo.rs:4:7: 4:18 error: mismatched types: expected `fn&() -> !` but found `fn&() -> _|_` (expected non-returning function, found non-returning function)
foo.rs:4     foo(|| {fail });
                ^~~~~~~~~~~

While this works:

fn foo(f: fn() -> !) {}

fn main() {
    foo(fn() -> ! { fail });
}

I don't know what is going on there but I feel the first snippet should work too.

[nikomatsakis]

Agreed. The current type checker has two ways to represent the same thing, which I think is what is leading to this problem. I've been thinking we oughta' fix that for some time, this bug gives me a good justification. =)

[nikomatsakis]

Specifically: fn types have a return_style (or something like that) and there is the bottom type. I don't see why we need both.

[catamorphism]

The reason we have both is that _|_ isn't a first-class type at the moment. That is, you can only mention it in the return type of a function, as !; you can't declare a local with type _|_, or a field in a data structure.

[catamorphism]

The most conservative fix here would be a way to infer the return_style for closures.

[nikomatsakis]

This should be fixed.