Confused by diverging type of block tail expression

[ehuss]

I am confused by the following, and I wanted to see if it is a bug or not. The following successfully compiles:

pub fn f() -> ! {
    loop {}
    ();
}

The following without the semicolon does not:

pub fn f() -> ! {
    loop {}
    ()  // ERROR: expected ! found unit type
}

I expected to see this happen:

My understanding is that the type of a block expression without a final expression is (), so I would expect these to both be the same — probably both should error, since I would expect both have the type () as the final expression. If not, can someone explain how the types resolve here?

Note: This was changed in #45880 (I think) where before that both were accepted.

Meta

rustc 1.54.0-nightly (ff2c947 2021-05-25)

[FabianWolff]

I can't give you a definitive answer, but have a look at this comment in the type checking code:

rust/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs

Lines 654 to 660 in a93699f

	// Subtle: if there is no explicit tail expression,
	// that is typically equivalent to a tail expression
	// of `()` -- except if the block diverges. In that
	// case, there is no value supplied from the tail
	// expression (assuming there are no other breaks,
	// this implies that the type of the block will be
	// `!`).

So it seems that this is the intended behavior, i.e. that a missing tail expression is not equivalent to ().

[ehuss]

Ah, it does seem intended, thanks! I'll close this and defer to rust-lang/reference#1033 to get it documented.