Use span_suggestion_with_applicability instead of span_suggestion

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

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 5a27f6a2c36f33e58923763012d9e48f4ee7c5e2..5cf714bed86a08cc897baf18befa4315edc5fd4d 100644 (file)
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,11 +1,12 @@
 use crate::utils::{get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, SpanlessEq};
 use crate::utils::{higher, sugg};
-use rustc::hir;
-use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::{declare_tool_lint, lint_array};
+use crate::rustc::hir;
+use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use crate::rustc::{declare_tool_lint, lint_array};
 use if_chain::if_chain;
-use syntax::ast;
+use crate::syntax::ast;
+use crate::rustc_errors::Applicability;
 
 /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a`
 /// patterns.
@@ -78,7 +79,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
                                         let r = &sugg::Sugg::hir(cx, rhs, "..");
                                         let long =
                                             format!("{} = {}", snip_a, sugg::make_binop(higher::binop(op.node), a, r));
-                                        db.span_suggestion(
+                                        db.span_suggestion_with_applicability(
                                             expr.span,
                                             &format!(
                                                 "Did you mean {} = {} {} {} or {}? Consider replacing it with",
@@ -89,8 +90,14 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
                                                 long
                                             ),
                                             format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
+                                            Applicability::Unspecified,
                                         );
-                                        db.span_suggestion(expr.span, "or", long);
+                                        db.span_suggestion_with_applicability(
+                                            expr.span, 
+                                            "or", 
+                                            long,
+                                            Applicability::Unspecified,
+                                            );
                                     }
                                 },
                             );
@@ -108,7 +115,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
             },
             hir::ExprKind::Assign(ref assignee, ref e) => {
                 if let hir::ExprKind::Binary(op, ref l, ref r) = e.node {
-                    #[allow(cyclomatic_complexity)]
+                    #[allow(clippy::cyclomatic_complexity)]
                     let lint = |assignee: &hir::Expr, rhs: &hir::Expr| {
                         let ty = cx.tables.expr_ty(assignee);
                         let rty = cx.tables.expr_ty(rhs);
@@ -172,10 +179,11 @@ macro_rules! ops {
                                     if let (Some(snip_a), Some(snip_r)) =
                                         (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
                                     {
-                                        db.span_suggestion(
+                                        db.span_suggestion_with_applicability(
                                             expr.span,
                                             "replace it with",
                                             format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
+                                            Applicability::Unspecified,
                                         );
                                     }
                                 },
@@ -220,7 +228,7 @@ macro_rules! ops {
 }
 
 fn is_commutative(op: hir::BinOpKind) -> bool {
-    use rustc::hir::BinOpKind::*;
+    use crate::rustc::hir::BinOpKind::*;
     match op {
         Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true,
         Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false,