Move the lint to operators category

Author: Artur-Sulej

clippy_lints/src/declared_lints.rs

@@ -88,7 +88,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::crate_in_macro_def::CRATE_IN_MACRO_DEF_INFO,
     crate::create_dir::CREATE_DIR_INFO,
     crate::dbg_macro::DBG_MACRO_INFO,
-    crate::decimal_bitwise_operands::DECIMAL_BITWISE_OPERANDS_INFO,
     crate::default::DEFAULT_TRAIT_ACCESS_INFO,
     crate::default::FIELD_REASSIGN_WITH_DEFAULT_INFO,
     crate::default_constructed_unit_structs::DEFAULT_CONSTRUCTED_UNIT_STRUCTS_INFO,
@@ -579,6 +578,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::operators::ASSIGN_OP_PATTERN_INFO,
     crate::operators::BAD_BIT_MASK_INFO,
     crate::operators::CMP_OWNED_INFO,
+    crate::operators::DECIMAL_BITWISE_OPERANDS_INFO,
     crate::operators::DOUBLE_COMPARISONS_INFO,
     crate::operators::DURATION_SUBSEC_INFO,
     crate::operators::EQ_OP_INFO,

clippy_lints/src/lib.rs

@@ -96,7 +96,6 @@ mod copy_iterator;
 mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
-mod decimal_bitwise_operands;
 mod default;
 mod default_constructed_unit_structs;
 mod default_instead_of_iter_empty;
@@ -846,7 +845,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
         Box::new(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf))),
         Box::new(|_| Box::new(infallible_try_from::InfallibleTryFrom)),
         Box::new(|_| Box::new(coerce_container_to_any::CoerceContainerToAny)),
-        Box::new(|_| Box::new(decimal_bitwise_operands::DecimalBitwiseOperands)),
         Box::new(|_| Box::new(toplevel_ref_arg::ToplevelRefArg)),
         Box::new(|_| Box::new(volatile_composites::VolatileComposites)),
         Box::new(|_| Box::<replace_box::ReplaceBox>::default()),

clippy_lints/src/decimal_bitwise_operands.rs renamed to clippy_lints/src/operators/decimal_bitwise_operands.rs

@@ -3,34 +3,11 @@ use clippy_utils::source::SpanRangeExt;
 use rustc_ast::LitKind;
 use rustc_data_structures::packed::Pu128;
 use rustc_hir::{AssignOpKind, BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_lint::LateContext;
 use rustc_span::Span;
 use rustc_span::source_map::Spanned;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for decimal literals used as bit masks in bitwise operations.
-    ///
-    /// ### Why is this bad?
-    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
-    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// let a = 14 & 6; // Bit pattern is not immediately clear
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    /// let a = 0b1110 & 0b0110;
-    /// ```
-    #[clippy::version = "1.92.0"]
-    pub DECIMAL_BITWISE_OPERANDS,
-    nursery,
-    "use binary, hex, or octal literals for bitwise operations"
-}
-
-declare_lint_pass!(DecimalBitwiseOperands => [DECIMAL_BITWISE_OPERANDS]);
+use super::DECIMAL_BITWISE_OPERANDS;
 
 fn check_bitwise_binary_expr(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Binary(op, left, right) = &expr.kind
@@ -85,12 +62,10 @@ fn emit_lint(cx: &LateContext<'_>, span: Span) {
     );
 }
 
-impl<'tcx> LateLintPass<'tcx> for DecimalBitwiseOperands {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        check_bitwise_binary_expr(cx, expr);
-        check_bitwise_assign_expr(cx, expr);
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if expr.span.from_expansion() {
+        return;
     }
+    check_bitwise_binary_expr(cx, expr);
+    check_bitwise_assign_expr(cx, expr);
 }

clippy_lints/src/operators/mod.rs

@@ -3,6 +3,7 @@ mod assign_op_pattern;
 mod bit_mask;
 mod cmp_owned;
 mod const_comparisons;
+mod decimal_bitwise_operands;
 mod double_comparison;
 mod duration_subsec;
 mod eq_op;
@@ -935,6 +936,28 @@ declare_clippy_lint! {
     "use of disallowed default division and remainder operations"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for decimal literals used as bit masks in bitwise operations.
+    ///
+    /// ### Why is this bad?
+    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
+    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// let a = 14 & 6; // Bit pattern is not immediately clear
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// let a = 0b1110 & 0b0110;
+    /// ```
+    #[clippy::version = "1.93.0"]
+    pub DECIMAL_BITWISE_OPERANDS,
+    nursery,
+    "use binary, hex, or octal literals for bitwise operations"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -984,6 +1007,7 @@ impl_lint_pass!(Operators => [
     MANUAL_IS_MULTIPLE_OF,
     MANUAL_DIV_CEIL,
     INVALID_UPCAST_COMPARISONS,
+    DECIMAL_BITWISE_OPERANDS
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Operators {
@@ -1003,6 +1027,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     needless_bitwise_bool::check(cx, e, op.node, lhs, rhs);
                     manual_midpoint::check(cx, e, op.node, lhs, rhs, self.msrv);
                     manual_is_multiple_of::check(cx, e, op.node, lhs, rhs, self.msrv);
+                    decimal_bitwise_operands::check(cx, e);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
@@ -1027,6 +1052,9 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 manual_div_ceil::check(cx, e, op.node, lhs, rhs, self.msrv);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
+                if !e.span.from_expansion() {
+                    decimal_bitwise_operands::check(cx, e);
+                }
                 let bin_op = op.node.into();
                 self.arithmetic_context.check_binary(cx, e, bin_op, lhs, rhs);
                 misrefactored_assign_op::check(cx, e, bin_op, lhs, rhs);