Added checks for signed integers

Author: pmk21

clippy_lints/src/implicit_saturating_sub.rs

@@ -1,4 +1,4 @@
-use crate::utils::{higher, in_macro, span_lint_and_sugg};
+use crate::utils::{higher, in_macro, match_qpath, span_lint_and_sugg, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -50,41 +50,78 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitSaturatingSub {
         }
         if_chain! {
             if let Some((ref cond, ref then, None)) = higher::if_block(&expr);
+
             // Check if the conditional expression is a binary operation
-            if let ExprKind::Binary(ref op, ref left, ref right) = cond.kind;
+            if let ExprKind::Binary(ref op, ref cond_left, ref cond_right) = cond.kind;
+
+            // Check if the variable in the condition statement is an integer
+            if cx.tables.expr_ty(cond_left).is_integral();
+
             // Ensure that the binary operator is > or !=
             if BinOpKind::Ne == op.node || BinOpKind::Gt == op.node;
-            if let ExprKind::Path(ref cond_path) = left.kind;
-            // Get the literal on the right hand side
-            if let ExprKind::Lit(ref lit) = right.kind;
-            if let LitKind::Int(0, _) = lit.node;
+
             // Check if the true condition block has only one statement
             if let ExprKind::Block(ref block, _) = then.kind;
             if block.stmts.len() == 1;
+
             // Check if assign operation is done
             if let StmtKind::Semi(ref e) = block.stmts[0].kind;
             if let ExprKind::AssignOp(ref op1, ref target, ref value) = e.kind;
             if BinOpKind::Sub == op1.node;
             if let ExprKind::Path(ref assign_path) = target.kind;
+
             // Check if the variable in the condition and assignment statement are the same
-            if let (QPath::Resolved(_, ref cres_path), QPath::Resolved(_, ref ares_path)) = (cond_path, assign_path);
-            if cres_path.res == ares_path.res;
+            if SpanlessEq::new(cx).eq_expr(cond_left, target);
+
+            // Extracting out the variable name
+            if let QPath::Resolved(_, ref ares_path) = assign_path;
+
+            // Get the literal being subtracted
             if let ExprKind::Lit(ref lit1) = value.kind;
-            if let LitKind::Int(assign_lit, _) = lit1.node;
+            if let LitKind::Int(1, _) = lit1.node;
+
             then {
                 // Get the variable name
-                let var_name = ares_path.segments[0].ident.name.as_str();
-                let applicability = Applicability::MaybeIncorrect;
-                span_lint_and_sugg(
-                    cx,
-                    IMPLICIT_SATURATING_SUB,
-                    expr.span,
-                    "Implicitly performing saturating subtraction",
-                    "try",
-                    format!("{} = {}.saturating_sub({});", var_name, var_name, assign_lit.to_string()),
-                    applicability
-                );
+                let var_name = ares_path.segments[0].ident.name.as_str().to_string();
+
+                match cond_right.kind {
+                    ExprKind::Lit(ref cond_lit) => {
+                        // Check if the constant is zero
+                        if let LitKind::Int(0, _) = cond_lit.node {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        } else {
+                            return;
+                        }
+                    },
+                    ExprKind::Path(ref cond_right_path) => {
+                        if match_qpath(cond_right_path, &["i8", "MIN"]) {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        } else if match_qpath(cond_right_path, &["i16", "MIN"]) {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        } else if match_qpath(cond_right_path, &["i32", "MIN"]) {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        } else if match_qpath(cond_right_path, &["i64", "MIN"]) {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        } else {
+                            return;
+                        }
+                    },
+                    _ => (),
+                }
             }
         }
     }
 }
+
+fn print_lint_and_sugg(cx: &LateContext<'_, '_>, var_name: String, expr: &Expr<'_>) {
+    let applicability = Applicability::MaybeIncorrect;
+    span_lint_and_sugg(
+        cx,
+        IMPLICIT_SATURATING_SUB,
+        expr.span,
+        "Implicitly performing saturating subtraction",
+        "try",
+        format!("{} = {}.saturating_sub({});", var_name, var_name, 1.to_string()),
+        applicability,
+    );
+}