rustup https://github.com/rust-lang/rust/pull/67455

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

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index c7a0f0058f9651afabb002fc8b09e5a8cd9a1a39..f47945f0a14692956c8a9d12e917998be9164497 100644 (file)
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,15 +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::declare_lint_pass;
 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 rustc_session::declare_tool_lint;
 use syntax_pos::Symbol;
 
 declare_clippy_lint! {
@@ -105,48 +106,58 @@ 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 {
                     if let Some(slice) = Sugg::hir_opt(cx, slice) {
-                        (false,
-                         format!(" elements of `{}`", slice),
-                         format!("{}.swap({}, {})",
-                                 slice.maybe_par(),
-                                 snippet(cx, idx1.span, ".."),
-                                 snippet(cx, idx2.span, "..")))
+                        (
+                            false,
+                            format!(" elements of `{}`", slice),
+                            format!(
+                                "{}.swap({}, {})",
+                                slice.maybe_par(),
+                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
+                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
+                            ),
+                        )
                     } else {
                         (false, String::new(), String::new())
                     }
                 } else if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs1), Sugg::hir_opt(cx, rhs1)) {
-                    (true, format!(" `{}` and `{}`", first, second),
-                        format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()))
+                    (
+                        true,
+                        format!(" `{}` and `{}`", first, second),
+                        format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
+                    )
                 } else {
                     (true, String::new(), String::new())
                 };
 
                 let span = w[0].span.to(second.span);
 
-                span_lint_and_then(cx,
-                                   MANUAL_SWAP,
-                                   span,
-                                   &format!("this looks like you are swapping{} manually", what),
-                                   |db| {
-                                       if !sugg.is_empty() {
-                                           db.span_suggestion(
-                                               span,
-                                               "try",
-                                               sugg,
-                                               Applicability::Unspecified,
-                                           );
+                span_lint_and_then(
+                    cx,
+                    MANUAL_SWAP,
+                    span,
+                    &format!("this looks like you are swapping{} manually", what),
+                    |db| {
+                        if !sugg.is_empty() {
+                            db.span_suggestion(
+                                span,
+                                "try",
+                                sugg,
+                                applicability,
+                            );
 
-                                           if replace {
-                                               db.note("or maybe you should use `std::mem::replace`?");
-                                           }
-                                       }
-                                   });
+                            if replace {
+                                db.note("or maybe you should use `std::mem::replace`?");
+                            }
+                        }
+                    }
+                );
             }
         }
     }
@@ -158,6 +169,7 @@ enum Slice<'a> {
     /// ## Example
     ///
     /// ```rust
+    /// # let mut a = vec![0, 1];
     /// let t = a[1];
     /// a[1] = a[0];
     /// a[0] = t;
@@ -170,6 +182,7 @@ enum Slice<'a> {
     /// ## 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;