wire the lint up to operators/ logic

Author: ada4a

clippy_lints/src/declared_lints.rs

@@ -227,7 +227,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
     crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
-    crate::integer_division_remainder_used::INTEGER_DIVISION_REMAINDER_USED_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
     crate::item_name_repetitions::ENUM_VARIANT_NAMES_INFO,
     crate::item_name_repetitions::MODULE_INCEPTION_INFO,
@@ -591,6 +590,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::operators::IMPOSSIBLE_COMPARISONS_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
+    crate::operators::INTEGER_DIVISION_REMAINDER_USED_INFO,
     crate::operators::MANUAL_DIV_CEIL_INFO,
     crate::operators::MANUAL_IS_MULTIPLE_OF_INFO,
     crate::operators::MANUAL_MIDPOINT_INFO,

clippy_lints/src/lib.rs

@@ -796,7 +796,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_early_pass(|| Box::new(multiple_bound_locations::MultipleBoundLocations));
     store.register_late_pass(move |_| Box::new(assigning_clones::AssigningClones::new(conf)));
     store.register_late_pass(|_| Box::new(zero_repeat_side_effects::ZeroRepeatSideEffects));
-    store.register_late_pass(|_| Box::new(integer_division_remainder_used::IntegerDivisionRemainderUsed));
     store.register_late_pass(move |_| Box::new(macro_metavars_in_unsafe::ExprMetavarsInUnsafe::new(conf)));
     store.register_late_pass(move |_| Box::new(string_patterns::StringPatterns::new(conf)));
     store.register_early_pass(|| Box::new(field_scoped_visibility_modifiers::FieldScopedVisibilityModifiers));

clippy_lints/src/operators/integer_division_remainder_used.rs

@@ -1,50 +1,23 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::BinOpKind;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
 use rustc_middle::ty::{self};
-use rustc_session::declare_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of division (`/`) and remainder (`%`) operations
-    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
-    ///
-    /// ### Why restrict this?
-    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
-    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let my_div = 10 / 2;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let my_div = 10 >> 1;
-    /// ```
-    #[clippy::version = "1.79.0"]
-    pub INTEGER_DIVISION_REMAINDER_USED,
-    restriction,
-    "use of disallowed default division and remainder operations"
-}
-
-declare_lint_pass!(IntegerDivisionRemainderUsed => [INTEGER_DIVISION_REMAINDER_USED]);
+use super::INTEGER_DIVISION_REMAINDER_USED;
 
-impl LateLintPass<'_> for IntegerDivisionRemainderUsed {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let ExprKind::Binary(op, lhs, rhs) = &expr.kind
-            && let BinOpKind::Div | BinOpKind::Rem = op.node
-            && let lhs_ty = cx.typeck_results().expr_ty(lhs)
-            && let rhs_ty = cx.typeck_results().expr_ty(rhs)
-            && let ty::Int(_) | ty::Uint(_) = lhs_ty.peel_refs().kind()
-            && let ty::Int(_) | ty::Uint(_) = rhs_ty.peel_refs().kind()
-        {
-            span_lint(
-                cx,
-                INTEGER_DIVISION_REMAINDER_USED,
-                expr.span.source_callsite(),
-                format!("use of {} has been disallowed in this context", op.node.as_str()),
-            );
-        }
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, op: BinOpKind, lhs: &Expr<'_>, rhs: &Expr<'_>) {
+    if let BinOpKind::Div | BinOpKind::Rem = op
+        && let lhs_ty = cx.typeck_results().expr_ty(lhs)
+        && let rhs_ty = cx.typeck_results().expr_ty(rhs)
+        && let ty::Int(_) | ty::Uint(_) = lhs_ty.peel_refs().kind()
+        && let ty::Int(_) | ty::Uint(_) = rhs_ty.peel_refs().kind()
+    {
+        span_lint(
+            cx,
+            INTEGER_DIVISION_REMAINDER_USED,
+            expr.span.source_callsite(),
+            format!("use of {} has been disallowed in this context", op.as_str()),
+        );
     }
 }

clippy_lints/src/operators/mod.rs

@@ -889,6 +889,29 @@ declare_clippy_lint! {
     "manually reimplementing `div_ceil`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of division (`/`) and remainder (`%`) operations
+    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
+    ///
+    /// ### Why restrict this?
+    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
+    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let my_div = 10 / 2;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let my_div = 10 >> 1;
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub INTEGER_DIVISION_REMAINDER_USED,
+    restriction,
+    "use of disallowed default division and remainder operations"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -963,6 +986,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
                 integer_division::check(cx, e, op.node, lhs, rhs);
+                integer_division_remainder_used::check(cx, e, op.node, lhs, rhs);
                 cmp_owned::check(cx, op.node, lhs, rhs);
                 float_cmp::check(cx, e, op.node, lhs, rhs);
                 modulo_one::check(cx, e, op.node, rhs);