[arithmetic_side_effects] Fix #10590

Author: c410-f3r

clippy_lints/src/operators/arithmetic_side_effects.rs

@@ -184,6 +184,34 @@ impl ArithmeticSideEffects {
         }
     }
 
+    /// There are some integer methods like `wrapping_div` that will panic depending on the
+    /// provided input.
+    fn manage_method_call<'tcx>(
+        &mut self,
+        args: &[hir::Expr<'tcx>],
+        cx: &LateContext<'tcx>,
+        instance: &hir::Expr<'tcx>,
+        ps: &hir::PathSegment<'tcx>,
+    ) {
+        const METHODS: &[&str] = &["wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
+        let Some(arg) = args.first() else { return; };
+        if constant_simple(cx, cx.typeck_results(), instance).is_some() {
+            return;
+        }
+        let instance_ty = cx.typeck_results().expr_ty(instance);
+        if !Self::is_integral(instance_ty) {
+            return;
+        }
+        let has_method = METHODS.iter().copied().any(|method| method == ps.ident.as_str());
+        if !has_method {
+            return;
+        }
+        let (actual_arg, _) = peel_hir_expr_refs(arg);
+        if let Some(n) = Self::literal_integer(cx, actual_arg) && n == 0 {
+            self.issue_lint(cx, arg);
+        }
+    }
+
     fn manage_unary_ops<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -222,6 +250,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
             hir::ExprKind::AssignOp(op, lhs, rhs) | hir::ExprKind::Binary(op, lhs, rhs) => {
                 self.manage_bin_ops(cx, expr, op, lhs, rhs);
             },
+            hir::ExprKind::MethodCall(ps, instance, args, _) => {
+                self.manage_method_call(args, cx, instance, ps);
+            },
             hir::ExprKind::Unary(un_op, un_expr) => {
                 self.manage_unary_ops(cx, expr, un_expr, *un_op);
             },

tests/ui/arithmetic_side_effects.rs

@@ -269,6 +269,11 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = &1 * _n;
     _n = 23 + 85;
 
+    // Method
+    _n.wrapping_div(1);
+    _n.wrapping_rem(1);
+    _n.wrapping_rem_euclid(1);
+
     // Unary
     _n = -2147483647;
     _n = -i32::MAX;
@@ -376,6 +381,11 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     _custom = Custom << _custom;
     _custom = &Custom << _custom;
 
+    // Method
+    _n.wrapping_div(0);
+    _n.wrapping_rem(0);
+    _n.wrapping_rem_euclid(0);
+
     // Unary
     _n = -_n;
     _n = -&_n;