Fix rust-lang#9544

Author: c410-f3r

clippy_lints/src/operators/arithmetic_side_effects.rs

@@ -16,8 +16,9 @@ const HARD_CODED_ALLOWED: &[&str] = &[
     "f32",
     "f64",
     "std::num::Saturating",
-    "std::string::String",
     "std::num::Wrapping",
+    "std::string::String",
+    "&str",
 ];
 
 #[derive(Debug)]
@@ -77,6 +78,11 @@ impl ArithmeticSideEffects {
         )
     }
 
+    // For example, 8i32 or &i64::MAX.
+    fn is_integral<'expr, 'tcx>(cx: &LateContext<'tcx>, expr: &'expr hir::Expr<'tcx>) -> bool {
+        cx.typeck_results().expr_ty(expr).peel_refs().is_integral()
+    }
+
     // Common entry-point to avoid code duplication.
     fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
         let msg = "arithmetic operation that can potentially result in unexpected side-effects";
@@ -88,24 +94,13 @@ impl ArithmeticSideEffects {
     /// * Is `expr` is a literal integer reference like `&199`, returns the literal integer without
     ///   references.
     /// * If `expr` is anything else, returns `None`.
-    fn literal_integer<'expr, 'tcx>(
-        cx: &LateContext<'tcx>,
-        expr: &'expr hir::Expr<'tcx>,
-    ) -> Option<&'expr hir::Expr<'tcx>> {
-        let expr_refs = cx.typeck_results().expr_ty(expr).peel_refs();
-
-        if !expr_refs.is_integral() {
-            return None;
-        }
-
+    fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<&'expr hir::Expr<'tcx>> {
         if matches!(expr.kind, hir::ExprKind::Lit(_)) {
             return Some(expr);
         }
-
         if let hir::ExprKind::AddrOf(.., inn) = expr.kind && let hir::ExprKind::Lit(_) = inn.kind {
             return Some(inn)
         }
-
         None
     }
 
@@ -134,14 +129,18 @@ impl ArithmeticSideEffects {
         ) {
             return;
         };
-        if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
+        if self.is_allowed_ty(cx, lhs) && self.is_allowed_ty(cx, rhs) {
             return;
         }
-        let has_valid_op = match (Self::literal_integer(cx, lhs), Self::literal_integer(cx, rhs)) {
-            (None, None) => false,
-            (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
-            (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
-            (Some(_), Some(_)) => true,
+        let has_valid_op = if Self::is_integral(cx, lhs) && Self::is_integral(cx, rhs) {
+            match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
+                (None, None) => false,
+                (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
+                (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
+                (Some(_), Some(_)) => true,
+            }
+        } else {
+            false
         };
         if !has_valid_op {
             self.issue_lint(cx, expr);

tests/ui/arithmetic_side_effects.rs

@@ -12,6 +12,31 @@
 
 use core::num::{Saturating, Wrapping};
 
+pub struct Custom;
+
+macro_rules! impl_arith {
+    ( $( $_trait:ident, $ty:ty, $method:ident; )* ) => {
+        $(
+            impl core::ops::$_trait<$ty> for Custom {
+                type Output = Self;
+                fn $method(self, _: $ty) -> Self::Output { Self }
+            }
+        )*
+    }
+}
+
+impl_arith!(
+    Add, i32, add;
+    Div, i32, div;
+    Mul, i32, mul;
+    Sub, i32, sub;
+
+    Add, f64, add;
+    Div, f64, div;
+    Mul, f64, mul;
+    Sub, f64, sub;
+);
+
 pub fn association_with_structures_should_not_trigger_the_lint() {
     enum Foo {
         Bar = -2,
@@ -130,7 +155,7 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = -(-1);
 }
 
-pub fn overflowing_runtime_ops() {
+pub fn runtime_ops() {
     let mut _n = i32::MAX;
 
     // Assign
@@ -163,6 +188,32 @@ pub fn overflowing_runtime_ops() {
     _n = 2 * _n;
     _n = &2 * _n;
 
+    // Custom
+    let _ = Custom + 0;
+    let _ = Custom + 1;
+    let _ = Custom + 2;
+    let _ = Custom + 0.0;
+    let _ = Custom + 1.0;
+    let _ = Custom + 2.0;
+    let _ = Custom - 0;
+    let _ = Custom - 1;
+    let _ = Custom - 2;
+    let _ = Custom - 0.0;
+    let _ = Custom - 1.0;
+    let _ = Custom - 2.0;
+    let _ = Custom / 0;
+    let _ = Custom / 1;
+    let _ = Custom / 2;
+    let _ = Custom / 0.0;
+    let _ = Custom / 1.0;
+    let _ = Custom / 2.0;
+    let _ = Custom * 0;
+    let _ = Custom * 1;
+    let _ = Custom * 2;
+    let _ = Custom * 0.0;
+    let _ = Custom * 1.0;
+    let _ = Custom * 2.0;
+
     // Unary
     _n = -_n;
     _n = -&_n;