Type inference of a diverging function is weird

[nodakai]

These two codes compile fine:

fn main() {
    panic!();
    panic!() //  warning: unreachable expression, #[warn(unreachable_code)] on by default
}

fn f<R>() -> R {
    panic!()
}

fn main() {
    println!("hello");
    f()
}

but this does not (note the semicolon after f()):

fn f<R>() -> R {
    panic!()
}

fn main() {
    println!("hello");
    f(); // error: unable to infer enough type information about `_`; type annotations required
}

Though the Rust language reference seems to say there's an (inhabitable) type called the "bottom type," the behavior of rustc is almost as if the bottom type does not really exist in Rust. These examples gave me an impression that a type equation involving a diverging function is simply discarded (otherwise R in the last example should correctly be inferred as the bottom type and there should be no difference between foo(); and panic();,) though I'm aware librustc/middle/infer/combine.rs does consistency check of FnDiverigng...

See also #20105 which was originally filed as a complaint for not allowing this code:

fn g<F, R>(_: F) where F: Fn<(), R> {
}

fn main() {
    g(|| panic!()); // error: unable to infer enough type information about `_`; type annotations required
}

[pnkfelix]

There is no longer a bottom type; it was removed (see issue #14973), replaced with treating a function returning ! as a distinct type-constructor from a function returning some actual type.

It is not clear to me from the issue description whether the problem here is merely one of documentation needing updating, or if there is some more fundamental issue that needs to be addressed.

[nodakai]

@pnkfelix Oh, I didn't know it had already been removed. Then these statements should at least be updated accordingly:

The ! annotation does not denote a type. Rather, the result type of a diverging function is a special type called $\bot$ ("bottom") that unifies with any type. Rust has no syntax for $\bot$.

• http://doc.rust-lang.org/reference.html#diverging-functions

The way I understood your explanation is: "diverging-ness" of a function is specific to each function marked with -> !. That's fine with me (as long as it's clearly explained so in the language reference and we don't call it the "bottom type".)

But then, I think f() in the second example should be rejected by type check because a type variable R remains undetermined.

[arielb1]

@nodakai

The semicolon example not compiling doesn't have anything to do with bottom. f has type for<T> ->T, and there are no constraints on T, but without the semicolon, T is constrained to be ().