False-positive with the unreachable code lint

[bjorn3]

Given the following code: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=67b068c7dded060fd71f7e5a5ca91278

#![allow(deprecated, invalid_value)]

enum Void {}

fn main() {
    if false {
        unsafe { std::mem::uninitialized::<Void>(); }
    }
    
    println!();
}

The current output is:

warning: unreachable expression
  --> src/main.rs:10:5
   |
7  |         unsafe { std::mem::uninitialized::<Void>(); }
   |                  --------------------------------- any code following this expression is unreachable
...
10 |     println!();
   |     ^^^^^^^^^^^ unreachable expression
   |
   = note: `#[warn(unreachable_code)]` on by default
note: this expression has type `Void`, which is uninhabited
  --> src/main.rs:7:18
   |
7  |         unsafe { std::mem::uninitialized::<Void>(); }
   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = note: this warning originates in the macro `$crate::format_args` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `playground` (bin "playground") generated 1 warning

I expected no lint to trigger as the println!() is actually reachable. This problem doesn't occur for panic!().

[pierwill]

@rustbot claim

[pierwill]

Hi @bjorn3! Can you elaborate a little on what makes println!() reachable here?

[bjorn3]

println!() is reachable as the std::mem::uninitialized::<Void>(); is never executed due to if false {}.

[pierwill]

@rustbot release-assignment

[tabokie]

I've located the issue to be in the liveness check:

rust/compiler/rustc_passes/src/liveness.rs

Lines 875 to 896 in 56694b0

	hir::ExprKind::If(ref cond, ref then, ref else_opt) => {
	//
	// (cond)
	// |
	// v
	// (expr)
	// / \
	// | |
	// v v
	// (then)(els)
	// | |
	// v v
	// ( succ )
	//
	let else_ln =
	self.propagate_through_opt_expr(else_opt.as_ref().map(|e| &**e), succ);
	let then_ln = self.propagate_through_expr(&then, succ);
	let ln = self.live_node(expr.hir_id, expr.span);
	self.init_from_succ(ln, else_ln);
	self.merge_from_succ(ln, then_ln);
	self.propagate_through_expr(&cond, ln)
	}

Here a diverge point sits inside a conditional block, but this information is lost when calling propagate_through_expr, which then calls warn_about_unreachable.

A simple fix for this would be skipping the check for conditional neighbors. But that will actually bring out another false negative case:

#![allow(deprecated, invalid_value)]

enum Void {}

fn main() {
    let b = false;
    // should warn:
    // any code following this `match` expression is unreachable, as all arms diverge
    match b {
        false => unsafe { std::mem::uninitialized::<Void>(); }
        _ => unreachable!(),
    }
    println!();
}

I'm quite new to the compiler code, but this case seems difficult to fix because the exhaustiveness check takes place in a earlier(?) pass which doesn't have the complete type information.