144 lines
7.2 KiB
Rust
144 lines
7.2 KiB
Rust
use rustc::lint::*;
|
|
use rustc_front::hir::*;
|
|
use rustc::middle::ty;
|
|
use syntax::ast::Lit_::LitBool;
|
|
|
|
use utils::{snippet, span_lint, span_help_and_lint, in_external_macro, expr_block};
|
|
|
|
declare_lint!(pub SINGLE_MATCH, Warn,
|
|
"a match statement with a single nontrivial arm (i.e, where the other arm \
|
|
is `_ => {}`) is used; recommends `if let` instead");
|
|
declare_lint!(pub MATCH_REF_PATS, Warn,
|
|
"a match has all arms prefixed with `&`; the match expression can be \
|
|
dereferenced instead");
|
|
declare_lint!(pub MATCH_BOOL, Warn,
|
|
"a match on boolean expression; recommends `if..else` block instead");
|
|
|
|
#[allow(missing_copy_implementations)]
|
|
pub struct MatchPass;
|
|
|
|
impl LintPass for MatchPass {
|
|
fn get_lints(&self) -> LintArray {
|
|
lint_array!(SINGLE_MATCH, MATCH_REF_PATS, MATCH_BOOL)
|
|
}
|
|
}
|
|
|
|
impl LateLintPass for MatchPass {
|
|
fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
|
|
if let ExprMatch(ref ex, ref arms, MatchSource::Normal) = expr.node {
|
|
if in_external_macro(cx, expr.span) { return; }
|
|
|
|
// check preconditions for SINGLE_MATCH
|
|
// only two arms
|
|
if arms.len() == 2 &&
|
|
// both of the arms have a single pattern and no guard
|
|
arms[0].pats.len() == 1 && arms[0].guard.is_none() &&
|
|
arms[1].pats.len() == 1 && arms[1].guard.is_none() &&
|
|
// and the second pattern is a `_` wildcard: this is not strictly necessary,
|
|
// since the exhaustiveness check will ensure the last one is a catch-all,
|
|
// but in some cases, an explicit match is preferred to catch situations
|
|
// when an enum is extended, so we don't consider these cases
|
|
arms[1].pats[0].node == PatWild(PatWildSingle) &&
|
|
// finally, we don't want any content in the second arm (unit or empty block)
|
|
is_unit_expr(&arms[1].body)
|
|
{
|
|
span_help_and_lint(cx, SINGLE_MATCH, expr.span,
|
|
"you seem to be trying to use match for destructuring a \
|
|
single pattern. Consider using `if let`",
|
|
&format!("try\nif let {} = {} {}",
|
|
snippet(cx, arms[0].pats[0].span, ".."),
|
|
snippet(cx, ex.span, ".."),
|
|
expr_block(cx, &arms[0].body, None, "..")));
|
|
}
|
|
|
|
// check preconditions for MATCH_REF_PATS
|
|
if has_only_ref_pats(arms) {
|
|
if let ExprAddrOf(Mutability::MutImmutable, ref inner) = ex.node {
|
|
span_lint(cx, MATCH_REF_PATS, expr.span, &format!(
|
|
"you don't need to add `&` to both the expression to match \
|
|
and the patterns: use `match {} {{ ...`", snippet(cx, inner.span, "..")));
|
|
} else {
|
|
span_lint(cx, MATCH_REF_PATS, expr.span, &format!(
|
|
"instead of prefixing all patterns with `&`, you can dereference the \
|
|
expression to match: `match *{} {{ ...`", snippet(cx, ex.span, "..")));
|
|
}
|
|
}
|
|
|
|
// check preconditions for MATCH_BOOL
|
|
// type of expression == bool
|
|
if cx.tcx.expr_ty(ex).sty == ty::TyBool {
|
|
if arms.len() == 2 && arms[0].pats.len() == 1 { // no guards
|
|
let exprs = if let PatLit(ref arm_bool) = arms[0].pats[0].node {
|
|
if let ExprLit(ref lit) = arm_bool.node {
|
|
if let LitBool(val) = lit.node {
|
|
if val {
|
|
Some((&*arms[0].body, &*arms[1].body))
|
|
} else {
|
|
Some((&*arms[1].body, &*arms[0].body))
|
|
}
|
|
} else { None }
|
|
} else { None }
|
|
} else { None };
|
|
if let Some((ref true_expr, ref false_expr)) = exprs {
|
|
if !is_unit_expr(true_expr) {
|
|
if !is_unit_expr(false_expr) {
|
|
span_help_and_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block:",
|
|
&format!("try\nif {} {} else {}",
|
|
snippet(cx, ex.span, "b"),
|
|
expr_block(cx, true_expr, None, ".."),
|
|
expr_block(cx, false_expr, None, "..")));
|
|
} else {
|
|
span_help_and_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block:",
|
|
&format!("try\nif {} {}",
|
|
snippet(cx, ex.span, "b"),
|
|
expr_block(cx, true_expr, None, "..")));
|
|
}
|
|
} else if !is_unit_expr(false_expr) {
|
|
span_help_and_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block:",
|
|
&format!("try\nif !{} {}",
|
|
snippet(cx, ex.span, "b"),
|
|
expr_block(cx, false_expr, None, "..")));
|
|
} else {
|
|
span_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block");
|
|
}
|
|
} else {
|
|
span_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block");
|
|
}
|
|
} else {
|
|
span_lint(cx, MATCH_BOOL, expr.span,
|
|
"you seem to be trying to match on a boolean expression. \
|
|
Consider using an if..else block");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_unit_expr(expr: &Expr) -> bool {
|
|
match expr.node {
|
|
ExprTup(ref v) if v.is_empty() => true,
|
|
ExprBlock(ref b) if b.stmts.is_empty() && b.expr.is_none() => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn has_only_ref_pats(arms: &[Arm]) -> bool {
|
|
let mapped = arms.iter().flat_map(|a| &a.pats).map(|p| match p.node {
|
|
PatRegion(..) => Some(true), // &-patterns
|
|
PatWild(..) => Some(false), // an "anything" wildcard is also fine
|
|
_ => None, // any other pattern is not fine
|
|
}).collect::<Option<Vec<bool>>>();
|
|
// look for Some(v) where there's at least one true element
|
|
mapped.map_or(false, |v| v.iter().any(|el| *el))
|
|
}
|