`single_match` should lint exhaustive `match` on standard types

[yeputons]

Summary

After #8282 was closed via #8322 (in Rust 1.60) the example below is no longer linting.

The original rationale was that Clippy should not lint matches on user-defined enums which explicitly list all possible options. Otherwise extending the enum later would break the original code, but not the fixed one, which may be unexpected for the author.

However, there is little reason to believe that standard types like std::option::Option will be extended in the future. I suggest that they're exempt from this check. Another example is std::result::Result. Of course, that does not help with user-defined Result-like types like in the anyhow crate, but still.

Lint Name

single_match

Reproducer

I tried this code:

fn main() {
    let x = Some(10);
    match x {
        Some(_) => println!("hi!"),
        None => {},
    };
}

I expected to see this happen:

Like in Rust 1.58:

warning: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
 --> a.rs:3:5
  |
3 | /     match x {
4 | |         Some(x) => println!("hi! {}", x),
5 | |         None => {},
6 | |     };
  | |_____^ help: try this: `if let Some(x) = x { println!("hi! {}", x) }`
  |
  = note: `#[warn(clippy::single_match)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match

warning: 1 warning emitted

Instead, this happened:

No output

Version

Clippy 0.1.63 (2022-05-31 e094492)

[botahamec]

@rustbot claim

[botahamec]

So I think I got this working, but I noticed an interesting side effect with the [`single_match_else`] lint:

error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> src\doc.rs:640:34
    |
640 |                   let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code) {
    |  __________________________________^
641 | |                     Ok(p) => p,
642 | |                     Err(errs) => {
643 | |                         drop(errs);
644 | |                         return false;
645 | |                     },
646 | |                 };
    | |_________________^
    |
    = note: `-D clippy::single-match-else` implied by `-D clippy::pedantic`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
help: try this
    |
640 ~                 let mut parser = if let Ok(p) = maybe_new_parser_from_source_str(&sess, filename, code) { p } else {
641 +                     drop(errs);
642 +                     return false;
643 ~                 };
    |

I'm not sure if this is something we want or not. I know this is a pedantic lint though, so let me know if I'm being silly.

[botahamec]

Actually, that fix would result in a compiler error, so yeah, that's definitely not what we want. I'll try fixing it

[yeputons]

Actually, that fix would result in a compiler error, so yeah, that's definitely not what we want. I'll try fixing it

Seems weird to me. These two lines of code look exactly the same, would you mind showing the compiler error? Probably some lifetime issues, if I were to guess.

[botahamec]

@yeptuons The problem is that the Err arm creates a variable called errs, which is being used in the block

I don't have the clippy source code on my laptop, but in the playground it looks something like this:

error[[E0425]](https://doc.rust-lang.org/stable/error-index.html#E0425): cannot find value `errs` in this scope
 --> src/main.rs:3:14
    |
641 |         drop(errs);
    |              ^^^^ not found in this scope