Warn when a match can be made more specific

[jyn514]

Consider the following code (playground):

enum E {
    A(usize),
    B(usize),
}

impl E {
    fn as_usize(&self) -> usize {
        match *self {
            E::A(a) => a,
            E::B(b) => b,
        }
    }
}

fn main() {
    let _ = E::B(1); // ignore warn(dead_code) on the B variant
    let e = E::A(1);
    match e {
        E::A(x) => x,
        x => x.as_usize(),
    };
}

This code gives no warnings. However, the as_usize() method is entirely useless, because the match can be rewritten to be more specific:

    match e {
        E::A(x) => x,
        E::B(x) => x,
    };

The compiler should give a warning in such a case.

[jyn514]

To be clear, the warning should be a suggestion to change x => x.as_usize() to E::B(x) => _. The warning about as_usize() (dead_code) will show up automatically after that.

[Mark-Simulacrum]

Hm, I think this likely wants to by allow by default and likely even a clippy warning. It can make sense to handle one case and provide for a general code path for all other cases, even if there is (currently) only one other case. This could also arise if other cases are conditionally available via cfg, for example.

[Nadrieril]

That would require cross-function analysis of patterns, plus I don't see how to generalize it beyond this simple example to some notion of what is or isn't useful. Pretty confident this is beyond the kind of things we want to lint in the compiler, feel free to reopen if I'm making a mistake.