Use span_suggestion_with_applicability instead of span_suggestion

[rust.git] / clippy_lints / src / utils / sugg.rs

diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 91fd5ec874afda3ffabb3bd402d2ba87f8793aab..f7d8c1fc15122526660cdbe2b7b124d680ce630a 100644 (file)
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -1,22 +1,21 @@
 //! Contains utility functions to generate suggestions.
-#![deny(missing_docs_in_private_items)]
-// currently ignores lifetimes and generics
-#![allow(use_self)]
+#![deny(clippy::missing_docs_in_private_items)]
 
 use matches::matches;
-use rustc::hir;
-use rustc::lint::{EarlyContext, LateContext, LintContext};
-use rustc_errors;
+use crate::rustc::hir;
+use crate::rustc::lint::{EarlyContext, LateContext, LintContext};
+use crate::rustc_errors;
 use std::borrow::Cow;
 use std::fmt::Display;
 use std;
-use syntax::codemap::{CharPos, Span};
-use syntax::parse::token;
-use syntax::print::pprust::token_to_string;
-use syntax::util::parser::AssocOp;
-use syntax::ast;
+use crate::syntax::source_map::{CharPos, Span};
+use crate::syntax::parse::token;
+use crate::syntax::print::pprust::token_to_string;
+use crate::syntax::util::parser::AssocOp;
+use crate::syntax::ast;
 use crate::utils::{higher, snippet, snippet_opt};
-use syntax_pos::{BytePos, Pos};
+use crate::syntax_pos::{BytePos, Pos};
+use crate::rustc_errors::Applicability;
 
 /// A helper type to build suggestion correctly handling parenthesis.
 pub enum Sugg<'a> {
@@ -40,7 +39,7 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
     }
 }
 
-#[allow(wrong_self_convention)] // ok, because of the function `as_ty` method
+#[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
 impl<'a> Sugg<'a> {
     /// Prepare a suggestion from an expression.
     pub fn hir_opt(cx: &LateContext<'_, '_>, expr: &hir::Expr) -> Option<Self> {
@@ -88,7 +87,7 @@ pub fn hir(cx: &LateContext<'_, '_>, expr: &hir::Expr, default: &'a str) -> Self
 
     /// Prepare a suggestion from an expression.
     pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
-        use syntax::ast::RangeLimits;
+        use crate::syntax::ast::RangeLimits;
 
         let snippet = snippet(cx, expr.span, default);
 
@@ -105,7 +104,6 @@ pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
             ast::ExprKind::Block(..) |
             ast::ExprKind::Break(..) |
             ast::ExprKind::Call(..) |
-            ast::ExprKind::Catch(..) |
             ast::ExprKind::Continue(..) |
             ast::ExprKind::Yield(..) |
             ast::ExprKind::Field(..) |
@@ -122,6 +120,7 @@ pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
             ast::ExprKind::Ret(..) |
             ast::ExprKind::Struct(..) |
             ast::ExprKind::Try(..) |
+            ast::ExprKind::TryBlock(..) |
             ast::ExprKind::Tup(..) |
             ast::ExprKind::Array(..) |
             ast::ExprKind::While(..) |
@@ -177,6 +176,7 @@ pub fn mut_addr_deref(self) -> Sugg<'static> {
 
     /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
     /// suggestion.
+    #[allow(dead_code)]
     pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
         match limit {
             ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
@@ -334,7 +334,7 @@ fn needs_paren(op: &AssocOp, other: &AssocOp, dir: Associativity) -> bool {
     Sugg::BinOp(op, sugg.into())
 }
 
-/// Convinience wrapper arround `make_assoc` and `AssocOp::from_ast_binop`.
+/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
 pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
     make_assoc(AssocOp::from_ast_binop(op), lhs, rhs)
 }
@@ -361,7 +361,7 @@ enum Associativity {
 /// they are considered
 /// associative.
 fn associativity(op: &AssocOp) -> Associativity {
-    use syntax::util::parser::AssocOp::*;
+    use crate::syntax::util::parser::AssocOp::*;
 
     match *op {
         ObsoleteInPlace | Assign | AssignOp(_) => Associativity::Right,
@@ -383,7 +383,7 @@ fn associativity(op: &AssocOp) -> Associativity {
 
 /// Convert a `hir::BinOp` to the corresponding assigning binary operator.
 fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
-    use syntax::parse::token::BinOpToken::*;
+    use crate::syntax::parse::token::BinOpToken::*;
 
     AssocOp::AssignOp(match op.node {
         hir::BinOpKind::Add => Plus,
@@ -411,8 +411,8 @@ fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
 
 /// Convert an `ast::BinOp` to the corresponding assigning binary operator.
 fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
-    use syntax::ast::BinOpKind::*;
-    use syntax::parse::token::BinOpToken;
+    use crate::syntax::ast::BinOpKind::*;
+    use crate::syntax::parse::token::BinOpToken;
 
     AssocOp::AssignOp(match op.node {
         Add => BinOpToken::Plus,
@@ -432,7 +432,7 @@ fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
 /// Return the indentation before `span` if there are nothing but `[ \t]`
 /// before it on its line.
 fn indentation<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option<String> {
-    let lo = cx.sess().codemap().lookup_char_pos(span.lo());
+    let lo = cx.sess().source_map().lookup_char_pos(span.lo());
     if let Some(line) = lo.file
         .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
     {
@@ -497,7 +497,12 @@ fn suggest_item_with_attr<D: Display + ?Sized>(&mut self, cx: &T, item: Span, ms
         if let Some(indent) = indentation(cx, item) {
             let span = item.with_hi(item.lo());
 
-            self.span_suggestion(span, msg, format!("{}\n{}", attr, indent));
+            self.span_suggestion_with_applicability(
+                        span,
+                        msg,
+                        format!("{}\n{}", attr, indent),
+                        Applicability::Unspecified,
+                        );
         }
     }
 
@@ -518,14 +523,19 @@ fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str
                 })
                 .collect::<String>();
 
-            self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent));
+            self.span_suggestion_with_applicability(
+                        span,
+                        msg,
+                        format!("{}\n{}", new_item, indent),
+                        Applicability::Unspecified,
+                        );
         }
     }
 
     fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str) {
         let mut remove_span = item;
-        let hi = cx.sess().codemap().next_point(remove_span).hi();
-        let fmpos = cx.sess().codemap().lookup_byte_offset(hi);
+        let hi = cx.sess().source_map().next_point(remove_span).hi();
+        let fmpos = cx.sess().source_map().lookup_byte_offset(hi);
 
         if let Some(ref src) = fmpos.fm.src {
             let non_whitespace_offset = src[fmpos.pos.to_usize()..].find(|c| c != ' ' && c != '\t' && c != '\n');
@@ -535,6 +545,11 @@ fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str) {
             }
         }
 
-        self.span_suggestion(remove_span, msg, String::new());
+        self.span_suggestion_with_applicability(
+                    remove_span,
+                    msg,
+                    String::new(),
+                    Applicability::Unspecified,
+                    );
     }
 }