Use match statement in checkers (4) (#10531)

Co-authored-by: Pierre Sassoulas <[email protected]>

Author: cdce8p

pylint/checkers/base/basic_checker.py

@@ -537,12 +537,11 @@ def visit_lambda(self, node: nodes.Lambda) -> None:
             # The body of the lambda must be a function call expression
             # for the lambda to be unnecessary.
             return
-        if isinstance(node.body.func, nodes.Attribute) and isinstance(
-            node.body.func.expr, nodes.Call
-        ):
-            # Chained call, the intermediate call might
-            # return something else (but we don't check that, yet).
-            return
+        match call.func:
+            case nodes.Attribute(expr=nodes.Call()):
+                # Chained call, the intermediate call might
+                # return something else (but we don't check that, yet).
+                return
 
         ordinary_args = list(node.args.args)
         new_call_args = list(self._filter_vararg(node, call.args))
@@ -683,14 +682,9 @@ def _check_misplaced_format_function(self, call_node: nodes.Call) -> None:
         if not expr:
             # we are doubtful on inferred type of node, so here just check if format
             # was called on print()
-            call_expr = call_node.func.expr
-            if not isinstance(call_expr, nodes.Call):
-                return
-            if (
-                isinstance(call_expr.func, nodes.Name)
-                and call_expr.func.name == "print"
-            ):
-                self.add_message("misplaced-format-function", node=call_node)
+            match call_node.func.expr:
+                case nodes.Call(func=nodes.Name(name="print")):
+                    self.add_message("misplaced-format-function", node=call_node)
 
     @utils.only_required_for_messages(
         "eval-used",

pylint/checkers/base/comparison_checker.py

@@ -185,36 +185,37 @@ def _check_literal_comparison(
         self, literal: nodes.NodeNG, node: nodes.Compare
     ) -> None:
         """Check if we compare to a literal, which is usually what we do not want to do."""
-        is_other_literal = isinstance(literal, (nodes.List, nodes.Dict, nodes.Set))
-        is_const = False
-        if isinstance(literal, nodes.Const):
-            if isinstance(literal.value, bool) or literal.value is None:
+        match literal:
+            case nodes.Const(value=bool() | None):
                 # Not interested in these values.
                 return
-            is_const = isinstance(literal.value, (bytes, str, int, float))
-
-        if is_const or is_other_literal:
-            incorrect_node_str = node.as_string()
-            if "is not" in incorrect_node_str:
-                equal_or_not_equal = "!="
-                is_or_is_not = "is not"
-            else:
-                equal_or_not_equal = "=="
-                is_or_is_not = "is"
-            fixed_node_str = incorrect_node_str.replace(
-                is_or_is_not, equal_or_not_equal
-            )
-            self.add_message(
-                "literal-comparison",
-                args=(
-                    incorrect_node_str,
-                    equal_or_not_equal,
-                    is_or_is_not,
-                    fixed_node_str,
-                ),
-                node=node,
-                confidence=HIGH,
-            )
+            case nodes.Const(value=bytes() | str() | int() | float()):
+                pass
+            case nodes.List() | nodes.Dict() | nodes.Set():
+                # Inline list, dict and set nodes
+                pass
+            case _:
+                return
+
+        incorrect_node_str = node.as_string()
+        if "is not" in incorrect_node_str:
+            equal_or_not_equal = "!="
+            is_or_is_not = "is not"
+        else:
+            equal_or_not_equal = "=="
+            is_or_is_not = "is"
+        fixed_node_str = incorrect_node_str.replace(is_or_is_not, equal_or_not_equal)
+        self.add_message(
+            "literal-comparison",
+            args=(
+                incorrect_node_str,
+                equal_or_not_equal,
+                is_or_is_not,
+                fixed_node_str,
+            ),
+            node=node,
+            confidence=HIGH,
+        )
 
     def _check_logical_tautology(self, node: nodes.Compare) -> None:
         """Check if identifier is compared against itself.

pylint/checkers/classes/class_checker.py

@@ -914,17 +914,16 @@ def _check_declare_non_slot(self, node: nodes.ClassDef) -> None:
         # Every class in bases has __slots__, our __slots__ is non-empty and there is no __dict__
 
         for child in node.body:
-            if isinstance(child, nodes.AnnAssign):
-                if child.value is not None:
-                    continue
-                if isinstance(child.target, nodes.AssignName):
-                    if child.target.name not in slot_names:
-                        self.add_message(
-                            "declare-non-slot",
-                            args=child.target.name,
-                            node=child.target,
-                            confidence=INFERENCE,
-                        )
+            match child:
+                case nodes.AnnAssign(
+                    target=nodes.AssignName(name=name), value=None
+                ) if (name not in slot_names):
+                    self.add_message(
+                        "declare-non-slot",
+                        args=child.target.name,
+                        node=child.target,
+                        confidence=INFERENCE,
+                    )
 
     def _check_consistent_mro(self, node: nodes.ClassDef) -> None:
         """Detect that a class has a consistent mro or duplicate bases."""
@@ -936,31 +935,30 @@ def _check_consistent_mro(self, node: nodes.ClassDef) -> None:
             self.add_message("duplicate-bases", args=node.name, node=node)
 
     def _check_enum_base(self, node: nodes.ClassDef, ancestor: nodes.ClassDef) -> None:
-        members = ancestor.getattr("__members__")
-        if members and isinstance(members[0], nodes.Dict) and members[0].items:
-            for _, name_node in members[0].items:
-                # Exempt type annotations without value assignments
-                if all(
-                    isinstance(item.parent, nodes.AnnAssign)
-                    and item.parent.value is None
-                    for item in ancestor.getattr(name_node.name)
-                ):
-                    continue
-                self.add_message(
-                    "invalid-enum-extension",
-                    args=ancestor.name,
-                    node=node,
-                    confidence=INFERENCE,
-                )
-                break
+        match ancestor.getattr("__members__"):
+            case [nodes.Dict(items=items), *_] if items:
+                for _, name_node in items:
+                    # Exempt type annotations without value assignments
+                    if all(
+                        isinstance(item.parent, nodes.AnnAssign)
+                        and item.parent.value is None
+                        for item in ancestor.getattr(name_node.name)
+                    ):
+                        continue
+                    self.add_message(
+                        "invalid-enum-extension",
+                        args=ancestor.name,
+                        node=node,
+                        confidence=INFERENCE,
+                    )
+                    break
 
         if ancestor.is_subtype_of("enum.IntFlag"):
             # Collect integer flag assignments present on the class
             assignments = defaultdict(list)
             for assign_name in node.nodes_of_class(nodes.AssignName):
-                if isinstance(assign_name.parent, nodes.Assign):
-                    value = getattr(assign_name.parent.value, "value", None)
-                    if isinstance(value, int):
+                match assign_name.parent:
+                    case nodes.Assign(value=object(value=int() as value)):
                         assignments[value].append(assign_name)
 
             # For each bit position, collect all the flags that set the bit
@@ -1336,11 +1334,9 @@ def visit_functiondef(self, node: nodes.FunctionDef) -> None:
         try:
             overridden = klass.instance_attr(node.name)[0]
             overridden_frame = overridden.frame()
-            if (
-                isinstance(overridden_frame, nodes.FunctionDef)
-                and overridden_frame.type == "method"
-            ):
-                overridden_frame = overridden_frame.parent.frame()
+            match overridden_frame:
+                case nodes.FunctionDef(type="method"):
+                    overridden_frame = overridden_frame.parent.frame()
             if not (
                 isinstance(overridden_frame, nodes.ClassDef)
                 and klass.is_subtype_of(overridden_frame.qname())
@@ -1740,12 +1736,10 @@ def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
             inferred = safe_infer(node.parent.parent.value.elts[class_index])
         else:
             inferred = safe_infer(node.parent.value)
-        if (
-            isinstance(inferred, (nodes.ClassDef, util.UninferableBase))
-            or inferred is None
-        ):
-            # If is uninferable, we allow it to prevent false positives
-            return
+        match inferred:
+            case nodes.ClassDef() | util.UninferableBase() | None:
+                # If uninferable, we allow it to prevent false positives
+                return
         self.add_message(
             "invalid-class-object",
             node=node,
@@ -1926,12 +1920,9 @@ def _check_protected_attribute_access(
         # through the class object or through super
 
         # If the expression begins with a call to super, that's ok.
-        if (
-            isinstance(node.expr, nodes.Call)
-            and isinstance(node.expr.func, nodes.Name)
-            and node.expr.func.name == "super"
-        ):
-            return
+        match node.expr:
+            case nodes.Call(func=nodes.Name(name="super")):
+                return
 
         # If the expression begins with a call to type(self), that's ok.
         if self._is_type_self_call(node.expr):
@@ -1960,14 +1951,10 @@ def _check_protected_attribute_access(
             # class A:
             #     b = property(lambda: self._b)
 
-            stmt = node.parent.statement()
-            if (
-                isinstance(stmt, nodes.Assign)
-                and len(stmt.targets) == 1
-                and isinstance(stmt.targets[0], nodes.AssignName)
-            ):
-                name = stmt.targets[0].name
-                if _is_attribute_property(name, klass):
+            match node.parent.statement():
+                case nodes.Assign(
+                    targets=[nodes.AssignName(name=name)]
+                ) if _is_attribute_property(name, klass):
                     return
 
             if (
@@ -2241,12 +2228,9 @@ def _check_init(self, node: nodes.FunctionDef, klass_node: nodes.ClassDef) -> No
             if not isinstance(expr, nodes.Attribute) or expr.attrname != "__init__":
                 continue
             # skip the test if using super
-            if (
-                isinstance(expr.expr, nodes.Call)
-                and isinstance(expr.expr.func, nodes.Name)
-                and expr.expr.func.name == "super"
-            ):
-                return
+            match expr.expr:
+                case nodes.Call(func=nodes.Name(name="super")):
+                    return
             # pylint: disable = too-many-try-statements
             try:
                 for klass in expr.expr.infer():

pylint/checkers/deprecated.py

@@ -290,9 +290,6 @@ def check_deprecated_class(
 
     def check_deprecated_class_in_call(self, node: nodes.Call) -> None:
         """Checks if call the deprecated class."""
-        if isinstance(node.func, nodes.Attribute) and isinstance(
-            node.func.expr, nodes.Name
-        ):
-            mod_name = node.func.expr.name
-            class_name = node.func.attrname
-            self.check_deprecated_class(node, mod_name, (class_name,))
+        match node.func:
+            case nodes.Attribute(expr=nodes.Name(name=mod_name), attrname=class_name):
+                self.check_deprecated_class(node, mod_name, (class_name,))

pylint/checkers/exceptions.py

@@ -229,16 +229,12 @@ def visit_name(self, node: nodes.Name) -> None:
     def visit_call(self, node: nodes.Call) -> None:
         if isinstance(node.func, nodes.Name):
             self.visit_name(node.func)
-        if (
-            len(node.args) > 1
-            and isinstance(node.args[0], nodes.Const)
-            and isinstance(node.args[0].value, str)
-        ):
-            msg = node.args[0].value
-            if "%" in msg or ("{" in msg and "}" in msg):
-                self._checker.add_message(
-                    "raising-format-tuple", node=self._node, confidence=HIGH
-                )
+        match node.args:
+            case [nodes.Const(value=str() as msg), _, *_]:
+                if "%" in msg or ("{" in msg and "}" in msg):
+                    self._checker.add_message(
+                        "raising-format-tuple", node=self._node, confidence=HIGH
+                    )
 
 
 class ExceptionRaiseLeafVisitor(BaseVisitor):

pylint/checkers/lambda_expressions.py

@@ -70,14 +70,15 @@ def visit_assign(self, node: nodes.Assign) -> None:
                         )
 
     def visit_namedexpr(self, node: nodes.NamedExpr) -> None:
-        if isinstance(node.target, nodes.AssignName) and isinstance(
-            node.value, nodes.Lambda
-        ):
-            self.add_message(
-                "unnecessary-lambda-assignment",
-                node=node.value,
-                confidence=HIGH,
-            )
+        match node:
+            case nodes.NamedExpr(
+                target=nodes.AssignName(), value=nodes.Lambda() as value
+            ):
+                self.add_message(
+                    "unnecessary-lambda-assignment",
+                    node=value,
+                    confidence=HIGH,
+                )
 
     def visit_call(self, node: nodes.Call) -> None:
         """Check if lambda expression is called directly."""

pylint/checkers/newstyle.py

@@ -74,26 +74,23 @@ def visit_functiondef(self, node: nodes.FunctionDef) -> None:
 
             # calling super(type(self), self) can lead to recursion loop
             # in derived classes
-            arg0 = call.args[0]
-            if (
-                isinstance(arg0, nodes.Call)
-                and isinstance(arg0.func, nodes.Name)
-                and arg0.func.name == "type"
-            ):
-                self.add_message("bad-super-call", node=call, args=("type",))
-                continue
+            match call.args[0]:
+                case nodes.Call(func=nodes.Name(name="type")):
+                    self.add_message("bad-super-call", node=call, args=("type",))
+                    continue
 
             # calling super(self.__class__, self) can lead to recursion loop
             # in derived classes
-            if (
-                len(call.args) >= 2
-                and isinstance(call.args[1], nodes.Name)
-                and call.args[1].name == "self"
-                and isinstance(arg0, nodes.Attribute)
-                and arg0.attrname == "__class__"
-            ):
-                self.add_message("bad-super-call", node=call, args=("self.__class__",))
-                continue
+            match call.args:
+                case [
+                    nodes.Attribute(attrname="__class__"),
+                    nodes.Name(name="self"),
+                    *_,
+                ]:
+                    self.add_message(
+                        "bad-super-call", node=call, args=("self.__class__",)
+                    )
+                    continue
 
             try:
                 supcls = call.args and next(call.args[0].infer(), None)