teach eager_or_lazy that arithmetic ops can panic

Author: y21

clippy_utils/src/eager_or_lazy.rs

@@ -13,6 +13,7 @@ use crate::ty::{all_predicates_of, is_copy};
 use crate::visitors::is_const_evaluatable;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::BinOpKind;
 use rustc_hir::{def_id::DefId, Block, Expr, ExprKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::Adjust;
@@ -188,6 +189,12 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                         self.eagerness = Lazy;
                     }
                 },
+
+                // `-i32::MIN` panics with overflow checks
+                ExprKind::Unary(UnOp::Neg, expr) if self.cx.typeck_results().expr_ty(expr).is_signed() => {
+                    self.eagerness |= NoChange;
+                },
+
                 // Custom `Deref` impl might have side effects
                 ExprKind::Unary(UnOp::Deref, e)
                     if self.cx.typeck_results().expr_ty(e).builtin_deref(true).is_none() =>
@@ -202,6 +209,24 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                         self.cx.typeck_results().expr_ty(e).kind(),
                         ty::Bool | ty::Int(_) | ty::Uint(_),
                     ) => {},
+
+                // Arithmetic operations panic on under-/overflow with overflow checks, so don't suggest changing it:
+                // https://doc.rust-lang.org/stable/reference/expressions/operator-expr.html#overflow
+                ExprKind::Binary(op, ..)
+                    if matches!(
+                        op.node,
+                        BinOpKind::Add
+                            | BinOpKind::Mul
+                            | BinOpKind::Sub
+                            | BinOpKind::Div
+                            | BinOpKind::Rem
+                            | BinOpKind::Shl
+                            | BinOpKind::Shr
+                    ) =>
+                {
+                    self.eagerness |= NoChange;
+                },
+
                 ExprKind::Binary(_, lhs, rhs)
                     if self.cx.typeck_results().expr_ty(lhs).is_primitive()
                         && self.cx.typeck_results().expr_ty(rhs).is_primitive() => {},

tests/ui/unnecessary_lazy_eval.fixed

@@ -181,10 +181,22 @@ fn main() {
     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+
+    issue9422(3);
+    issue9422_v2(3);
 }
 
 #[allow(unused)]
 fn issue9485() {
     // should not lint, is in proc macro
     with_span!(span Some(42).unwrap_or_else(|| 2););
 }
+
+fn issue9422(x: usize) -> Option<usize> {
+    (x >= 5).then(|| x - 5)
+    // (x >= 5).then_some(x - 5)  // clippy suggestion panics
+}
+
+fn issue9422_v2(x: usize) -> Option<i32> {
+    (x >= 5).then(|| -i32::MAX) // .then_some(-i32::MAX) always panics
+}

tests/ui/unnecessary_lazy_eval.rs

@@ -181,10 +181,22 @@ fn main() {
     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+
+    issue9422(3);
+    issue9422_v2(3);
 }
 
 #[allow(unused)]
 fn issue9485() {
     // should not lint, is in proc macro
     with_span!(span Some(42).unwrap_or_else(|| 2););
 }
+
+fn issue9422(x: usize) -> Option<usize> {
+    (x >= 5).then(|| x - 5)
+    // (x >= 5).then_some(x - 5)  // clippy suggestion panics
+}
+
+fn issue9422_v2(x: usize) -> Option<i32> {
+    (x >= 5).then(|| -i32::MAX) // .then_some(-i32::MAX) always panics
+}