Merge branch 'macro-use' into HEAD

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

diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 08b4cf166f27af562124d09921105705edd5df1c..76ea9c5ade609ea95a73ade1166961340ebdd904 100644 (file)
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,12 +1,15 @@
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use syntax::ast::*;
 use syntax::codemap::Spanned;
-use utils::{span_lint_and_sugg, snippet};
+use crate::utils::{in_macro, snippet, span_lint_and_sugg};
 
 /// **What it does:** Checks for operations where precedence may be unclear
 /// and suggests to add parentheses. Currently it catches the following:
-/// * mixed usage of arithmetic and bit shifting/combining operators without parentheses
-/// * a "negative" numeric literal (which is really a unary `-` followed by a numeric literal)
+/// * mixed usage of arithmetic and bit shifting/combining operators without
+/// parentheses
+/// * a "negative" numeric literal (which is really a unary `-` followed by a
+/// numeric literal)
 ///   followed by a method call
 ///
 /// **Why is this bad?** Not everyone knows the precedence of those operators by
@@ -18,13 +21,13 @@
 /// **Example:**
 /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
 /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
-declare_lint! {
+declare_clippy_lint! {
     pub PRECEDENCE,
-    Warn,
+    complexity,
     "operations where precedence may be unclear"
 }
 
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct Precedence;
 
 impl LintPass for Precedence {
@@ -35,14 +38,20 @@ fn get_lints(&self) -> LintArray {
 
 impl EarlyLintPass for Precedence {
     fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
+        if in_macro(expr.span) {
+            return;
+        }
+
         if let ExprKind::Binary(Spanned { node: op, .. }, ref left, ref right) = expr.node {
             let span_sugg = |expr: &Expr, sugg| {
-                span_lint_and_sugg(cx,
-                                   PRECEDENCE,
-                                   expr.span,
-                                   "operator precedence can trip the unwary",
-                                   "consider parenthesizing your expression",
-                                   sugg);
+                span_lint_and_sugg(
+                    cx,
+                    PRECEDENCE,
+                    expr.span,
+                    "operator precedence can trip the unwary",
+                    "consider parenthesizing your expression",
+                    sugg,
+                );
             };
 
             if !is_bit_op(op) {
@@ -50,24 +59,30 @@ fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
             }
             match (is_arith_expr(left), is_arith_expr(right)) {
                 (true, true) => {
-                    let sugg = format!("({}) {} ({})",
-                                       snippet(cx, left.span, ".."),
-                                       op.to_string(),
-                                       snippet(cx, right.span, ".."));
+                    let sugg = format!(
+                        "({}) {} ({})",
+                        snippet(cx, left.span, ".."),
+                        op.to_string(),
+                        snippet(cx, right.span, "..")
+                    );
                     span_sugg(expr, sugg);
                 },
                 (true, false) => {
-                    let sugg = format!("({}) {} {}",
-                                       snippet(cx, left.span, ".."),
-                                       op.to_string(),
-                                       snippet(cx, right.span, ".."));
+                    let sugg = format!(
+                        "({}) {} {}",
+                        snippet(cx, left.span, ".."),
+                        op.to_string(),
+                        snippet(cx, right.span, "..")
+                    );
                     span_sugg(expr, sugg);
                 },
                 (false, true) => {
-                    let sugg = format!("{} {} ({})",
-                                       snippet(cx, left.span, ".."),
-                                       op.to_string(),
-                                       snippet(cx, right.span, ".."));
+                    let sugg = format!(
+                        "{} {} ({})",
+                        snippet(cx, left.span, ".."),
+                        op.to_string(),
+                        snippet(cx, right.span, "..")
+                    );
                     span_sugg(expr, sugg);
                 },
                 (false, false) => (),
@@ -75,19 +90,19 @@ fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
         }
 
         if let ExprKind::Unary(UnOp::Neg, ref rhs) = expr.node {
-            if let ExprKind::MethodCall(_, _, ref args) = rhs.node {
+            if let ExprKind::MethodCall(_, ref args) = rhs.node {
                 if let Some(slf) = args.first() {
                     if let ExprKind::Lit(ref lit) = slf.node {
                         match lit.node {
-                            LitKind::Int(..) |
-                            LitKind::Float(..) |
-                            LitKind::FloatUnsuffixed(..) => {
-                                span_lint_and_sugg(cx,
-                                                   PRECEDENCE,
-                                                   expr.span,
-                                                   "unary minus has lower precedence than method call",
-                                                   "consider adding parentheses to clarify your intent",
-                                                   format!("-({})", snippet(cx, rhs.span, "..")));
+                            LitKind::Int(..) | LitKind::Float(..) | LitKind::FloatUnsuffixed(..) => {
+                                span_lint_and_sugg(
+                                    cx,
+                                    PRECEDENCE,
+                                    expr.span,
+                                    "unary minus has lower precedence than method call",
+                                    "consider adding parentheses to clarify your intent",
+                                    format!("-({})", snippet(cx, rhs.span, "..")),
+                                );
                             },
                             _ => (),
                         }