2018-05-30 08:15:50 +00:00
|
|
|
use crate::utils::{match_qpath, paths, snippet, span_lint_and_then};
|
2019-12-03 23:16:03 +00:00
|
|
|
use rustc::declare_lint_pass;
|
2018-12-29 15:04:45 +00:00
|
|
|
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
|
|
|
use rustc_errors::Applicability;
|
2020-01-06 16:39:50 +00:00
|
|
|
use rustc_hir::*;
|
2019-12-03 23:16:03 +00:00
|
|
|
use rustc_session::declare_tool_lint;
|
2018-12-29 15:04:45 +00:00
|
|
|
use syntax::ast::LitKind;
|
2016-10-29 16:56:12 +00:00
|
|
|
|
2018-03-28 13:24:26 +00:00
|
|
|
declare_clippy_lint! {
|
2019-03-05 16:50:33 +00:00
|
|
|
/// **What it does:** Lint for redundant pattern matching over `Result` or
|
|
|
|
/// `Option`
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** It's more concise and clear to just use the proper
|
|
|
|
/// utility function
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// if let Ok(_) = Ok::<i32, i32>(42) {}
|
|
|
|
/// if let Err(_) = Err::<i32, i32>(42) {}
|
|
|
|
/// if let None = None::<()> {}
|
|
|
|
/// if let Some(_) = Some(42) {}
|
|
|
|
/// match Ok::<i32, i32>(42) {
|
|
|
|
/// Ok(_) => true,
|
|
|
|
/// Err(_) => false,
|
|
|
|
/// };
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// The more idiomatic use would be:
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// if Ok::<i32, i32>(42).is_ok() {}
|
|
|
|
/// if Err::<i32, i32>(42).is_err() {}
|
|
|
|
/// if None::<()>.is_none() {}
|
|
|
|
/// if Some(42).is_some() {}
|
|
|
|
/// Ok::<i32, i32>(42).is_ok();
|
|
|
|
/// ```
|
2018-10-10 15:13:53 +00:00
|
|
|
pub REDUNDANT_PATTERN_MATCHING,
|
2018-03-28 13:24:26 +00:00
|
|
|
style,
|
2016-10-29 16:56:12 +00:00
|
|
|
"use the proper utility function avoiding an `if let`"
|
|
|
|
}
|
|
|
|
|
2019-04-08 20:43:55 +00:00
|
|
|
declare_lint_pass!(RedundantPatternMatching => [REDUNDANT_PATTERN_MATCHING]);
|
2016-10-29 16:56:12 +00:00
|
|
|
|
2019-04-08 20:43:55 +00:00
|
|
|
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantPatternMatching {
|
2019-12-27 07:12:26 +00:00
|
|
|
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
|
|
|
|
if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
|
2018-10-07 13:36:42 +00:00
|
|
|
match match_source {
|
|
|
|
MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
|
2019-09-25 17:01:21 +00:00
|
|
|
MatchSource::IfLetDesugar { contains_else_clause } => {
|
|
|
|
find_sugg_for_if_let(cx, expr, op, arms, *contains_else_clause)
|
|
|
|
},
|
2018-10-07 13:36:42 +00:00
|
|
|
_ => return,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-10-29 16:56:12 +00:00
|
|
|
|
2019-09-25 17:01:21 +00:00
|
|
|
fn find_sugg_for_if_let<'a, 'tcx>(
|
|
|
|
cx: &LateContext<'a, 'tcx>,
|
2019-12-27 07:12:26 +00:00
|
|
|
expr: &'tcx Expr<'_>,
|
|
|
|
op: &Expr<'_>,
|
|
|
|
arms: &[Arm<'_>],
|
2019-09-25 17:01:21 +00:00
|
|
|
has_else: bool,
|
|
|
|
) {
|
2019-09-27 15:16:06 +00:00
|
|
|
let good_method = match arms[0].pat.kind {
|
2019-09-25 19:00:17 +00:00
|
|
|
PatKind::TupleStruct(ref path, ref patterns, _) if patterns.len() == 1 => {
|
2019-09-27 15:16:06 +00:00
|
|
|
if let PatKind::Wild = patterns[0].kind {
|
2019-09-25 19:00:17 +00:00
|
|
|
if match_qpath(path, &paths::RESULT_OK) {
|
|
|
|
"is_ok()"
|
|
|
|
} else if match_qpath(path, &paths::RESULT_ERR) {
|
|
|
|
"is_err()"
|
|
|
|
} else if match_qpath(path, &paths::OPTION_SOME) {
|
|
|
|
"is_some()"
|
2018-10-07 13:36:42 +00:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
2019-09-25 19:00:17 +00:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
},
|
2016-10-29 16:56:12 +00:00
|
|
|
|
2019-09-25 19:00:17 +00:00
|
|
|
PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE) => "is_none()",
|
2016-10-29 16:56:12 +00:00
|
|
|
|
2019-09-25 19:00:17 +00:00
|
|
|
_ => return,
|
|
|
|
};
|
2018-10-07 13:36:42 +00:00
|
|
|
|
2019-09-25 17:01:21 +00:00
|
|
|
let maybe_semi = if has_else { "" } else { ";" };
|
|
|
|
|
2019-09-25 19:00:17 +00:00
|
|
|
span_lint_and_then(
|
|
|
|
cx,
|
|
|
|
REDUNDANT_PATTERN_MATCHING,
|
|
|
|
arms[0].pat.span,
|
|
|
|
&format!("redundant pattern matching, consider using `{}`", good_method),
|
|
|
|
|db| {
|
|
|
|
let span = expr.span.to(op.span);
|
|
|
|
db.span_suggestion(
|
|
|
|
span,
|
|
|
|
"try this",
|
2019-09-25 17:01:21 +00:00
|
|
|
format!("{}.{}{}", snippet(cx, op.span, "_"), good_method, maybe_semi),
|
2019-09-25 19:00:17 +00:00
|
|
|
Applicability::MaybeIncorrect, // snippet
|
|
|
|
);
|
|
|
|
},
|
|
|
|
);
|
2018-10-07 13:36:42 +00:00
|
|
|
}
|
|
|
|
|
2019-12-27 07:12:26 +00:00
|
|
|
fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
|
2018-10-07 13:36:42 +00:00
|
|
|
if arms.len() == 2 {
|
2019-09-27 15:16:06 +00:00
|
|
|
let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
|
2018-10-07 13:36:42 +00:00
|
|
|
|
|
|
|
let found_good_method = match node_pair {
|
|
|
|
(
|
2018-11-02 11:12:14 +00:00
|
|
|
PatKind::TupleStruct(ref path_left, ref patterns_left, _),
|
2018-11-27 20:14:15 +00:00
|
|
|
PatKind::TupleStruct(ref path_right, ref patterns_right, _),
|
2018-11-02 11:12:14 +00:00
|
|
|
) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
|
2019-09-27 15:16:06 +00:00
|
|
|
if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
|
2018-10-07 13:36:42 +00:00
|
|
|
find_good_method_for_match(
|
|
|
|
arms,
|
|
|
|
path_left,
|
|
|
|
path_right,
|
2019-05-17 21:53:54 +00:00
|
|
|
&paths::RESULT_OK,
|
|
|
|
&paths::RESULT_ERR,
|
2018-10-07 13:36:42 +00:00
|
|
|
"is_ok()",
|
2018-11-27 20:14:15 +00:00
|
|
|
"is_err()",
|
2018-10-07 13:36:42 +00:00
|
|
|
)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
},
|
2018-11-27 20:14:15 +00:00
|
|
|
(PatKind::TupleStruct(ref path_left, ref patterns, _), PatKind::Path(ref path_right))
|
|
|
|
| (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, ref patterns, _))
|
|
|
|
if patterns.len() == 1 =>
|
|
|
|
{
|
2019-09-27 15:16:06 +00:00
|
|
|
if let PatKind::Wild = patterns[0].kind {
|
2018-10-07 13:36:42 +00:00
|
|
|
find_good_method_for_match(
|
|
|
|
arms,
|
|
|
|
path_left,
|
|
|
|
path_right,
|
2019-05-17 21:53:54 +00:00
|
|
|
&paths::OPTION_SOME,
|
|
|
|
&paths::OPTION_NONE,
|
2018-10-07 13:36:42 +00:00
|
|
|
"is_some()",
|
2018-11-27 20:14:15 +00:00
|
|
|
"is_none()",
|
2018-10-07 13:36:42 +00:00
|
|
|
)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => None,
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(good_method) = found_good_method {
|
|
|
|
span_lint_and_then(
|
|
|
|
cx,
|
2018-10-10 15:13:53 +00:00
|
|
|
REDUNDANT_PATTERN_MATCHING,
|
2018-10-07 13:36:42 +00:00
|
|
|
expr.span,
|
|
|
|
&format!("redundant pattern matching, consider using `{}`", good_method),
|
|
|
|
|db| {
|
|
|
|
let span = expr.span.to(op.span);
|
2019-01-27 12:33:56 +00:00
|
|
|
db.span_suggestion(
|
2018-10-07 13:36:42 +00:00
|
|
|
span,
|
|
|
|
"try this",
|
|
|
|
format!("{}.{}", snippet(cx, op.span, "_"), good_method),
|
2019-08-07 18:34:23 +00:00
|
|
|
Applicability::MaybeIncorrect, // snippet
|
2018-10-07 13:36:42 +00:00
|
|
|
);
|
|
|
|
},
|
|
|
|
);
|
2016-10-29 16:56:12 +00:00
|
|
|
}
|
2018-10-07 13:36:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn find_good_method_for_match<'a>(
|
2019-12-27 07:12:26 +00:00
|
|
|
arms: &[Arm<'_>],
|
2019-12-30 04:02:10 +00:00
|
|
|
path_left: &QPath<'_>,
|
|
|
|
path_right: &QPath<'_>,
|
2019-05-17 21:53:54 +00:00
|
|
|
expected_left: &[&str],
|
|
|
|
expected_right: &[&str],
|
2018-10-07 13:36:42 +00:00
|
|
|
should_be_left: &'a str,
|
2018-11-27 20:14:15 +00:00
|
|
|
should_be_right: &'a str,
|
2018-10-07 13:36:42 +00:00
|
|
|
) -> Option<&'a str> {
|
|
|
|
let body_node_pair = if match_qpath(path_left, expected_left) && match_qpath(path_right, expected_right) {
|
2019-09-27 15:16:06 +00:00
|
|
|
(&(*arms[0].body).kind, &(*arms[1].body).kind)
|
2018-10-07 13:36:42 +00:00
|
|
|
} else if match_qpath(path_right, expected_left) && match_qpath(path_left, expected_right) {
|
2019-09-27 15:16:06 +00:00
|
|
|
(&(*arms[1].body).kind, &(*arms[0].body).kind)
|
2018-10-07 13:36:42 +00:00
|
|
|
} else {
|
|
|
|
return None;
|
|
|
|
};
|
|
|
|
|
|
|
|
match body_node_pair {
|
2018-11-27 20:14:15 +00:00
|
|
|
(ExprKind::Lit(ref lit_left), ExprKind::Lit(ref lit_right)) => match (&lit_left.node, &lit_right.node) {
|
|
|
|
(LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
|
|
|
|
(LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
|
|
|
|
_ => None,
|
2018-10-07 13:36:42 +00:00
|
|
|
},
|
|
|
|
_ => None,
|
2016-10-29 16:56:12 +00:00
|
|
|
}
|
|
|
|
}
|