Raise an error / warning on single path match

[flaper87]

It is possible to write single path matches, which - although they are correct - are useless (unless I'm missing something). We could catch this cases and raise an error or a warning. I'm personally leaning towards an error, I would prefer keeping the code clean from cases like this.

fn main() {
    match Some(1) {
        _ => {println!("Nothing else could happen")}
    }
}

[alexcrichton]

These are not quite useless with the new lifetime changes, these two statements have different semantic meaning:

// this is a compile error
let slot = foo.borrow().get();

// this is valid code
match foo.borrow().get() {
    slot => { /* ... */ }
}

[huonw]

A lint on warn by default (like the other stylistic lints) would be fine for this, no need at all to make it a hard error.

(FWIW, using match is nicer in macros too: can handle structs, enums and tuples uniformly. E.g. deriving does it.)

[Aatch]

As a more general statement, I think that trying to prevent "pointless" code is a non-starter since there is an enormous amount of such code that can be written. There will always be degenerate cases and I don't think we even need a lint. This is unlikely to represent some bug or lead to bugs.

Bad style is not necessarily indicative of bad code. If you want to keep your code clean from silly constructs, then don't write them!

[flaper87]

oh mmh, I meant to target this bug just when using _ cases and I agree a lint would be enough.

It looks like this bug is a dup of #3482

[flaper87]

@Aatch I don't fully agree and the fact that good and bad style exists is the reason we have lints and style checkers. The whole point is help people to avoid things like this and to avoid writing awful code too.

I agree bad style is not indicative of bad code. However, in cases like this it's certainly a waste.