Auto merge of #3725 - mikerite:fix-2728, r=phansch

[rust.git] / clippy_lints / src / copies.rs

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 76c8360be62d9273cf41ff7729b8636d2773ed83..41afe5ce0d79ed07333e6afeca95b7c323aeb89e 100644 (file)
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,14 +1,14 @@
-use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use crate::rustc::{declare_tool_lint, lint_array};
-use crate::rustc::ty::Ty;
-use crate::rustc::hir::*;
-use crate::rustc_data_structures::fx::FxHashMap;
+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 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 std::hash::BuildHasherDefault;
-use crate::syntax::symbol::LocalInternedString;
-use crate::rustc_data_structures::small_vec::OneVector;
-use crate::utils::{SpanlessEq, SpanlessHash};
-use crate::utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_and_lint};
+use syntax::symbol::LocalInternedString;
 
 /// **What it does:** Checks for consecutive `if`s with the same condition.
 ///
@@ -70,7 +70,7 @@
 ///
 /// **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
@@ -110,6 +110,10 @@ 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"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {
@@ -158,7 +162,8 @@ fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr]) {
         h.finish()
     };
 
-    let eq: &dyn 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(
@@ -202,7 +207,8 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
                 |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` 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
@@ -218,7 +224,10 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
                             // 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));
@@ -234,9 +243,9 @@ fn lint_match_arms(cx: &LateContext<'_, '_>, expr: &Expr) {
 /// 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) -> (OneVector<&Expr>, OneVector<&Block>) {
-    let mut conds = OneVector::new();
-    let mut blocks: OneVector<&Block> = OneVector::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 ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.node {
         conds.push(&**cond);
@@ -265,13 +274,19 @@ fn if_sequence(mut expr: &Expr) -> (OneVector<&Expr>, OneVector<&Block>) {
 
 /// 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>>) {
+    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(_, _, ident, ref as_pat) => {
+            PatKind::Binding(.., ident, ref as_pat) => {
                 if let Entry::Vacant(v) = map.entry(ident.as_str()) {
                     v.insert(cx.tables.pat_ty(pat));
                 }
@@ -279,11 +294,15 @@ fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut FxHa
                     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 {
@@ -305,7 +324,6 @@ fn bindings_impl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat, map: &mut FxHa
     result
 }
 
-
 fn search_same_sequenced<T, Eq>(exprs: &[T], eq: Eq) -> Option<(&T, &T)>
 where
     Eq: Fn(&T, &T) -> bool,
@@ -334,10 +352,8 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
         };
     }
 
-    let mut map: FxHashMap<_, Vec<&_>> = FxHashMap::with_capacity_and_hasher(
-        exprs.len(),
-        BuildHasherDefault::default()
-    );
+    let mut map: FxHashMap<_, Vec<&_>> =
+        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
 
     for expr in exprs {
         match map.entry(hash(expr)) {