Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::match_wild_err_arm: `Err(_)` matches all errors
What it meansChecks for arm which matches all errors with Err(_) and take drastic actions like panic!. It is in the pedantic group and off by default.
What you see
warning: `Err(_)` matches all errors --> main.rs:6:5 | 6 | Err(_) => panic!("err"), | ^^^^^^ | = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#match_wild_err_arm = note: `-W clippy::match-wild-err-arm` implied by `-W clippy::pedantic`
Real output of Clippy 0.1.99 (Rust 1.99) on the example below. Names and line numbers in yours will differ.
Does it matter?
It is generally a bad practice, similar to catching all exceptions in java with catch(Exception)
Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.
How to fix it
Clippy does not fix this one automatically. Change the code by hand:
Flagged
let x: Result<i32, &str> = Ok(3);
match x {
Ok(_) => println!("ok"),
Err(_) => panic!("err"),
}
Turn it off, or on
It is off by default. To use it, set it to warn or deny:
Whole crate (Cargo.toml)
[lints.clippy]
match_wild_err_arm = "warn"In code
#![warn(clippy::match_wild_err_arm)]One run
cargo clippy -- -W clippy::match-wild-err-armThe [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.
Clippy's own documentation
What it does
Checks for arm which matches all errors with Err(_)
and take drastic actions like panic!.
Why is this bad?
It is generally a bad practice, similar to
catching all exceptions in java with catch(Exception)
Example
let x: Result<i32, &str> = Ok(3);
match x {
Ok(_) => println!("ok"),
Err(_) => panic!("err"),
}
From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.
Related lints
- too_many_linesChecks for functions with a large amount of lines
- missing_errors_docChecks the doc comments of publicly visible functions that return a Result type and warns if there is no # Errors section
- must_use_candidateChecks for public functions that have no #[must_use] attribute, but return something not already marked must-use, have no mutable arg and mutate no statics
- map_unwrap_orChecks for usage of option.map(_).unwrap_or(_) or option.map(_).unwrap_or_else(_) or result.map(_).unwrap_or_else(_)
- match_boolChecks for matches where match expression is a bool
- match_same_armsChecks for match with identical arm bodies. Note: Does not lint on wildcards if the non_exhaustive_omitted_patterns_lint feature is enabled and disallowed
- match_wildcard_for_single_variantsChecks for wildcard enum matches for a single variant
- maybe_infinite_iterChecks for iteration that may be infinite
- mismatching_type_param_order`Foo` has a similarly named generic type parameter `B` in its declaration, but in a different order
All 847 Clippy lints · Rust compiler errors · Cargo.toml checker
Up next
Related lintclippy::too_many_linesChecks for functions with a large amount of linesRead it next →Did this answer your question?