Use match statement in checkers (5) (#10544)

Author: cdce8p

pylint/checkers/base/comparison_checker.py

@@ -145,20 +145,19 @@ def _check_nan_comparison(
     ) -> None:
         def _is_float_nan(node: nodes.NodeNG) -> bool:
             try:
-                if isinstance(node, nodes.Call) and len(node.args) == 1:
-                    if (
-                        node.args[0].value.lower() == "nan"
-                        and node.inferred()[0].pytype() == "builtins.float"
+                match node:
+                    case nodes.Call(args=[nodes.Const(value=str(value))]) if (
+                        value.lower() == "nan"
                     ):
-                        return True
+                        return node.inferred()[0].pytype() == "builtins.float"  # type: ignore[no-any-return]
                 return False
             except AttributeError:
                 return False
 
         def _is_numpy_nan(node: nodes.NodeNG) -> bool:
-            if isinstance(node, nodes.Attribute) and node.attrname == "NaN":
-                if isinstance(node.expr, nodes.Name):
-                    return node.expr.name in {"numpy", "nmp", "np"}
+            match node:
+                case nodes.Attribute(attrname="NaN", expr=nodes.Name(name=name)):
+                    return name in {"numpy", "nmp", "np"}
             return False
 
         def _is_nan(node: nodes.NodeNG) -> bool:

pylint/checkers/classes/class_checker.py

@@ -1980,13 +1980,10 @@ def _is_called_inside_special_method(node: nodes.NodeNG) -> bool:
         return frame_name and frame_name in PYMETHODS
 
     def _is_type_self_call(self, expr: nodes.NodeNG) -> bool:
-        return (
-            isinstance(expr, nodes.Call)
-            and isinstance(expr.func, nodes.Name)
-            and expr.func.name == "type"
-            and len(expr.args) == 1
-            and self._is_mandatory_method_param(expr.args[0])
-        )
+        match expr:
+            case nodes.Call(func=nodes.Name(name="type"), args=[arg]):
+                return self._is_mandatory_method_param(arg)
+        return False
 
     @staticmethod
     def _is_classmethod(func: LocalsDictNodeNG) -> bool:

pylint/checkers/logging.py

@@ -192,11 +192,10 @@ def visit_call(self, node: nodes.Call) -> None:
         """Checks calls to logging methods."""
 
         def is_logging_name() -> bool:
-            return (
-                isinstance(node.func, nodes.Attribute)
-                and isinstance(node.func.expr, nodes.Name)
-                and node.func.expr.name in self._logging_names
-            )
+            match node.func:
+                case nodes.Attribute(expr=nodes.Name(name=name)):
+                    return name in self._logging_names
+            return False
 
         def is_logger_class() -> tuple[bool, str | None]:
             for inferred in infer_all(node.func):

pylint/checkers/modified_iterating_checker.py

@@ -99,12 +99,10 @@ def _modified_iterating_check(
 
     @staticmethod
     def _is_node_expr_that_calls_attribute_name(node: nodes.NodeNG) -> bool:
-        return (
-            isinstance(node, nodes.Expr)
-            and isinstance(node.value, nodes.Call)
-            and isinstance(node.value.func, nodes.Attribute)
-            and isinstance(node.value.func.expr, nodes.Name)
-        )
+        match node:
+            case nodes.Expr(value=nodes.Call(func=nodes.Attribute(expr=nodes.Name()))):
+                return True
+        return False
 
     @staticmethod
     def _common_cond_list_set(
@@ -123,10 +121,10 @@ def _common_cond_list_set(
 
     @staticmethod
     def _is_node_assigns_subscript_name(node: nodes.NodeNG) -> bool:
-        return isinstance(node, nodes.Assign) and (
-            isinstance(node.targets[0], nodes.Subscript)
-            and (isinstance(node.targets[0].value, nodes.Name))
-        )
+        match node:
+            case nodes.Assign(targets=[nodes.Subscript(value=nodes.Name()), *_]):
+                return True
+        return False
 
     def _modified_iterating_list_cond(
         self, node: nodes.NodeNG, iter_obj: nodes.Name | nodes.Attribute

pylint/checkers/refactoring/refactoring_checker.py

@@ -826,14 +826,13 @@ def _check_superfluous_else_continue(self, node: nodes.If) -> None:
 
     @staticmethod
     def _type_and_name_are_equal(node_a: Any, node_b: Any) -> bool:
-        if isinstance(node_a, nodes.Name) and isinstance(node_b, nodes.Name):
-            return node_a.name == node_b.name  # type: ignore[no-any-return]
-        if isinstance(node_a, nodes.AssignName) and isinstance(
-            node_b, nodes.AssignName
-        ):
-            return node_a.name == node_b.name  # type: ignore[no-any-return]
-        if isinstance(node_a, nodes.Const) and isinstance(node_b, nodes.Const):
-            return node_a.value == node_b.value  # type: ignore[no-any-return]
+        match (node_a, node_b):
+            case (
+                [nodes.Name(name=a), nodes.Name(name=b)]
+                | [nodes.AssignName(name=a), nodes.AssignName(name=b)]
+                | [nodes.Const(value=a), nodes.Const(value=b)]
+            ):
+                return a == b  # type: ignore[no-any-return]
         return False
 
     def _is_dict_get_block(self, node: nodes.If) -> bool:
@@ -1568,12 +1567,10 @@ def visit_boolop(self, node: nodes.BoolOp) -> None:
 
     @staticmethod
     def _is_simple_assignment(node: nodes.NodeNG | None) -> bool:
-        return (
-            isinstance(node, nodes.Assign)
-            and len(node.targets) == 1
-            and isinstance(node.targets[0], nodes.AssignName)
-            and isinstance(node.value, nodes.Name)
-        )
+        match node:
+            case nodes.Assign(targets=[nodes.AssignName()], value=nodes.Name()):
+                return True
+        return False
 
     def _check_swap_variables(self, node: nodes.Return | nodes.Assign) -> None:
         if not node.next_sibling() or not node.next_sibling().next_sibling():
@@ -1901,16 +1898,12 @@ def _is_and_or_ternary(node: nodes.NodeNG | None) -> bool:
 
         All of: condition, true_value and false_value should not be a complex boolean expression
         """
-        return (
-            isinstance(node, nodes.BoolOp)
-            and node.op == "or"
-            and len(node.values) == 2
-            and isinstance(node.values[0], nodes.BoolOp)
-            and not isinstance(node.values[1], nodes.BoolOp)
-            and node.values[0].op == "and"
-            and not isinstance(node.values[0].values[1], nodes.BoolOp)
-            and len(node.values[0].values) == 2
-        )
+        match node:
+            case nodes.BoolOp(
+                op="or", values=[nodes.BoolOp(op="and", values=[_, v1]), v2]
+            ) if not (isinstance(v2, nodes.BoolOp) or isinstance(v1, nodes.BoolOp)):
+                return True
+        return False
 
     @staticmethod
     def _and_or_ternary_arguments(
@@ -2093,10 +2086,10 @@ def _is_function_def_never_returning(
         except AttributeError:
             return False  # the BoundMethod proxy may be a lambda without a returns
 
-        return (
-            isinstance(returns, nodes.Attribute)
-            and returns.attrname in {"NoReturn", "Never"}
-        ) or (isinstance(returns, nodes.Name) and returns.name in {"NoReturn", "Never"})
+        match returns:
+            case nodes.Attribute(attrname=name) | nodes.Name(name=name):
+                return name in {"NoReturn", "Never"}
+        return False
 
     def _check_return_at_the_end(self, node: nodes.FunctionDef) -> None:
         """Check for presence of a *single* return statement at the end of a

pylint/checkers/typecheck.py

@@ -1291,14 +1291,14 @@ def _is_ignored_function(
 
     @staticmethod
     def _is_builtin_no_return(node: nodes.Assign) -> bool:
-        return (
-            isinstance(node.value, nodes.Call)
-            and isinstance(node.value.func, nodes.Attribute)
-            and bool(inferred := utils.safe_infer(node.value.func.expr))
-            and isinstance(inferred, bases.Instance)
-            and node.value.func.attrname
-            in BUILTINS_IMPLICIT_RETURN_NONE.get(inferred.pytype(), ())
-        )
+        match node.value:
+            case nodes.Call(func=nodes.Attribute(expr=expr, attrname=attr)):
+                return (
+                    bool(inferred := utils.safe_infer(expr))
+                    and isinstance(inferred, bases.Instance)
+                    and attr in BUILTINS_IMPLICIT_RETURN_NONE.get(inferred.pytype(), ())
+                )
+        return False
 
     def _check_dundername_is_string(self, node: nodes.Assign) -> None:
         """Check a string is assigned to self.__name__."""

pylint/checkers/utils.py

@@ -1479,11 +1479,10 @@ def has_known_bases(
 
 
 def is_none(node: nodes.NodeNG) -> bool:
-    return (
-        node is None
-        or (isinstance(node, nodes.Const) and node.value is None)
-        or (isinstance(node, nodes.Name) and node.name == "None")
-    )
+    match node:
+        case None | nodes.Const(value=None) | nodes.Name(value="None"):
+            return True
+    return False
 
 
 def node_type(node: nodes.NodeNG) -> SuccessfulInferenceResult | None:
@@ -1696,11 +1695,10 @@ def is_protocol_class(cls: nodes.NodeNG) -> bool:
 
 def is_call_of_name(node: nodes.NodeNG, name: str) -> bool:
     """Checks if node is a function call with the given name."""
-    return (
-        isinstance(node, nodes.Call)
-        and isinstance(node.func, nodes.Name)
-        and node.func.name == name
-    )
+    match node:
+        case nodes.Call(func=nodes.Name(name=func_name)):
+            return func_name == name  # type: ignore[no-any-return]
+    return False
 
 
 def is_test_condition(
@@ -1885,12 +1883,10 @@ def is_deleted_after_current(node: nodes.NodeNG, varname: str) -> bool:
 
 def is_function_body_ellipsis(node: nodes.FunctionDef) -> bool:
     """Checks whether a function body only consists of a single Ellipsis."""
-    return (
-        len(node.body) == 1
-        and isinstance(node.body[0], nodes.Expr)
-        and isinstance(node.body[0].value, nodes.Const)
-        and node.body[0].value.value == Ellipsis
-    )
+    match node.body:
+        case [nodes.Expr(value=nodes.Const(value=value))]:
+            return value is Ellipsis
+    return False
 
 
 def is_base_container(node: nodes.NodeNG | None) -> bool:
@@ -1909,20 +1905,18 @@ def is_empty_str_literal(node: nodes.NodeNG | None) -> bool:
 
 def returns_bool(node: nodes.NodeNG) -> bool:
     """Returns true if a node is a nodes.Return that returns a constant boolean."""
-    return (
-        isinstance(node, nodes.Return)
-        and isinstance(node.value, nodes.Const)
-        and isinstance(node.value.value, bool)
-    )
+    match node:
+        case nodes.Return(value=nodes.Const(value=bool())):
+            return True
+    return False
 
 
 def assigned_bool(node: nodes.NodeNG) -> bool:
     """Returns true if a node is a nodes.Assign that returns a constant boolean."""
-    return (
-        isinstance(node, nodes.Assign)
-        and isinstance(node.value, nodes.Const)
-        and isinstance(node.value.value, bool)
-    )
+    match node:
+        case nodes.Assign(value=nodes.Const(value=bool())):
+            return True
+    return False
 
 
 def get_node_first_ancestor_of_type(
@@ -1993,18 +1987,15 @@ def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> boo
             except IndexError:
                 return False
 
-            if isinstance(import_from, nodes.ImportFrom):
-                return (
-                    import_from.modname == "typing"
-                    and import_from.real_name(node.name) in names_to_check
-                )
+            match import_from:
+                case nodes.ImportFrom(modname="typing"):
+                    return import_from.real_name(node.name) in names_to_check
+            return False
         case nodes.Attribute():
-            inferred_module = safe_infer(node.expr)
-            return (
-                isinstance(inferred_module, nodes.Module)
-                and inferred_module.name == "typing"
-                and node.attrname in names_to_check
-            )
+            match safe_infer(node.expr):
+                case nodes.Module(name="typing"):
+                    return node.attrname in names_to_check
+            return False
     return False
 
 

pylint/extensions/code_style.py

@@ -282,19 +282,11 @@ def _check_prev_sibling_to_if_stmt(
         if prev_sibling is None or prev_sibling.tolineno - prev_sibling.fromlineno != 0:
             return False
 
-        if (
-            isinstance(prev_sibling, nodes.Assign)
-            and len(prev_sibling.targets) == 1
-            and isinstance(prev_sibling.targets[0], nodes.AssignName)
-            and prev_sibling.targets[0].name == name
-        ):
-            return True
-        if (
-            isinstance(prev_sibling, nodes.AnnAssign)
-            and isinstance(prev_sibling.target, nodes.AssignName)
-            and prev_sibling.target.name == name
-        ):
-            return True
+        match prev_sibling:
+            case nodes.Assign(
+                targets=[nodes.AssignName(name=target_name)]
+            ) | nodes.AnnAssign(target=nodes.AssignName(name=target_name)):
+                return target_name == name  # type: ignore[no-any-return]
         return False
 
     @staticmethod

pylint/extensions/typing.py

@@ -300,11 +300,10 @@ def visit_subscript(self, node: nodes.Subscript) -> None:
     def _is_deprecated_union_annotation(
         annotation: nodes.NodeNG, union_name: str
     ) -> bool:
-        return (
-            isinstance(annotation, nodes.Subscript)
-            and isinstance(annotation.value, nodes.Name)
-            and annotation.value.name == union_name
-        )
+        match annotation:
+            case nodes.Subscript(value=nodes.Name(name=name)):
+                return name == union_name  # type: ignore[no-any-return]
+        return False
 
     def _is_binop_union_annotation(self, annotation: nodes.NodeNG) -> bool:
         return self._should_check_alternative_union_syntax and isinstance(