Work in progress merging of use-implicit-booleaness checker

Author: Pierre-Sassoulas

doc/whatsnew/2/2.15/index.rst

@@ -19,10 +19,15 @@ New checkers
 Removed checkers
 ================
 
+* The compare to zero and compare to empty string checkers have been removed as they are now part of
+  the implicit booleaness checker, a default check.
+
 
 Extensions
 ==========
 
+* ``compare-to-zero`` and ``compare-to-empty-string`` have been renamed to ``use-implicit-booleaness-not-comparison``.
+ The content of the message now suggest what should be done like other implicit booleaness checks.
 
 False positives fixed
 =====================

pylint/checkers/refactoring/implicit_booleaness_checker.py

@@ -4,13 +4,21 @@
 
 from __future__ import annotations
 
+import itertools
+from collections.abc import Iterable
+from typing import Any
+
 import astroid
 from astroid import bases, nodes
 
 from pylint import checkers
 from pylint.checkers import utils
 
 
+def _is_constant_zero(node):
+    return isinstance(node, astroid.Const) and node.value == 0
+
+
 class ImplicitBooleanessChecker(checkers.BaseChecker):
     """Checks for incorrect usage of comparisons or len() inside conditions.
 
@@ -50,7 +58,6 @@ class ImplicitBooleanessChecker(checkers.BaseChecker):
     * comparison such as variable != empty_literal:
     """
 
-    # configuration section name
     name = "refactoring"
     msgs = {
         "C1802": (
@@ -64,11 +71,17 @@ class ImplicitBooleanessChecker(checkers.BaseChecker):
             {"old_names": [("C1801", "len-as-condition")]},
         ),
         "C1803": (
-            "'%s' can be simplified to '%s' as an empty sequence is falsey",
+            "'%s' can be simplified to '%s' as %s is falsey",
             "use-implicit-booleaness-not-comparison",
             "Used when Pylint detects that collection literal comparison is being "
             "used to check for emptiness; Use implicit booleaness instead"
             "of a collection classes; empty collections are considered as false",
+            {
+                "old_names": [
+                    ("C1901", "compare-to-empty-string"),
+                    ("C2001", "compare-to-zero"),
+                ]
+            },
         ),
     }
 
@@ -139,6 +152,80 @@ def visit_unaryop(self, node: nodes.UnaryOp) -> None:
     @utils.only_required_for_messages("use-implicit-booleaness-not-comparison")
     def visit_compare(self, node: nodes.Compare) -> None:
         self._check_use_implicit_booleaness_not_comparison(node)
+        self._check_compare_to_empty_string(node)
+        self._check_compare_to_zero(node)
+
+    def _check_compare_to_zero(self, node: nodes.Compare) -> None:
+        """Checks for comparisons to zero.
+
+        Most of the time you should use the fact that integers with a value of 0 are false.
+        An exception to this rule is when 0 is allowed in the program and has a
+        different meaning than None!
+        """
+        # pylint: disable=duplicate-code
+        _operators = ["!=", "==", "is not", "is"]
+        # note: astroid.Compare has the left most operand in node.left
+        # while the rest are a list of tuples in node.ops
+        # the format of the tuple is ('compare operator sign', node)
+        # here we squash everything into `ops` to make it easier for processing later
+        ops = [("", node.left)]
+        ops.extend(node.ops)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_ops))
+        for ops_idx in range(len(ops) - 2):
+            op_1 = ops[ops_idx]
+            op_2 = ops[ops_idx + 1]
+            op_3 = ops[ops_idx + 2]
+            error_detected = False
+
+            # 0 ?? X
+            if _is_constant_zero(op_1) and op_2 in _operators:
+                error_detected = True
+            # X ?? 0
+            elif op_2 in _operators and _is_constant_zero(op_3):
+                error_detected = True
+
+            if error_detected:
+                self.add_message(
+                    "compare-to-zero", args=("TODO", "TODO", "'0'"), node=node
+                )
+
+    def _check_compare_to_empty_string(self, node: nodes.Compare) -> None:
+        """Checks for comparisons to empty string.
+
+        Most of the time you should use the fact that empty strings are false.
+        An exception to this rule is when an empty string value is allowed in the program
+        and has a different meaning than None!
+        """
+        _operators = ["!=", "==", "is not", "is"]
+        # note: astroid.Compare has the left most operand in node.left
+        # while the rest are a list of tuples in node.ops
+        # the format of the tuple is ('compare operator sign', node)
+        # here we squash everything into `ops` to make it easier for processing later
+        ops = [("", node.left)]
+        ops.extend(node.ops)
+        iter_ops: Iterable[Any] = iter(ops)
+        ops = list(itertools.chain(*iter_ops))
+        for ops_idx in range(len(ops) - 2):
+            op_1 = ops[ops_idx]
+            op_2 = ops[ops_idx + 1]
+            op_3 = ops[ops_idx + 2]
+            error_detected = False
+
+            # x ?? ""
+            if utils.is_empty_str_literal(op_1) and op_2 in _operators:
+                error_detected = True
+                suggestion = op_3.name
+            # '' ?? X
+            elif op_2 in _operators and utils.is_empty_str_literal(op_3):
+                error_detected = True
+                suggestion = op_1.name
+            if error_detected:
+                self.add_message(
+                    "compare-to-empty-string",
+                    args=(node.as_string(), suggestion, "an empty string"),
+                    node=node,
+                )
 
     def _check_use_implicit_booleaness_not_comparison(
         self, node: nodes.Compare
@@ -199,10 +286,7 @@ def _check_use_implicit_booleaness_not_comparison(
                     )
                     self.add_message(
                         "use-implicit-booleaness-not-comparison",
-                        args=(
-                            original_comparison,
-                            suggestion,
-                        ),
+                        args=(original_comparison, suggestion, "an empty sequence"),
                         node=node,
                     )