X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Farithmetic.rs;h=7653ba43459f2db068f24be9a778f71b2d65745c;hb=6d1225981177587fbb68d9c4902c770c3dbaafb0;hp=fa48b2b550612fb5587bc08a76e0eabdea339adf;hpb=9f0216d52070faeb4f49b7a7f1c898b8f053622f;p=rust.git diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index fa48b2b5506..7653ba43459 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -1,39 +1,43 @@ +use crate::consts::constant_simple; use crate::utils::span_lint; use rustc::hir; +use rustc::impl_lint_pass; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_tool_lint, lint_array}; +use rustc_session::declare_tool_lint; use syntax::source_map::Span; -/// **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. -/// -/// **Example:** -/// ```rust -/// a + 1 -/// ``` declare_clippy_lint! { + /// **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. + /// + /// **Example:** + /// ```rust + /// # let a = 0; + /// a + 1; + /// ``` pub INTEGER_ARITHMETIC, restriction, "any integer arithmetic statement" } -/// **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. -/// -/// **Known problems:** None. -/// -/// **Example:** -/// ```rust -/// a + 1.0 -/// ``` declare_clippy_lint! { + /// **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. + /// + /// **Known problems:** None. + /// + /// **Example:** + /// ```rust + /// # let a = 0.0; + /// a + 1.0; + /// ``` pub FLOAT_ARITHMETIC, restriction, "any floating-point arithmetic statement" @@ -41,22 +45,27 @@ #[derive(Copy, Clone, Default)] pub struct Arithmetic { - span: Option, + expr_span: Option, + /// This field is used to check whether expressions are constants, such as in enum discriminants + /// and consts + const_span: Option, } -impl LintPass for Arithmetic { - fn get_lints(&self) -> LintArray { - lint_array!(INTEGER_ARITHMETIC, FLOAT_ARITHMETIC) - } -} +impl_lint_pass!(Arithmetic => [INTEGER_ARITHMETIC, FLOAT_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; } - match expr.node { - hir::ExprKind::Binary(ref op, ref l, ref r) => { + + if let Some(span) = self.const_span { + if span.contains(expr.span) { + return; + } + } + match &expr.kind { + hir::ExprKind::Binary(op, l, r) | hir::ExprKind::AssignOp(op, l, r) => { match op.node { hir::BinOpKind::And | hir::BinOpKind::Or @@ -76,20 +85,22 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { 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) => { + hir::ExprKind::Unary(hir::UnOp::UnNeg, 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); - } else if ty.is_floating_point() { - span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); - self.span = Some(expr.span); + if constant_simple(cx, cx.tables, expr).is_none() { + if ty.is_integral() { + span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected"); + self.expr_span = Some(expr.span); + } else if ty.is_floating_point() { + span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); + self.expr_span = Some(expr.span); + } } }, _ => (), @@ -97,8 +108,38 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { } 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_body(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body<'_>) { + let body_owner = cx.tcx.hir().body_owner(body.id()); + + match cx.tcx.hir().body_owner_kind(body_owner) { + hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => { + let body_span = cx.tcx.hir().span(body_owner); + + if let Some(span) = self.const_span { + if span.contains(body_span) { + return; + } + } + self.const_span = Some(body_span); + }, + hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => (), + } + } + + fn check_body_post(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body<'_>) { + let body_owner = cx.tcx.hir().body_owner(body.id()); + let body_span = cx.tcx.hir().span(body_owner); + + if let Some(span) = self.const_span { + if span.contains(body_span) { + return; + } } + self.const_span = None; } }