Merge branch 'macro-use' into HEAD

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

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index c478974a5bd4f985c6aac0e240f230f2d1e56ae3..784461c23ee8ae1b3b5eaef04bccb6a4c8f9f7dd 100644 (file)
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,7 +1,7 @@
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use syntax::ast;
-use syntax_pos::{Span, NO_EXPANSION};
-use utils::{differing_macro_contexts, in_macro, snippet_opt, span_note_and_lint};
+use crate::utils::{differing_macro_contexts, in_macro, snippet_opt, span_note_and_lint};
 use syntax::ptr::P;
 
 /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-`
@@ -16,9 +16,9 @@
 /// ```rust,ignore
 /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    Warn,
+    style,
     "suspicious formatting of `*=`, `-=` or `!=`"
 }
 
@@ -42,9 +42,9 @@
 /// if bar { // this is the `else` block of the previous `if`, but should it be?
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub SUSPICIOUS_ELSE_FORMATTING,
-    Warn,
+    style,
     "suspicious formatting of `else if`"
 }
 
@@ -62,9 +62,9 @@
 ///     -4, -5, -6
 /// ];
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub POSSIBLE_MISSING_COMMA,
-    Warn,
+    correctness,
     "possible missing comma in array"
 }
 
@@ -106,19 +106,11 @@ fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
 fn check_assign(cx: &EarlyContext, expr: &ast::Expr) {
     if let ast::ExprKind::Assign(ref lhs, ref rhs) = expr.node {
         if !differing_macro_contexts(lhs.span, rhs.span) && !in_macro(lhs.span) {
-            let eq_span = Span {
-                lo: lhs.span.hi,
-                hi: rhs.span.lo,
-                ctxt: NO_EXPANSION,
-            };
+            let eq_span = lhs.span.between(rhs.span);
             if let ast::ExprKind::Unary(op, ref sub_rhs) = rhs.node {
                 if let Some(eq_snippet) = snippet_opt(cx, eq_span) {
                     let op = ast::UnOp::to_string(op);
-                    let eqop_span = Span {
-                        lo: lhs.span.hi,
-                        hi: sub_rhs.span.lo,
-                        ctxt: NO_EXPANSION,
-                    };
+                    let eqop_span = lhs.span.between(sub_rhs.span);
                     if eq_snippet.ends_with('=') {
                         span_note_and_lint(
                             cx,
@@ -126,7 +118,7 @@ fn check_assign(cx: &EarlyContext, expr: &ast::Expr) {
                             eqop_span,
                             &format!(
                                 "this looks like you are trying to use `.. {op}= ..`, but you \
-                                                     really are doing `.. = ({op} ..)`",
+                                 really are doing `.. = ({op} ..)`",
                                 op = op
                             ),
                             eqop_span,
@@ -146,18 +138,14 @@ fn check_else_if(cx: &EarlyContext, expr: &ast::Expr) {
             // this will be a span from the closing ‘}’ of the “then” block (excluding) to
             // the
             // “if” of the “else if” block (excluding)
-            let else_span = Span {
-                lo: then.span.hi,
-                hi: else_.span.lo,
-                ctxt: NO_EXPANSION,
-            };
+            let else_span = then.span.between(else_.span);
 
             // the snippet should look like " else \n    " with maybe comments anywhere
             // it’s bad when there is a ‘\n’ after the “else”
             if let Some(else_snippet) = snippet_opt(cx, else_span) {
-                let else_pos = else_snippet.find("else").expect(
-                    "there must be a `else` here",
-                );
+                let else_pos = else_snippet
+                    .find("else")
+                    .expect("there must be a `else` here");
 
                 if else_snippet[else_pos..].contains('\n') {
                     span_note_and_lint(
@@ -167,7 +155,7 @@ fn check_else_if(cx: &EarlyContext, expr: &ast::Expr) {
                         "this is an `else if` but the formatting might hide it",
                         else_span,
                         "to remove this lint, remove the `else` or remove the new line between `else` \
-                                        and `if`",
+                         and `if`",
                     );
                 }
             }
@@ -181,17 +169,9 @@ fn check_array(cx: &EarlyContext, expr: &ast::Expr) {
         for element in array {
             if let ast::ExprKind::Binary(ref op, ref lhs, _) = element.node {
                 if !differing_macro_contexts(lhs.span, op.span) {
-                    let space_span = Span {
-                        lo: lhs.span.hi,
-                        hi: op.span.lo,
-                        ctxt: NO_EXPANSION,
-                    };
+                    let space_span = lhs.span.between(op.span);
                     if let Some(space_snippet) = snippet_opt(cx, space_span) {
-                        let lint_span = Span {
-                            lo: lhs.span.hi,
-                            hi: lhs.span.hi,
-                            ctxt: NO_EXPANSION,
-                        };
+                        let lint_span = lhs.span.with_lo(lhs.span.hi());
                         if space_snippet.contains('\n') {
                             span_note_and_lint(
                                 cx,
@@ -211,15 +191,11 @@ fn check_array(cx: &EarlyContext, expr: &ast::Expr) {
 
 /// Implementation of the `SUSPICIOUS_ELSE_FORMATTING` lint for consecutive ifs.
 fn check_consecutive_ifs(cx: &EarlyContext, first: &ast::Expr, second: &ast::Expr) {
-    if !differing_macro_contexts(first.span, second.span) && !in_macro(first.span) && unsugar_if(first).is_some() &&
-        unsugar_if(second).is_some()
+    if !differing_macro_contexts(first.span, second.span) && !in_macro(first.span) && unsugar_if(first).is_some()
+        && unsugar_if(second).is_some()
     {
         // where the else would be
-        let else_span = Span {
-            lo: first.span.hi,
-            hi: second.span.lo,
-            ctxt: NO_EXPANSION,
-        };
+        let else_span = first.span.between(second.span);
 
         if let Some(else_snippet) = snippet_opt(cx, else_span) {
             if !else_snippet.contains('\n') {
@@ -230,7 +206,7 @@ fn check_consecutive_ifs(cx: &EarlyContext, first: &ast::Expr, second: &ast::Exp
                     "this looks like an `else if` but the `else` is missing",
                     else_span,
                     "to remove this lint, add the missing `else` or add a new line before the second \
-                                    `if`",
+                     `if`",
                 );
             }
         }
@@ -240,8 +216,9 @@ fn check_consecutive_ifs(cx: &EarlyContext, first: &ast::Expr, second: &ast::Exp
 /// Match `if` or `if let` expressions and return the `then` and `else` block.
 fn unsugar_if(expr: &ast::Expr) -> Option<(&P<ast::Block>, &Option<P<ast::Expr>>)> {
     match expr.node {
-        ast::ExprKind::If(_, ref then, ref else_) |
-        ast::ExprKind::IfLet(_, _, ref then, ref else_) => Some((then, else_)),
+        ast::ExprKind::If(_, ref then, ref else_) | ast::ExprKind::IfLet(_, _, ref then, ref else_) => {
+            Some((then, else_))
+        },
         _ => None,
     }
 }