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 e70e320929a8aca54b9c57c3f0c93825ee3b0826..76ea9c5ade609ea95a73ade1166961340ebdd904 100644 (file)
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,28 +1,33 @@
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use syntax::ast::*;
 use syntax::codemap::Spanned;
-use utils::{span_lint, snippet};
+use crate::utils::{in_macro, snippet, span_lint_and_sugg};
 
-/// **What it does:** This lint 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)
+/// **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)
 ///   followed by a method call
 ///
-/// **Why is this bad?** Because not everyone knows the precedence of those operators by heart, so
-/// expressions like these may trip others trying to reason about the code.
+/// **Why is this bad?** Not everyone knows the precedence of those operators by
+/// heart, so expressions like these may trip others trying to reason about the
+/// code.
 ///
-/// **Known problems:** None
+/// **Known problems:** None.
 ///
-/// **Examples:**
+/// **Example:**
 /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
 /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
-declare_lint! {
-    pub PRECEDENCE, Warn,
-    "catches operations where precedence may be unclear"
+declare_clippy_lint! {
+    pub PRECEDENCE,
+    complexity,
+    "operations where precedence may be unclear"
 }
 
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct Precedence;
 
 impl LintPass for Precedence {
@@ -33,60 +38,72 @@ 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,
+                );
+            };
+
             if !is_bit_op(op) {
                 return;
             }
             match (is_arith_expr(left), is_arith_expr(right)) {
                 (true, true) => {
-                    span_lint(cx,
-                              PRECEDENCE,
-                              expr.span,
-                              &format!("operator precedence can trip the unwary. Consider parenthesizing your \
-                                        expression:`({}) {} ({})`",
-                                       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) => {
-                    span_lint(cx,
-                              PRECEDENCE,
-                              expr.span,
-                              &format!("operator precedence can trip the unwary. Consider parenthesizing your \
-                                        expression:`({}) {} {}`",
-                                       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) => {
-                    span_lint(cx,
-                              PRECEDENCE,
-                              expr.span,
-                              &format!("operator precedence can trip the unwary. Consider parenthesizing your \
-                                        expression:`{} {} ({})`",
-                                       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) => (),
             }
         }
 
         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(cx,
-                                          PRECEDENCE,
-                                          expr.span,
-                                          &format!("unary minus has lower precedence than method call. Consider \
-                                                    adding parentheses to clarify your intent: -({})",
-                                                   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, "..")),
+                                );
+                            },
                             _ => (),
                         }
                     }