Improved exhaustive integer matching

[fintelia]

During the implementation/stabilization process for exhaustive integer matching, there was a request to support matches of the form:

fn foo(i: u8) {
    match i & 0x3 {
        0 => {}
        1 => {}
        2 => {}
        3 => {}
    }
}

It seems that this should be feasible to implement, if the exact structure is constrained enough. Specifically the addition would be useful even if the match expression had to be a single bitwise and between an unsigned integer literal/constant and an expression, and even if the constant had to be exactly one less than a power of two. In the compiler, this should then be a matter of recognizing the pattern and using an adjusted upper bound for the exhaustive match instead of std::{u8, u16, ...}::MAX.

I've been finding this exact pattern coming up frequently in a crate I've been working on.

[leonardo-m]

This could be handled with a more general value range analysis in the front-end.

[varkor]

I think this should be moved to the RFCs repository. I certainly wouldn't feel comfortable special-casing certain forms of expression like this, and even a limited form of value analysis is a complex feature. This has come up in the past, but I can't find references to other issues right now.

[oli-obk]

I agree, this needs an RFC. I think the relation to generic value arguments and thus integer subtypes is something that should be part of this discussion, too.