Use match statement in checkers (6) (#10552)

Author: cdce8p

pylint/checkers/classes/class_checker.py

@@ -167,15 +167,15 @@ def _is_trivial_super_delegation(function: nodes.FunctionDef) -> bool:
         return False
 
     call = statement.value
-    if (
-        not isinstance(call, nodes.Call)
-        # Not a super() attribute access.
-        or not isinstance(call.func, nodes.Attribute)
-    ):
-        return False
+    match call := statement.value:
+        case nodes.Call(func=nodes.Attribute(expr=expr)):
+            pass
+        case _:
+            # Not a super() attribute access.
+            return False
 
     # Anything other than a super call is non-trivial.
-    super_call = safe_infer(call.func.expr)
+    super_call = safe_infer(expr)
     if not isinstance(super_call, astroid.objects.Super):
         return False
 
@@ -1844,33 +1844,27 @@ def _check_classmethod_declaration(self, node: nodes.Assign) -> None:
         is defined.
         `node` is an assign node.
         """
-        if not isinstance(node.value, nodes.Call):
-            return
-
         # check the function called is "classmethod" or "staticmethod"
-        func = node.value.func
-        if not isinstance(func, nodes.Name) or func.name not in (
-            "classmethod",
-            "staticmethod",
-        ):
-            return
+        # Check if the arg passed to classmethod is a class member
+        match node.value:
+            case nodes.Call(
+                func=nodes.Name(name="classmethod" | "staticmethod" as name),
+                args=[nodes.Name(name=method_name), *_],
+            ):
+                pass
+            case _:
+                return
 
         msg = (
             "no-classmethod-decorator"
-            if func.name == "classmethod"
+            if name == "classmethod"
             else "no-staticmethod-decorator"
         )
         # assignment must be at a class scope
         parent_class = node.scope()
         if not isinstance(parent_class, nodes.ClassDef):
             return
 
-        # Check if the arg passed to classmethod is a class member
-        classmeth_arg = node.value.args[0]
-        if not isinstance(classmeth_arg, nodes.Name):
-            return
-
-        method_name = classmeth_arg.name
         if any(method_name == member.name for member in parent_class.mymethods()):
             self.add_message(msg, node=node.targets[0])
 
@@ -2383,16 +2377,16 @@ def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
             first_attr = self._first_attrs[-1]
         else:
             # It's possible the function was already unregistered.
-            closest_func = utils.get_node_first_ancestor_of_type(
+            match closest_func := utils.get_node_first_ancestor_of_type(
                 node, nodes.FunctionDef
-            )
-            if closest_func is None:
-                return False
-            if not closest_func.is_bound():
-                return False
-            if not closest_func.args.args:
-                return False
-            first_attr = closest_func.args.args[0].name
+            ):
+                case nodes.FunctionDef(
+                    args=nodes.Arguments(args=[nodes.AssignName(name=first_attr), *_])
+                ) if closest_func.is_bound():
+                    pass
+                case _:
+                    return False
+        # pylint: disable=possibly-used-before-assignment
         return isinstance(node, nodes.Name) and node.name == first_attr
 
 

pylint/checkers/deprecated.py

@@ -251,13 +251,12 @@ def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> N
         if not isinstance(inferred, ACCEPTABLE_NODES):
             return
 
-        if isinstance(node.func, nodes.Attribute):
-            func_name = node.func.attrname
-        elif isinstance(node.func, nodes.Name):
-            func_name = node.func.name
-        else:
-            # Not interested in other nodes.
-            return
+        match node.func:
+            case nodes.Attribute(attrname=func_name) | nodes.Name(name=func_name):
+                pass
+            case _:
+                # Not interested in other nodes.
+                return
 
         qnames = {inferred.qname(), func_name}
         if any(name in self.deprecated_methods() for name in qnames):

pylint/checkers/design_analysis.py

@@ -203,12 +203,11 @@ def _is_exempt_from_public_methods(node: astroid.ClassDef) -> bool:
     for decorator in node.decorators.nodes:
         if isinstance(decorator, astroid.Call):
             decorator = decorator.func
-        if not isinstance(decorator, (astroid.Name, astroid.Attribute)):
-            continue
-        if isinstance(decorator, astroid.Name):
-            name = decorator.name
-        else:
-            name = decorator.attrname
+        match decorator:
+            case astroid.Name(name=name) | astroid.Attribute(attrname=name):
+                pass
+            case _:
+                continue
         if name in DATACLASSES_DECORATORS and (
             root_locals.intersection(DATACLASSES_DECORATORS)
             or DATACLASS_IMPORT in root_locals

pylint/checkers/newstyle.py

@@ -59,22 +59,17 @@ def visit_functiondef(self, node: nodes.FunctionDef) -> None:
             if not isinstance(expr, nodes.Attribute):
                 continue
 
-            call = expr.expr
-            # skip the test if using super
-            if not (
-                isinstance(call, nodes.Call)
-                and isinstance(call.func, nodes.Name)
-                and call.func.name == "super"
-            ):
-                continue
-
-            # super first arg should not be the class
-            if not call.args:
-                continue
+            match call := expr.expr:
+                case nodes.Call(func=nodes.Name(name="super"), args=[arg0, *_]):
+                    pass
+                case _:
+                    # skip the test if using super
+                    # super first arg should not be the class
+                    continue
 
             # calling super(type(self), self) can lead to recursion loop
             # in derived classes
-            match call.args[0]:
+            match arg0:
                 case nodes.Call(func=nodes.Name(name="type")):
                     self.add_message("bad-super-call", node=call, args=("type",))
                     continue

pylint/checkers/refactoring/recommendation_checker.py

@@ -210,15 +210,14 @@ def _check_consider_using_enumerate(self, node: nodes.For) -> None:
             return
 
         # Is it a proper len call?
-        if not isinstance(node.iter.args[-1], nodes.Call):
-            return
-        second_func = node.iter.args[-1].func
-        if not self._is_builtin(second_func, "len"):
-            return
-        len_args = node.iter.args[-1].args
-        if not len_args or len(len_args) != 1:
-            return
-        iterating_object = len_args[0]
+        match node.iter.args:
+            case [
+                *_,
+                nodes.Call(func=second_func, args=[iterating_object]),
+            ] if self._is_builtin(second_func, "len"):
+                pass
+            case _:
+                return
         if isinstance(iterating_object, nodes.Name):
             expected_subscript_val_type = nodes.Name
         elif isinstance(iterating_object, nodes.Attribute):