clippy_lints/src/arithmetic.rs

   1 use rustc::hir;
   2 use rustc::lint::*;
   3 use syntax::codemap::Span;
   4 use utils::span_lint;
   5
   6 /// **What it does:** Checks for plain integer arithmetic.
   7 ///
   8 /// **Why is this bad?** This is only checked against overflow in debug builds.
   9 /// In some applications one wants explicitly checked, wrapping or saturating
  10 /// arithmetic.
  11 ///
  12 /// **Known problems:** None.
  13 ///
  14 /// **Example:**
  15 /// ```rust
  16 /// a + 1
  17 /// ```
  18 declare_restriction_lint! {
  19     pub INTEGER_ARITHMETIC,
  20     "any integer arithmetic statement"
  21 }
  22
  23 /// **What it does:** Checks for float arithmetic.
  24 ///
  25 /// **Why is this bad?** For some embedded systems or kernel development, it
  26 /// can be useful to rule out floating-point numbers.
  27 ///
  28 /// **Known problems:** None.
  29 ///
  30 /// **Example:**
  31 /// ```rust
  32 /// a + 1.0
  33 /// ```
  34 declare_restriction_lint! {
  35     pub FLOAT_ARITHMETIC,
  36     "any floating-point arithmetic statement"
  37 }
  38
  39 #[derive(Copy, Clone, Default)]
  40 pub struct Arithmetic {
  41     span: Option<Span>,
  42 }
  43
  44 impl LintPass for Arithmetic {
  45     fn get_lints(&self) -> LintArray {
  46         lint_array!(INTEGER_ARITHMETIC, FLOAT_ARITHMETIC)
  47     }
  48 }
  49
  50 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
  51     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
  52         if self.span.is_some() {
  53             return;
  54         }
  55         match expr.node {
  56             hir::ExprBinary(ref op, ref l, ref r) => {
  57                 match op.node {
  58                     hir::BiAnd | hir::BiOr | hir::BiBitAnd | hir::BiBitOr | hir::BiBitXor | hir::BiShl |
  59                     hir::BiShr | hir::BiEq | hir::BiLt | hir::BiLe | hir::BiNe | hir::BiGe | hir::BiGt => return,
  60                     _ => (),
  61                 }
  62                 let (l_ty, r_ty) = (cx.tables.expr_ty(l), cx.tables.expr_ty(r));
  63                 if l_ty.is_integral() && r_ty.is_integral() {
  64                     span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
  65                     self.span = Some(expr.span);
  66                 } else if l_ty.is_floating_point() && r_ty.is_floating_point() {
  67                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
  68                     self.span = Some(expr.span);
  69                 }
  70             },
  71             hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => {
  72                 let ty = cx.tables.expr_ty(arg);
  73                 if ty.is_integral() {
  74                     span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
  75                     self.span = Some(expr.span);
  76                 } else if ty.is_floating_point() {
  77                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
  78                     self.span = Some(expr.span);
  79                 }
  80             },
  81             _ => (),
  82         }
  83     }
  84
  85     fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
  86         if Some(expr.span) == self.span {
  87             self.span = None;
  88         }
  89     }
  90 }