Merge branch 'macro-use' into HEAD

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

diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index 2bd0562aebb2cb381f077ffee6eb7f2caee99c2d..b3d78d2d13f7951c3a9eb8138494b8c4dd9fd0f6 100644 (file)
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -1,39 +1,42 @@
+use crate::utils::span_lint;
 use rustc::hir;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use syntax::codemap::Span;
-use utils::span_lint;
 
-/// **What it does:** This lint checks for plain integer arithmetic
+/// **What it does:** Checks for plain integer arithmetic.
 ///
 /// **Why is this bad?** This is only checked against overflow in debug builds.
 /// In some applications one wants explicitly checked, wrapping or saturating
 /// arithmetic.
 ///
-/// **Known problems:** None
+/// **Known problems:** None.
 ///
 /// **Example:**
 /// ```rust
 /// a + 1
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub INTEGER_ARITHMETIC,
-    "Any integer arithmetic statement"
+    restriction,
+    "any integer arithmetic statement"
 }
 
-/// **What it does:** This lint checks for float arithmetic
+/// **What it does:** Checks for float arithmetic.
 ///
 /// **Why is this bad?** For some embedded systems or kernel development, it
-/// can be useful to rule out floating-point numbers
+/// can be useful to rule out floating-point numbers.
 ///
-/// **Known problems:** None
+/// **Known problems:** None.
 ///
 /// **Example:**
 /// ```rust
 /// a + 1.0
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub FLOAT_ARITHMETIC,
-    "Any floating-point arithmetic statement"
+    restriction,
+    "any floating-point arithmetic statement"
 }
 
 #[derive(Copy, Clone, Default)]
@@ -47,19 +50,30 @@ fn get_lints(&self) -> LintArray {
     }
 }
 
-impl LateLintPass for Arithmetic {
-    fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
-        if let Some(_) = self.span {
+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() {
             return;
         }
         match expr.node {
-            hir::ExprBinary(ref op, ref l, ref r) => {
+            hir::ExprKind::Binary(ref op, ref l, ref r) => {
                 match op.node {
-                    hir::BiAnd | hir::BiOr | hir::BiBitAnd | hir::BiBitOr | hir::BiBitXor | hir::BiShl |
-                    hir::BiShr | hir::BiEq | hir::BiLt | hir::BiLe | hir::BiNe | hir::BiGe | hir::BiGt => return,
+                    hir::BinOpKind::And
+                    | hir::BinOpKind::Or
+                    | hir::BinOpKind::BitAnd
+                    | hir::BinOpKind::BitOr
+                    | hir::BinOpKind::BitXor
+                    | hir::BinOpKind::Shl
+                    | hir::BinOpKind::Shr
+                    | hir::BinOpKind::Eq
+                    | hir::BinOpKind::Lt
+                    | hir::BinOpKind::Le
+                    | hir::BinOpKind::Ne
+                    | hir::BinOpKind::Ge
+                    | hir::BinOpKind::Gt => return,
                     _ => (),
                 }
-                let (l_ty, r_ty) = (cx.tcx.expr_ty(l), cx.tcx.expr_ty(r));
+                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);
@@ -67,9 +81,9 @@ fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
                     self.span = Some(expr.span);
                 }
-            }
-            hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => {
-                let ty = cx.tcx.expr_ty(arg);
+            },
+            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);
@@ -77,12 +91,12 @@ fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
                     self.span = Some(expr.span);
                 }
-            }
+            },
             _ => (),
         }
     }
 
-    fn check_expr_post(&mut self, _: &LateContext, expr: &hir::Expr) {
+    fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
         if Some(expr.span) == self.span {
             self.span = None;
         }