Add improve-conditionals check in the CodeStyle extension

Author: cdce8p

doc/data/messages/i/improve-conditionals/bad.py

@@ -0,0 +1,4 @@
+def func(expr, node_cls):
+    # +1:[improve-conditional]
+    if not isinstance(expr, node_cls) or expr.attrname != "__init__":
+        ...

doc/data/messages/i/improve-conditionals/good.py

@@ -0,0 +1,3 @@
+def func(expr, node_cls):
+    if not (isinstance(expr, node_cls) and expr.attrname == "__init__"):
+        ...

doc/user_guide/checkers/extensions.rst

@@ -92,6 +92,8 @@ Code Style checker Messages
   Using math.inf or math.nan permits to benefit from typing and it is up to 4
   times faster than a float call (after the initial import of math). This check
   also catches typos in float calls as a side effect.
+:improve-conditionals (R6107): *Rewrite conditional expression to '%s'*
+  Rewrite negated if expressions to improve readability.
 
 
 .. _pylint.extensions.comparison_placement:

doc/user_guide/messages/messages_overview.rst

@@ -516,6 +516,7 @@ All messages in the refactor category:
    refactor/duplicate-code
    refactor/else-if-used
    refactor/empty-comment
+   refactor/improve-conditionals
    refactor/inconsistent-return-statements
    refactor/literal-comparison
    refactor/magic-value-comparison

doc/whatsnew/fragments/10600.new_check

@@ -0,0 +1,3 @@
+Add :ref:`improve-conditionals` check to the Code Style extension.
+
+Refs #10600

pylint/extensions/code_style.py

@@ -5,13 +5,14 @@
 from __future__ import annotations
 
 import difflib
+from copy import copy
 from typing import TYPE_CHECKING, TypeGuard, cast
 
 from astroid import nodes
 
 from pylint.checkers import BaseChecker, utils
 from pylint.checkers.utils import only_required_for_messages, safe_infer
-from pylint.interfaces import INFERENCE
+from pylint.interfaces import HIGH, INFERENCE
 
 if TYPE_CHECKING:
     from pylint.lint import PyLinter
@@ -82,6 +83,14 @@ class CodeStyleChecker(BaseChecker):
             "to 4 times faster than a float call (after the initial import of math). "
             "This check also catches typos in float calls as a side effect.",
         ),
+        "R6107": (
+            "Rewrite conditional expression to '%s'",
+            "improve-conditionals",
+            "Rewrite negated if expressions to improve readability.",
+            {
+                # "default_enabled": False,
+            },
+        ),
     }
     options = (
         (
@@ -356,6 +365,76 @@ def visit_assign(self, node: nodes.Assign) -> None:
                 confidence=INFERENCE,
             )
 
+    @staticmethod
+    def _can_be_inverted(node: nodes.NodeNG) -> bool:
+        match node:
+            case nodes.UnaryOp(op="not"):
+                return True
+            case nodes.Compare(
+                ops=[("!=" | "not in", _)]
+                | [("<" | "<=" | ">" | ">=", nodes.Const(value=int()))]
+            ):
+                return True
+        return False
+
+    @staticmethod
+    def _invert_node(node: nodes.NodeNG) -> nodes.NodeNG:
+        match node:
+            case nodes.UnaryOp(op="not"):
+                new_node = copy(node.operand)
+                new_node.parent = node
+                return new_node
+            case nodes.Compare(left=left, ops=[(op, n)]):
+                new_node = copy(node)
+                match op:
+                    case "!=":
+                        new_op = "=="
+                    case "not in":
+                        new_op = "in"
+                    case "<":
+                        new_op = ">="
+                    case "<=":
+                        new_op = ">"
+                    case ">":
+                        new_op = "<="
+                    case ">=":
+                        new_op = "<"
+                    case _:  # pragma: no cover
+                        raise AssertionError
+                new_node.postinit(left=left, ops=[(new_op, n)])
+                return new_node
+            case _:  # pragma: no cover
+                raise AssertionError
+
+    @only_required_for_messages("improve-conditionals")
+    def visit_boolop(self, node: nodes.BoolOp) -> None:
+        if node.op == "or" and all(self._can_be_inverted(val) for val in node.values):
+            new_boolop = copy(node)
+            new_boolop.op = "and"
+            new_boolop.postinit([self._invert_node(val) for val in node.values])
+
+            if isinstance(node.parent, nodes.UnaryOp) and node.parent.op == "not":
+                target_node = node.parent
+                new_node = new_boolop
+            else:
+                target_node = node
+                new_node = nodes.UnaryOp(
+                    op="not",
+                    lineno=0,
+                    col_offset=0,
+                    end_lineno=None,
+                    end_col_offset=None,
+                    parent=node.parent,
+                )
+                new_node.postinit(operand=new_boolop)
+
+            self.add_message(
+                "improve-conditionals",
+                node=target_node,
+                args=(new_node.as_string(),),
+                confidence=HIGH,
+            )
+
 
 def register(linter: PyLinter) -> None:
     linter.register_checker(CodeStyleChecker(linter))

tests/functional/ext/code_style/cs_improve_conditionals.py

@@ -0,0 +1,26 @@
+# pylint: disable=missing-docstring
+
+def f1(expr, node_cls, x, y, z):
+    if isinstance(expr, node_cls) and expr.attrname == "__init__":
+        ...
+    elif isinstance(expr, node_cls) or expr.attrname == "__init__":
+        ...
+    elif not isinstance(expr, node_cls) and expr.attrname == "__init__":
+        ...
+    elif not isinstance(expr, node_cls) and expr.attrname != "__init__":
+        ...
+    elif not isinstance(expr, node_cls) or expr.attrname == "__init__":
+        ...
+
+    if not isinstance(expr, node_cls) or expr.attrname != "__init__":  # [improve-conditionals]
+        ...
+    elif x > 0 or y >= 1:  # [improve-conditionals]
+        ...
+    elif x < 0 or y <= 1:  # [improve-conditionals]
+        ...
+    elif not x or y not in z:  # [improve-conditionals]
+        ...
+    elif not (not x or not y):  # [improve-conditionals]
+        ...
+    elif x and (not y or not z):  # [improve-conditionals]
+        ...

tests/functional/ext/code_style/cs_improve_conditionals.rc

@@ -0,0 +1,3 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style
+enable=improve-conditionals

tests/functional/ext/code_style/cs_improve_conditionals.txt

@@ -0,0 +1,6 @@
+improve-conditionals:15:7:15:68:f1:Rewrite conditional expression to 'not (isinstance(expr, node_cls) and expr.attrname == '__init__')':HIGH
+improve-conditionals:17:9:17:24:f1:Rewrite conditional expression to 'not (x <= 0 and y < 1)':HIGH
+improve-conditionals:19:9:19:24:f1:Rewrite conditional expression to 'not (x >= 0 and y > 1)':HIGH
+improve-conditionals:21:9:21:28:f1:Rewrite conditional expression to 'not (x and y in z)':HIGH
+improve-conditionals:23:9:23:29:f1:Rewrite conditional expression to 'x and y':HIGH
+improve-conditionals:25:16:25:30:f1:Rewrite conditional expression to 'not (y and z)':HIGH