Unreachable statement is not checked for const assertions

[TheNeikos]

I tried this code:

use core::marker::PhantomData;

struct Check<T: Accept>(PhantomData<T>);
impl<T: Accept> Check<T> {
    const CHECK: () = assert!(T::STREAM);
}

trait Accept {
    type Foo;
    const STREAM: bool = false;
}

impl Accept for u64 {
    type Foo = u64;
    const STREAM: bool = false;
}

struct Foo;

impl Foo {
    fn only_stream<T: Accept>(self, t: T)
    {
        let _ = Check::<T>::CHECK;
        println!("Is stream!");
    }
}

fn get_foo() -> Foo {
    todo!()
}

fn main() {
    let foo: Foo = todo!(); // Comment these out to make it fail to compile
    foo.only_stream(5u64);  // this line as well
    
    let foo = get_foo();
    foo.only_stream(5u64);
}

I expected to see this happen: I expected the second line in main to cause a compilation failure. But due to the todo this does not happen.

Instead, this happened: It compiles, but warns about unused code.

Meta

rustc --version --verbose:

Stable 1.69

this also happens on nightly 1.71.0-nightly (2023-05-03 473f916d836cc662c5bd)

Playground link: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=c3caf7f91c27f00067173e0e83406a24

Found together with @matthiasbeyer

[TheNeikos]

While this is not high impact problem for working code, since it never progresses past the todo!, this does come up when testing. Which is also how we found out about this. Notably for compile_fail tests.

The fact that the location of the todo! is important, seems to me that this may not be expected.

[matthiasbeyer]

this does come up when testing. Which is also how we found out about this. Notably for compile_fail tests.

doctests, that is.

[oli-obk]

It is somewhat intended. Avoiding looking into dead code is done on purpose, so that if cfg(windows) { f::<i32>() } else { g() } doesn't instantiate the generic function f for i32 on windows, because that may end up being expensive or even wrong (failing to compile on non-windows, but compiling on windows).

That said, this all is done rather opportunistically and there is some desire to change something in this space that may then also affect what we do in dead code.

[TheNeikos]

I understand. It is a rather unfortunate cross section of not wanting to instantiate a complete system in a doctest to get a valid T while also having compile_fail on it.

Putting the todo into a seperate function works at least here. Is there maybe a way to mark something as 'this will fail at runtime' but will not otherwise impede the computed data flow? (And thus not trigger the dead code analysis?

[oli-obk]

Is there maybe a way to mark something as 'this will fail at runtime' but will not otherwise impede the computed data flow? (And thus not trigger the dead code analysis?

Thinking about this I feel like todo!() and unimplemented!() should serve that purpose (in contrast to panic! or unreachable!()) as these signal that any dead code around them is only dead code for now. I don't have a good idea for how to teach rustc about that though.