-use rustc::lint::*;
-use rustc::ty::Ty;
+use crate::utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_and_lint};
+use crate::utils::{SpanlessEq, SpanlessHash};
use rustc::hir::*;
-use std::collections::HashMap;
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::ty::Ty;
+use rustc::{declare_tool_lint, lint_array};
+use rustc_data_structures::fx::FxHashMap;
+use smallvec::SmallVec;
use std::collections::hash_map::Entry;
-use syntax::symbol::InternedString;
-use syntax::util::small_vector::SmallVector;
-use utils::{SpanlessEq, SpanlessHash};
-use utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_and_lint};
+use std::hash::BuildHasherDefault;
+use syntax::symbol::LocalInternedString;
/// **What it does:** Checks for consecutive `if`s with the same condition.
///
///
/// **Known problems:** False positive possible with order dependent `match`
/// (see issue
-/// [#860](https://github.com/rust-lang-nursery/rust-clippy/issues/860)).
+/// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
///
/// **Example:**
/// ```rust,ignore
fn get_lints(&self) -> LintArray {
lint_array![IFS_SAME_COND, IF_SAME_THEN_ELSE, MATCH_SAME_ARMS]
}
+
+ fn name(&self) -> &'static str {
+ "CopyAndPaste"
+ }
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {
if !in_macro(expr.span) {
// skip ifs directly in else, it will be checked in the parent if
if let Some(&Expr {
- node: ExprIf(_, _, Some(ref else_expr)),
+ node: ExprKind::If(_, _, Some(ref else_expr)),
..
}) = get_parent_expr(cx, expr)
{
}
/// Implementation of `IF_SAME_THEN_ELSE`.
-fn lint_same_then_else(cx: &LateContext, blocks: &[&Block]) {
- let eq: &Fn(&&Block, &&Block) -> bool = &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).eq_block(lhs, rhs) };
+fn lint_same_then_else(cx: &LateContext<'_, '_>, blocks: &[&Block]) {
+ let eq: &dyn Fn(&&Block, &&Block) -> bool = &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).eq_block(lhs, rhs) };
if let Some((i, j)) = search_same_sequenced(blocks, eq) {
span_note_and_lint(
}
/// Implementation of `IFS_SAME_COND`.
-fn lint_same_cond(cx: &LateContext, conds: &[&Expr]) {
- let hash: &Fn(&&Expr) -> u64 = &|expr| -> u64 {
- let mut h = SpanlessHash::new(cx);
+fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr]) {
+ let hash: &dyn Fn(&&Expr) -> u64 = &|expr| -> u64 {
+ let mut h = SpanlessHash::new(cx, cx.tables);
h.hash_expr(expr);
h.finish()
};
- let eq: &Fn(&&Expr, &&Expr) -> bool = &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, rhs) };
+ 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) {
span_note_and_lint(
}
}
-/// Implementation if `MATCH_SAME_ARMS`.
-fn lint_match_arms(cx: &LateContext, expr: &Expr) {
- if let ExprMatch(_, ref arms, MatchSource::Normal) = expr.node {
+/// Implementation of `MATCH_SAME_ARMS`.
+fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
+ if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.node {
let hash = |&(_, arm): &(usize, &Arm)| -> u64 {
- let mut h = SpanlessHash::new(cx);
+ let mut h = SpanlessHash::new(cx, cx.tables);
h.hash_expr(&arm.body);
h.finish()
};
|db| {
db.span_note(i.body.span, "same as this");
- // Note: this does not use `span_suggestion` on purpose: there is no clean way
+ // Note: this does not use `span_suggestion_with_applicability` on purpose:
+ // there is no clean way
// to remove the other arm. Building a span and suggest to replace it to ""
// makes an even more confusing error message. Also in order not to make up a
// span for the whole pattern, the suggestion is only shown when there is only
// hiding all the subsequent arms, and rust won't compile
db.span_note(
i.body.span,
- &format!("`{}` has the same arm body as the `_` wildcard, consider removing it`", lhs),
+ &format!(
+ "`{}` has the same arm body as the `_` wildcard, consider removing it`",
+ lhs
+ ),
);
} else {
db.span_note(i.body.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
/// 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) -> (SmallVector<&Expr>, SmallVector<&Block>) {
- let mut conds = SmallVector::new();
- let mut blocks: SmallVector<&Block> = SmallVector::new();
+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 ExprIf(ref cond, ref then_expr, ref else_expr) = expr.node {
+ while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.node {
conds.push(&**cond);
- if let ExprBlock(ref block) = then_expr.node {
+ if let ExprKind::Block(ref block, _) = then_expr.node {
blocks.push(block);
} else {
- panic!("ExprIf node is not an ExprBlock");
+ panic!("ExprKind::If node is not an ExprKind::Block");
}
if let Some(ref else_expr) = *else_expr {
// final `else {..}`
if !blocks.is_empty() {
- if let ExprBlock(ref block) = expr.node {
+ if let ExprKind::Block(ref block, _) = expr.node {
blocks.push(&**block);
}
}
}
/// Return the list of bindings in a pattern.
-fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<InternedString, Ty<'tcx>> {
- fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut HashMap<InternedString, Ty<'tcx>>) {
+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>>,
+ ) {
match pat.node {
PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
- PatKind::TupleStruct(_, ref pats, _) => for pat in pats {
- bindings_impl(cx, pat, map);
+ PatKind::TupleStruct(_, ref pats, _) => {
+ for pat in pats {
+ bindings_impl(cx, pat, map);
+ }
},
- PatKind::Binding(_, _, ref ident, ref as_pat) => {
- if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {
+ PatKind::Binding(_, _, ident, ref as_pat) => {
+ if let Entry::Vacant(v) = map.entry(ident.as_str()) {
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, _) => for pat in fields {
- bindings_impl(cx, &pat.node.pat, map);
+ PatKind::Struct(_, ref fields, _) => {
+ for pat in fields {
+ bindings_impl(cx, &pat.node.pat, map);
+ }
},
- PatKind::Tuple(ref fields, _) => for pat in fields {
- bindings_impl(cx, pat, map);
+ PatKind::Tuple(ref fields, _) => {
+ for pat in fields {
+ bindings_impl(cx, pat, map);
+ }
},
PatKind::Slice(ref lhs, ref mid, ref rhs) => {
for pat in lhs {
}
}
- let mut result = HashMap::new();
+ let mut result = FxHashMap::default();
bindings_impl(cx, pat, &mut result);
result
}
-
fn search_same_sequenced<T, Eq>(exprs: &[T], eq: Eq) -> Option<(&T, &T)>
where
Eq: Fn(&T, &T) -> bool,
};
}
- let mut map: HashMap<_, Vec<&_>> = HashMap::with_capacity(exprs.len());
+ let mut map: FxHashMap<_, Vec<&_>> =
+ FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
for expr in exprs {
match map.entry(hash(expr)) {
projects / rust.git / blobdiff