Why does "if return" compile in Rust?

Question

I found some strange Rust code in dtolnay's mind-bending Rust quiz. Apparently, this is a valid Rust program (playground):

fn main() {
    if return { print!("1") } {}
}

According to the Rust docs:

The syntax of an if expression is a condition operand, followed by a consequent block, any number of else if conditions and blocks, and an optional trailing else block. The condition operands must have the boolean type.

To me it means that the return statement must somehow evaluate as a boolean, otherwise the code wouldn't compile. But that explanation seems outlandish, and I suspect there must be something else going on.

So why does if return compile at all?

Answer 1

It is for the same reason the following code compiles:

fn create_string() -> String {
    std::process::exit(0);
}

The body of the function above does never return a String value, however, since std::process::exit() is a divergent function (i.e., its return type is !), it results in valid code: The control flow will never reach the point where a String value has to be produced.

The same applies to panic!(). The following code, which replaces your return with panic!(), also compiles for the same reason:

fn main() {
    if panic!() { print!("1") } {}
}

Answer 2

You're looking for the never type, which is the result of the return expression.

And while it compiles, it does generate a warning:

warning: unreachable block in `if` or `while` expression
  |
2 |     if return { print!("1") } {}
  |        ---------------------- ^^ unreachable block in `if` or `while` expression
  |        |
  |        any code following this expression is unreachable