Auto merge of #4543 - xiongmao86:issue4503, r=flip1995

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

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index bb294c467fa8302e15b505881c8349a96631f40f..7e699844ef232889affac158c81d4b7bb26dbf67 100644 (file)
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,16 +1,16 @@
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    differing_macro_contexts, is_type_diagnostic_item, match_type, paths, snippet, span_lint_and_then, walk_ptrs_ty,
-    SpanlessEq,
+    differing_macro_contexts, is_type_diagnostic_item, match_type, paths, snippet_with_applicability,
+    span_lint_and_then, walk_ptrs_ty, SpanlessEq,
 };
 use if_chain::if_chain;
 use matches::matches;
-use rustc::hir::*;
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::ty;
-use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
-use syntax_pos::Symbol;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual swapping.
@@ -68,14 +68,14 @@
 declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Swap {
-    fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) {
+    fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block<'_>) {
         check_manual_swap(cx, block);
         check_suspicious_swap(cx, block);
     }
 }
 
 /// Implementation of the `MANUAL_SWAP` lint.
-fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
+fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block<'_>) {
     for w in block.stmts.windows(3) {
         if_chain! {
             // let t = foo();
@@ -85,11 +85,11 @@ fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
 
             // foo() = bar();
             if let StmtKind::Semi(ref first) = w[1].kind;
-            if let ExprKind::Assign(ref lhs1, ref rhs1) = first.kind;
+            if let ExprKind::Assign(ref lhs1, ref rhs1, _) = first.kind;
 
             // bar() = t;
             if let StmtKind::Semi(ref second) = w[2].kind;
-            if let ExprKind::Assign(ref lhs2, ref rhs2) = second.kind;
+            if let ExprKind::Assign(ref lhs2, ref rhs2, _) = second.kind;
             if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.kind;
             if rhs2.segments.len() == 1;
 
@@ -105,8 +105,9 @@ fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
                     }
                 }
 
-                let slice = check_for_slice(cx, lhs1, lhs2);
+                let mut applicability = Applicability::MachineApplicable;
 
+                let slice = check_for_slice(cx, lhs1, lhs2);
                 let (replace, what, sugg) = if let Slice::NotSwappable = slice {
                     return;
                 } else if let Slice::Swappable(slice, idx1, idx2) = slice {
@@ -117,8 +118,8 @@ fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
                             format!(
                                 "{}.swap({}, {})",
                                 slice.maybe_par(),
-                                snippet(cx, idx1.span, ".."),
-                                snippet(cx, idx2.span, ".."),
+                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
+                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
                             ),
                         )
                     } else {
@@ -147,7 +148,7 @@ fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
                                 span,
                                 "try",
                                 sugg,
-                                Applicability::Unspecified,
+                                applicability,
                             );
 
                             if replace {
@@ -167,18 +168,20 @@ enum Slice<'a> {
     /// ## Example
     ///
     /// ```rust
+    /// # let mut a = vec![0, 1];
     /// let t = a[1];
     /// a[1] = a[0];
     /// a[0] = t;
     /// // can be written as
     /// a.swap(0, 1);
     /// ```
-    Swappable(&'a Expr, &'a Expr, &'a Expr),
+    Swappable(&'a Expr<'a>, &'a Expr<'a>, &'a Expr<'a>),
     /// The `swap` function cannot be used.
     ///
     /// ## Example
     ///
     /// ```rust
+    /// # let mut a = [vec![1, 2], vec![3, 4]];
     /// let t = a[0][1];
     /// a[0][1] = a[1][0];
     /// a[1][0] = t;
@@ -189,7 +192,7 @@ enum Slice<'a> {
 }
 
 /// Checks if both expressions are index operations into "slice-like" types.
-fn check_for_slice<'a>(cx: &LateContext<'_, '_>, lhs1: &'a Expr, lhs2: &'a Expr) -> Slice<'a> {
+fn check_for_slice<'a>(cx: &LateContext<'_, '_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<'_>) -> Slice<'a> {
     if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.kind {
         if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.kind {
             if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) {
@@ -212,14 +215,14 @@ fn check_for_slice<'a>(cx: &LateContext<'_, '_>, lhs1: &'a Expr, lhs2: &'a Expr)
 }
 
 /// Implementation of the `ALMOST_SWAPPED` lint.
-fn check_suspicious_swap(cx: &LateContext<'_, '_>, block: &Block) {
+fn check_suspicious_swap(cx: &LateContext<'_, '_>, block: &Block<'_>) {
     for w in block.stmts.windows(2) {
         if_chain! {
             if let StmtKind::Semi(ref first) = w[0].kind;
             if let StmtKind::Semi(ref second) = w[1].kind;
             if !differing_macro_contexts(first.span, second.span);
-            if let ExprKind::Assign(ref lhs0, ref rhs0) = first.kind;
-            if let ExprKind::Assign(ref lhs1, ref rhs1) = second.kind;
+            if let ExprKind::Assign(ref lhs0, ref rhs0, _) = first.kind;
+            if let ExprKind::Assign(ref lhs1, ref rhs1, _) = second.kind;
             if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1);
             if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0);
             then {