diff --git a/CHANGELOG.md b/CHANGELOG.md index 671450a120d..8fdc1487bcc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -364,6 +364,7 @@ All notable changes to this project will be documented in this file. [`match_overlapping_arm`]: https://github.com/Manishearth/rust-clippy/wiki#match_overlapping_arm [`match_ref_pats`]: https://github.com/Manishearth/rust-clippy/wiki#match_ref_pats [`match_same_arms`]: https://github.com/Manishearth/rust-clippy/wiki#match_same_arms +[`match_wild_err_arm`]: https://github.com/Manishearth/rust-clippy/wiki#match_wild_err_arm [`mem_forget`]: https://github.com/Manishearth/rust-clippy/wiki#mem_forget [`min_max`]: https://github.com/Manishearth/rust-clippy/wiki#min_max [`misrefactored_assign_op`]: https://github.com/Manishearth/rust-clippy/wiki#misrefactored_assign_op diff --git a/README.md b/README.md index cfc9d06b495..3660937262a 100644 --- a/README.md +++ b/README.md @@ -180,7 +180,7 @@ transparently: ## Lints -There are 187 lints included in this crate: +There are 188 lints included in this crate: name | default | triggers on -----------------------------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------- @@ -271,6 +271,7 @@ name [match_overlapping_arm](https://github.com/Manishearth/rust-clippy/wiki#match_overlapping_arm) | warn | a match with overlapping arms [match_ref_pats](https://github.com/Manishearth/rust-clippy/wiki#match_ref_pats) | warn | a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression [match_same_arms](https://github.com/Manishearth/rust-clippy/wiki#match_same_arms) | warn | `match` with identical arm bodies +[match_wild_err_arm](https://github.com/Manishearth/rust-clippy/wiki#match_wild_err_arm) | warn | a match with `Err(_)` arm and take drastic actions [mem_forget](https://github.com/Manishearth/rust-clippy/wiki#mem_forget) | allow | `mem::forget` usage on `Drop` types, likely to cause memory leaks [min_max](https://github.com/Manishearth/rust-clippy/wiki#min_max) | warn | `min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant [misrefactored_assign_op](https://github.com/Manishearth/rust-clippy/wiki#misrefactored_assign_op) | warn | having a variable on both sides of an assign op diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 4b7b72f0c79..de5945df81f 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -413,6 +413,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { matches::MATCH_BOOL, matches::MATCH_OVERLAPPING_ARM, matches::MATCH_REF_PATS, + matches::MATCH_WILD_ERR_ARM, matches::SINGLE_MATCH, methods::CHARS_NEXT_CMP, methods::CLONE_DOUBLE_REF, diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 9cb557ba646..66b55c48455 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -10,7 +10,8 @@ use std::collections::Bound; use syntax::ast::LitKind; use syntax::codemap::Span; use utils::paths; -use utils::{match_type, snippet, span_note_and_lint, span_lint_and_then, in_external_macro, expr_block}; +use utils::{match_type, snippet, span_note_and_lint, span_lint_and_then, in_external_macro, expr_block, walk_ptrs_ty, + is_expn_of}; use utils::sugg::Sugg; /// **What it does:** Checks for matches with a single arm where an `if let` @@ -121,6 +122,28 @@ declare_lint! { "a match with overlapping arms" } +/// **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, just like +/// catching all exceptions in java with `catch(Exception)` +/// +/// **Known problems:** None. +/// +/// **Example:** +/// ```rust +/// let x : Result(i32, &str) = Ok(3); +/// match x { +/// Ok(_) => println!("ok"), +/// Err(_) => panic!("err"), +/// } +/// ``` +declare_lint! { + pub MATCH_WILD_ERR_ARM, + Warn, + "a match with `Err(_)` arm and take drastic actions" +} + #[allow(missing_copy_implementations)] pub struct MatchPass; @@ -130,7 +153,8 @@ impl LintPass for MatchPass { MATCH_REF_PATS, MATCH_BOOL, SINGLE_MATCH_ELSE, - MATCH_OVERLAPPING_ARM) + MATCH_OVERLAPPING_ARM, + MATCH_WILD_ERR_ARM) } } @@ -143,6 +167,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MatchPass { check_single_match(cx, ex, arms, expr); check_match_bool(cx, ex, arms, expr); check_overlapping_arms(cx, ex, arms); + check_wild_err_arm(cx, ex, arms); } if let ExprMatch(ref ex, ref arms, source) = expr.node { check_match_ref_pats(cx, ex, arms, source, expr); @@ -322,6 +347,45 @@ fn check_overlapping_arms(cx: &LateContext, ex: &Expr, arms: &[Arm]) { } } +fn check_wild_err_arm(cx: &LateContext, ex: &Expr, arms: &[Arm]) { + let ex_ty = walk_ptrs_ty(cx.tables.expr_ty(ex)); + if match_type(cx, ex_ty, &paths::RESULT) { + for arm in arms { + if let PatKind::TupleStruct(ref path, ref inner, _) = arm.pats[0].node { + let path_str = print::to_string(print::NO_ANN, |s| s.print_qpath(path, false)); + if_let_chain! {[ + path_str == "Err", + inner.iter().any(|pat| pat.node == PatKind::Wild), + let ExprBlock(ref block) = arm.body.node, + is_panic_block(cx, block) + ], { + // `Err(_)` arm with `panic!` found + span_note_and_lint(cx, + MATCH_WILD_ERR_ARM, + arm.pats[0].span, + "Err(_) will match all errors, maybe not a good idea", + arm.pats[0].span, + "to remove this warning, match each error seperately \ + or use unreachable macro"); + }} + } + } + } +} + +// If the block contains only a `panic!` macro (as expression or statement) +fn is_panic_block(cx: &LateContext, block: &Block) -> bool { + match (&block.expr, block.stmts.len(), block.stmts.first()) { + (&Some(ref exp), 0, _) => { + is_expn_of(cx, exp.span, "panic").is_some() && is_expn_of(cx, exp.span, "unreachable").is_none() + }, + (&None, 1, Some(stmt)) => { + is_expn_of(cx, stmt.span, "panic").is_some() && is_expn_of(cx, stmt.span, "unreachable").is_none() + }, + _ => false, + } +} + fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], source: MatchSource, expr: &Expr) { if has_only_ref_pats(arms) { if let ExprAddrOf(Mutability::MutImmutable, ref inner) = ex.node { diff --git a/tests/ui/matches.rs b/tests/ui/matches.rs index 00faed26818..46a99293a35 100644 --- a/tests/ui/matches.rs +++ b/tests/ui/matches.rs @@ -283,5 +283,53 @@ fn overlapping() { } } +fn match_wild_err_arm() { + let x: Result = Ok(3); + + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => panic!("err") + } + + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => {panic!()} + } + + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => {panic!();} + } + + // allowed when not with `panic!` block + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => println!("err") + } + + // allowed when used with `unreachable!` + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => {unreachable!()} + } + + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => unreachable!() + } + + match x { + Ok(3) => println!("ok"), + Ok(_) => println!("ok"), + Err(_) => {unreachable!();} + } +} + fn main() { } diff --git a/tests/ui/matches.stderr b/tests/ui/matches.stderr index bc254cb0bcb..bc8584b8587 100644 --- a/tests/ui/matches.stderr +++ b/tests/ui/matches.stderr @@ -388,5 +388,37 @@ note: overlaps with this 275 | 0 ... 11 => println!("0 ... 11"), | ^^^^^^^^ -error: aborting due to 23 previous errors +error: Err(_) will match all errors, maybe not a good idea + --> $DIR/matches.rs:292:9 + | +292 | Err(_) => panic!("err") + | ^^^^^^ + | + = note: #[deny(match_wild_err_arm)] implied by #[deny(clippy)] +note: lint level defined here + --> $DIR/matches.rs:5:9 + | +5 | #![deny(clippy)] + | ^^^^^^ + = note: to remove this warning, match each error seperately or use unreachable macro + +error: Err(_) will match all errors, maybe not a good idea + --> $DIR/matches.rs:298:9 + | +298 | Err(_) => {panic!()} + | ^^^^^^ + | + = note: #[deny(match_wild_err_arm)] implied by #[deny(clippy)] + = note: to remove this warning, match each error seperately or use unreachable macro + +error: Err(_) will match all errors, maybe not a good idea + --> $DIR/matches.rs:304:9 + | +304 | Err(_) => {panic!();} + | ^^^^^^ + | + = note: #[deny(match_wild_err_arm)] implied by #[deny(clippy)] + = note: to remove this warning, match each error seperately or use unreachable macro + +error: aborting due to 26 previous errors