-use crate::utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_and_lint};
+use crate::utils::{get_parent_expr, higher, if_sequence, same_tys, snippet, span_lint_and_then, span_note_and_lint};
use crate::utils::{SpanlessEq, SpanlessHash};
use rustc::hir::*;
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
use rustc::ty::Ty;
-use rustc::{declare_tool_lint, lint_array};
+use rustc::{declare_lint_pass, declare_tool_lint};
use rustc_data_structures::fx::FxHashMap;
-use smallvec::SmallVec;
+use std::cmp::Ordering;
use std::collections::hash_map::Entry;
use std::hash::BuildHasherDefault;
-use syntax::symbol::LocalInternedString;
+use syntax::symbol::Symbol;
declare_clippy_lint! {
/// **What it does:** Checks for consecutive `if`s with the same condition.
"`match` with identical arm bodies"
}
-#[derive(Copy, Clone, Debug)]
-pub struct CopyAndPaste;
-
-impl LintPass for CopyAndPaste {
- fn get_lints(&self) -> LintArray {
- lint_array![IFS_SAME_COND, IF_SAME_THEN_ELSE, MATCH_SAME_ARMS]
- }
-
- fn name(&self) -> &'static str {
- "CopyAndPaste"
- }
-}
+declare_lint_pass!(CopyAndPaste => [IFS_SAME_COND, IF_SAME_THEN_ELSE, MATCH_SAME_ARMS]);
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
- if !in_macro(expr.span) {
+ if !expr.span.from_expansion() {
// skip ifs directly in else, it will be checked in the parent if
- if let Some(&Expr {
- node: ExprKind::If(_, _, Some(ref else_expr)),
- ..
- }) = get_parent_expr(cx, expr)
- {
- if else_expr.hir_id == expr.hir_id {
- return;
+ if let Some(expr) = get_parent_expr(cx, expr) {
+ if let Some((_, _, Some(ref else_expr))) = higher::if_block(&expr) {
+ if else_expr.hir_id == expr.hir_id {
+ return;
+ }
}
}
let eq: &dyn Fn(&&Expr, &&Expr) -> bool =
&|&lhs, &rhs| -> bool { SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, rhs) };
- if let Some((i, j)) = search_same(conds, hash, eq) {
+ for (i, j) in search_same(conds, hash, eq) {
span_note_and_lint(
cx,
IFS_SAME_COND,
}
/// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
+fn lint_match_arms<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &Expr) {
+ fn same_bindings<'tcx>(
+ cx: &LateContext<'_, 'tcx>,
+ lhs: &FxHashMap<Symbol, Ty<'tcx>>,
+ rhs: &FxHashMap<Symbol, Ty<'tcx>>,
+ ) -> bool {
+ lhs.len() == rhs.len()
+ && lhs
+ .iter()
+ .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| same_tys(cx, l_ty, r_ty)))
+ }
+
if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.node {
let hash = |&(_, arm): &(usize, &Arm)| -> u64 {
let mut h = SpanlessHash::new(cx, cx.tables);
let eq = |&(lindex, lhs): &(usize, &Arm), &(rindex, rhs): &(usize, &Arm)| -> bool {
let min_index = usize::min(lindex, rindex);
let max_index = usize::max(lindex, rindex);
+
// Arms with a guard are ignored, those can’t always be merged together
// This is also the case for arms in-between each there is an arm with a guard
(min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
// all patterns should have the same bindings
- bindings(cx, &lhs.pats[0]) == bindings(cx, &rhs.pats[0])
+ same_bindings(cx, &bindings(cx, &lhs.pats[0]), &bindings(cx, &rhs.pats[0]))
};
let indexed_arms: Vec<(usize, &Arm)> = arms.iter().enumerate().collect();
- if let Some((&(_, i), &(_, j))) = search_same(&indexed_arms, hash, eq) {
+ for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
span_lint_and_then(
cx,
MATCH_SAME_ARMS,
),
);
} else {
- db.span_note(i.body.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
+ db.span_help(
+ i.pats[0].span,
+ &format!("consider refactoring into `{} | {}`", lhs, rhs),
+ );
}
}
},
}
}
-/// Return the list of condition expressions and the list of blocks in a
-/// sequence of `if/else`.
-/// Eg. would return `([a, b], [c, d, e])` for the expression
-/// `if a { c } else if b { d } else { e }`.
-fn if_sequence(mut expr: &Expr) -> (SmallVec<[&Expr; 1]>, SmallVec<[&Block; 1]>) {
- let mut conds = SmallVec::new();
- let mut blocks: SmallVec<[&Block; 1]> = SmallVec::new();
-
- while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.node {
- conds.push(&**cond);
- if let ExprKind::Block(ref block, _) = then_expr.node {
- blocks.push(block);
- } else {
- panic!("ExprKind::If node is not an ExprKind::Block");
- }
-
- if let Some(ref else_expr) = *else_expr {
- expr = else_expr;
- } else {
- break;
- }
- }
-
- // final `else {..}`
- if !blocks.is_empty() {
- if let ExprKind::Block(ref block, _) = expr.node {
- blocks.push(&**block);
- }
- }
-
- (conds, blocks)
-}
-
-/// Return the list of bindings in a pattern.
-fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> FxHashMap<LocalInternedString, Ty<'tcx>> {
- fn bindings_impl<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- pat: &Pat,
- map: &mut FxHashMap<LocalInternedString, Ty<'tcx>>,
- ) {
+/// Returns the list of bindings in a pattern.
+fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> FxHashMap<Symbol, Ty<'tcx>> {
+ fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut FxHashMap<Symbol, Ty<'tcx>>) {
match pat.node {
PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
PatKind::TupleStruct(_, ref pats, _) => {
}
},
PatKind::Binding(.., ident, ref as_pat) => {
- if let Entry::Vacant(v) = map.entry(ident.as_str()) {
+ if let Entry::Vacant(v) = map.entry(ident.name) {
v.insert(cx.tables.pat_ty(pat));
}
if let Some(ref as_pat) = *as_pat {
bindings_impl(cx, as_pat, map);
}
},
- PatKind::Struct(_, ref fields, _) => {
+ PatKind::Or(ref fields) | PatKind::Tuple(ref fields, _) => {
for pat in fields {
- bindings_impl(cx, &pat.node.pat, map);
+ bindings_impl(cx, pat, map);
}
},
- PatKind::Tuple(ref fields, _) => {
+ PatKind::Struct(_, ref fields, _) => {
for pat in fields {
- bindings_impl(cx, pat, map);
+ bindings_impl(cx, &pat.pat, map);
}
},
PatKind::Slice(ref lhs, ref mid, ref rhs) => {
None
}
-fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
+fn search_common_cases<'a, T, Eq>(exprs: &'a [T], eq: &Eq) -> Option<(&'a T, &'a T)>
+where
+ Eq: Fn(&T, &T) -> bool,
+{
+ match exprs.len().cmp(&2) {
+ Ordering::Greater | Ordering::Less => None,
+ Ordering::Equal => {
+ if eq(&exprs[0], &exprs[1]) {
+ Some((&exprs[0], &exprs[1]))
+ } else {
+ None
+ }
+ },
+ }
+}
+
+fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
where
Hash: Fn(&T) -> u64,
Eq: Fn(&T, &T) -> bool,
{
- // common cases
- if exprs.len() < 2 {
- return None;
- } else if exprs.len() == 2 {
- return if eq(&exprs[0], &exprs[1]) {
- Some((&exprs[0], &exprs[1]))
- } else {
- None
- };
+ if let Some(expr) = search_common_cases(&exprs, &eq) {
+ return vec![expr];
}
+ let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
+
let mut map: FxHashMap<_, Vec<&_>> =
FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
Entry::Occupied(mut o) => {
for o in o.get() {
if eq(o, expr) {
- return Some((o, expr));
+ match_expr_list.push((o, expr));
}
}
o.get_mut().push(expr);
}
}
- None
+ match_expr_list
}
projects / rust.git / blobdiff