non-exhaustive match for masked integer

[crawford]

I have the following program which fails to compile:

fn main() {
    println!("{}", match 123 & 0x01 {
        0x00 => "Hello",
        0x01 => "World",
    });
}

with the following error:

foo.rs:2:20: 5:6 error: non-exhaustive patterns: `_` not covered [E0004]
foo.rs:2     println!("{}", match 123 & 0x01 {
foo.rs:3         0x00 => "Hello",
foo.rs:4         0x01 => "World",
foo.rs:5     });
<std macros>:2:25: 2:56 note: in this expansion of format_args!
<std macros>:3:1: 3:54 note: in this expansion of print! (defined in <std macros>)
foo.rs:2:5: 5:8 note: in this expansion of println! (defined in <std macros>)
foo.rs:2:20: 5:6 help: run `rustc --explain E0004` to see a detailed explanation
error: aborting due to previous error

It would be really nice if the compiler could recognize that foo & 0x01 can only result in 0x00 or 0x01, making the match exhaustive.

This looks related to #12483.

[arielb1]

Exhaustiveness analysis cares only about types. The type of your masked integer is still i32.

[crawford]

Yes, but i32 is guaranteed to be only one of two values in this case. Does it make sense for the exhaustiveness analysis to look at more than just the types? Or does it make sense for 123 & 0x01 to result in an internal subtype of i32 (an i1 in this case)?

[arielb1]

@crawford

No and there is no plan for making Rust's analyses to be based on runtime properties other than types.

[arielb1]

Of course, if we ever implement dependent types or something, we would integrate it with the exhaustiveness checker, but until then, we won't be working in this direction.