Disable arithmetic lints in constant items

Author: pengowen123

clippy_lints/src/arithmetic.rs

@@ -9,7 +9,7 @@
 
 
 use crate::utils::span_lint;
-use crate::rustc::hir;
+use crate::rustc::hir::{self, Item, ItemKind};
 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use crate::rustc::{declare_tool_lint, lint_array};
 use crate::syntax::source_map::Span;
@@ -51,7 +51,8 @@ declare_clippy_lint! {
 
 #[derive(Copy, Clone, Default)]
 pub struct Arithmetic {
-    span: Option<Span>,
+    expr_span: Option<Span>,
+    item_span: Option<Span>,
 }
 
 impl LintPass for Arithmetic {
@@ -62,9 +63,15 @@ impl LintPass for Arithmetic {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
-        if self.span.is_some() {
+        if self.expr_span.is_some() {
             return;
         }
+
+        if let Some(span) = self.item_span {
+            if span.contains(expr.span) {
+                return;
+            }
+        }
         match expr.node {
             hir::ExprKind::Binary(ref op, ref l, ref r) => {
                 match op.node {
@@ -86,29 +93,47 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
                 let (l_ty, r_ty) = (cx.tables.expr_ty(l), cx.tables.expr_ty(r));
                 if l_ty.is_integral() && r_ty.is_integral() {
                     span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                    self.span = Some(expr.span);
+                    self.expr_span = Some(expr.span);
                 } else if l_ty.is_floating_point() && r_ty.is_floating_point() {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                    self.span = Some(expr.span);
+                    self.expr_span = Some(expr.span);
                 }
             },
             hir::ExprKind::Unary(hir::UnOp::UnNeg, ref arg) => {
                 let ty = cx.tables.expr_ty(arg);
                 if ty.is_integral() {
                     span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                    self.span = Some(expr.span);
+                    self.expr_span = Some(expr.span);
                 } else if ty.is_floating_point() {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                    self.span = Some(expr.span);
+                    self.expr_span = Some(expr.span);
                 }
             },
             _ => (),
         }
     }
 
     fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
-        if Some(expr.span) == self.span {
-            self.span = None;
+        if Some(expr.span) == self.expr_span {
+            self.expr_span = None;
+        }
+    }
+
+    fn check_item(&mut self, _: &LateContext<'_, '_>, item: &Item) {
+        match item.node {
+            ItemKind::Enum(..)
+            | ItemKind::Const(..)
+            | ItemKind::Static(..) => self.item_span = Some(item.span),
+            _ => (),
+        }
+    }
+
+    fn check_item_post(&mut self, _: &LateContext<'_, '_>, item: &Item) {
+        match item.node {
+            ItemKind::Enum(..)
+            | ItemKind::Const(..)
+            | ItemKind::Static(..) => self.item_span = None,
+            _ => (),
         }
     }
 }

tests/ui/arithmetic.rs

@@ -37,4 +37,12 @@ fn main() {
     f / 2.0;
     f - 2.0 * 4.2;
     -f;
+
+    // No errors for the following items because they are constant expressions
+    enum Foo {
+        Bar = -2,
+    }
+
+    const FOO: i32 = -2;
+    static BAR: i32 = -2;
 }