Use match statement in checkers (3) (#10529)

Author: cdce8p

pylint/checkers/base/basic_checker.py

@@ -367,9 +367,7 @@ def _check_using_constant_test(
                 # Just forcing the generator to infer all elements.
                 # astroid.exceptions.InferenceError are false positives
                 # see https://github.com/pylint-dev/pylint/pull/8185
-                if isinstance(inferred, nodes.FunctionDef):
-                    call_inferred = list(inferred.infer_call_result(node))
-                elif isinstance(inferred, nodes.Lambda):
+                if isinstance(inferred, (nodes.FunctionDef, nodes.Lambda)):
                     call_inferred = list(inferred.infer_call_result(node))
             except astroid.InferenceError:
                 call_inferred = None
@@ -711,37 +709,36 @@ def visit_call(self, node: nodes.Call) -> None:
             # ignore the name if it's not a builtin (i.e. not defined in the
             # locals nor globals scope)
             if not (name in node.frame() or name in node.root()):
-                if name == "exec":
-                    self.add_message("exec-used", node=node)
-                elif name == "reversed":
-                    self._check_reversed(node)
-                elif name == "eval":
-                    self.add_message("eval-used", node=node)
+                match name:
+                    case "exec":
+                        self.add_message("exec-used", node=node)
+                    case "reversed":
+                        self._check_reversed(node)
+                    case "eval":
+                        self.add_message("eval-used", node=node)
 
     @utils.only_required_for_messages("assert-on-tuple", "assert-on-string-literal")
     def visit_assert(self, node: nodes.Assert) -> None:
         """Check whether assert is used on a tuple or string literal."""
-        if isinstance(node.test, nodes.Tuple) and len(node.test.elts) > 0:
-            self.add_message("assert-on-tuple", node=node, confidence=HIGH)
-
-        if isinstance(node.test, nodes.Const) and isinstance(node.test.value, str):
-            if node.test.value:
-                when = "never"
-            else:
-                when = "always"
-            self.add_message("assert-on-string-literal", node=node, args=(when,))
+        match node.test:
+            case nodes.Tuple(elts=elts) if len(elts) > 0:
+                self.add_message("assert-on-tuple", node=node, confidence=HIGH)
+            case nodes.Const(value=str(val)):
+                when = "never" if val else "always"
+                self.add_message("assert-on-string-literal", node=node, args=(when,))
 
     @utils.only_required_for_messages("duplicate-key")
     def visit_dict(self, node: nodes.Dict) -> None:
         """Check duplicate key in dictionary."""
         keys = set()
         for k, _ in node.items:
-            if isinstance(k, nodes.Const):
-                key = k.value
-            elif isinstance(k, nodes.Attribute):
-                key = k.as_string()
-            else:
-                continue
+            match k:
+                case nodes.Const():
+                    key = k.value
+                case nodes.Attribute():
+                    key = k.as_string()
+                case _:
+                    continue
             if key in keys:
                 self.add_message("duplicate-key", node=node, args=key)
             keys.add(key)
@@ -827,41 +824,42 @@ def _check_reversed(self, node: nodes.Call) -> None:
         except utils.NoSuchArgumentError:
             pass
         else:
-            if isinstance(argument, util.UninferableBase):
-                return
-            if argument is None:
-                # Nothing was inferred.
-                # Try to see if we have iter().
-                if isinstance(node.args[0], nodes.Call):
-                    try:
-                        func = next(node.args[0].func.infer())
-                    except astroid.InferenceError:
-                        return
-                    if getattr(
-                        func, "name", None
-                    ) == "iter" and utils.is_builtin_object(func):
-                        self.add_message("bad-reversed-sequence", node=node)
-                return
-
-            if isinstance(argument, (nodes.List, nodes.Tuple)):
-                return
+            match argument:
+                case util.UninferableBase():
+                    return
+                case None:
+                    # Nothing was inferred.
+                    # Try to see if we have iter().
+                    if isinstance(node.args[0], nodes.Call):
+                        try:
+                            func = next(node.args[0].func.infer())
+                        except astroid.InferenceError:
+                            return
+                        if getattr(
+                            func, "name", None
+                        ) == "iter" and utils.is_builtin_object(func):
+                            self.add_message("bad-reversed-sequence", node=node)
+                    return
 
-            # dicts are reversible, but only from Python 3.8 onward. Prior to
-            # that, any class based on dict must explicitly provide a
-            # __reversed__ method
-            if not self._py38_plus and isinstance(argument, astroid.Instance):
-                if any(
-                    ancestor.name == "dict" and utils.is_builtin_object(ancestor)
-                    for ancestor in itertools.chain(
-                        (argument._proxied,), argument._proxied.ancestors()
-                    )
-                ):
-                    try:
-                        argument.locals[REVERSED_PROTOCOL_METHOD]
-                    except KeyError:
-                        self.add_message("bad-reversed-sequence", node=node)
+                case nodes.List() | nodes.Tuple():
                     return
 
+                case astroid.Instance() if not self._py38_plus:
+                    # dicts are reversible, but only from Python 3.8 onward. Prior to
+                    # that, any class based on dict must explicitly provide a
+                    # __reversed__ method
+                    if any(
+                        ancestor.name == "dict" and utils.is_builtin_object(ancestor)
+                        for ancestor in itertools.chain(
+                            (argument._proxied,), argument._proxied.ancestors()
+                        )
+                    ):
+                        try:
+                            argument.locals[REVERSED_PROTOCOL_METHOD]
+                        except KeyError:
+                            self.add_message("bad-reversed-sequence", node=node)
+                        return
+
             if hasattr(argument, "getattr"):
                 # everything else is not a proper sequence for reversed()
                 for methods in REVERSED_METHODS:
@@ -910,15 +908,16 @@ def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
                 # Unpacking a variable into the same name.
                 return
 
-        if isinstance(node.value, nodes.Name):
-            if len(targets) != 1:
-                return
-            rhs_names = [node.value]
-        elif isinstance(node.value, nodes.Tuple):
-            rhs_count = len(node.value.elts)
-            if len(targets) != rhs_count or rhs_count == 1:
-                return
-            rhs_names = node.value.elts
+        match node.value:
+            case nodes.Name():
+                if len(targets) != 1:
+                    return
+                rhs_names = [node.value]
+            case nodes.Tuple():
+                rhs_count = len(node.value.elts)
+                if len(targets) != rhs_count or rhs_count == 1:
+                    return
+                rhs_names = node.value.elts
 
         for target, lhs_name in zip(targets, rhs_names):
             if not isinstance(lhs_name, nodes.Name):

pylint/checkers/base/basic_error_checker.py

@@ -218,26 +218,25 @@ def visit_classdef(self, node: nodes.ClassDef) -> None:
     def _too_many_starred_for_tuple(self, assign_tuple: nodes.Tuple) -> bool:
         starred_count = 0
         for elem in assign_tuple.itered():
-            if isinstance(elem, nodes.Tuple):
-                return self._too_many_starred_for_tuple(elem)
-            if isinstance(elem, nodes.Starred):
-                starred_count += 1
+            match elem:
+                case nodes.Tuple():
+                    return self._too_many_starred_for_tuple(elem)
+                case nodes.Starred():
+                    starred_count += 1
         return starred_count > 1
 
     @utils.only_required_for_messages(
         "too-many-star-expressions", "invalid-star-assignment-target"
     )
     def visit_assign(self, node: nodes.Assign) -> None:
-        # Check *a, *b = ...
-        assign_target = node.targets[0]
-        # Check *a = b
-        if isinstance(node.targets[0], nodes.Starred):
-            self.add_message("invalid-star-assignment-target", node=node)
-
-        if not isinstance(assign_target, nodes.Tuple):
-            return
-        if self._too_many_starred_for_tuple(assign_target):
-            self.add_message("too-many-star-expressions", node=node)
+        match assign_target := node.targets[0]:
+            case nodes.Starred():
+                # Check *a = b
+                self.add_message("invalid-star-assignment-target", node=node)
+            case nodes.Tuple():
+                # Check *a, *b = ...
+                if self._too_many_starred_for_tuple(assign_target):
+                    self.add_message("too-many-star-expressions", node=node)
 
     @utils.only_required_for_messages("star-needs-assignment-target")
     def visit_starred(self, node: nodes.Starred) -> None:

pylint/checkers/base/docstring_checker.py

@@ -191,12 +191,13 @@ def _check_docstring(
                     # Strings.
                     if func.bound.name in {"str", "unicode", "bytes"}:
                         return
-            if node_type == "module":
-                message = "missing-module-docstring"
-            elif node_type == "class":
-                message = "missing-class-docstring"
-            else:
-                message = "missing-function-docstring"
+            match node_type:
+                case "module":
+                    message = "missing-module-docstring"
+                case "class":
+                    message = "missing-class-docstring"
+                case _:
+                    message = "missing-function-docstring"
             self.add_message(message, node=node, confidence=confidence)
         elif not docstring.strip():
             if node_type == "class":

pylint/checkers/base/name_checker/checker.py

@@ -681,18 +681,19 @@ def _assigns_typealias(node: nodes.NodeNG | None) -> bool:
     def _check_typevar(self, name: str, node: nodes.AssignName) -> None:
         """Check for TypeVar lint violations."""
         variance: TypeVarVariance = TypeVarVariance.invariant
-        if isinstance(node.parent, nodes.Assign):
-            keywords = node.assign_type().value.keywords
-            args = node.assign_type().value.args
-        elif isinstance(node.parent, nodes.Tuple):
-            keywords = (
-                node.assign_type().value.elts[node.parent.elts.index(node)].keywords
-            )
-            args = node.assign_type().value.elts[node.parent.elts.index(node)].args
-        else:  # PEP 695 generic type nodes
-            keywords = ()
-            args = ()
-            variance = TypeVarVariance.inferred
+        match node.parent:
+            case nodes.Assign():
+                keywords = node.assign_type().value.keywords
+                args = node.assign_type().value.args
+            case nodes.Tuple():
+                keywords = (
+                    node.assign_type().value.elts[node.parent.elts.index(node)].keywords
+                )
+                args = node.assign_type().value.elts[node.parent.elts.index(node)].args
+            case _:  # PEP 695 generic type nodes
+                keywords = ()
+                args = ()
+                variance = TypeVarVariance.inferred
 
         name_arg = None
         for kw in keywords:
@@ -717,49 +718,48 @@ def _check_typevar(self, name: str, node: nodes.AssignName) -> None:
         if name_arg is None and args and isinstance(args[0], nodes.Const):
             name_arg = args[0].value
 
-        if variance == TypeVarVariance.inferred:
-            # Ignore variance check for PEP 695 type parameters.
-            # The variance is inferred by the type checker.
-            # Adding _co or _contra suffix can help to reason about TypeVar.
-            pass
-        elif variance == TypeVarVariance.double_variant:
-            self.add_message(
-                "typevar-double-variance",
-                node=node,
-                confidence=interfaces.INFERENCE,
-            )
-            self.add_message(
-                "typevar-name-incorrect-variance",
-                node=node,
-                args=("",),
-                confidence=interfaces.INFERENCE,
-            )
-        elif variance == TypeVarVariance.covariant and not name.endswith("_co"):
-            suggest_name = f"{re.sub('_contra$', '', name)}_co"
-            self.add_message(
-                "typevar-name-incorrect-variance",
-                node=node,
-                args=(f'. "{name}" is covariant, use "{suggest_name}" instead'),
-                confidence=interfaces.INFERENCE,
-            )
-        elif variance == TypeVarVariance.contravariant and not name.endswith("_contra"):
-            suggest_name = f"{re.sub('_co$', '', name)}_contra"
-            self.add_message(
-                "typevar-name-incorrect-variance",
-                node=node,
-                args=(f'. "{name}" is contravariant, use "{suggest_name}" instead'),
-                confidence=interfaces.INFERENCE,
-            )
-        elif variance == TypeVarVariance.invariant and (
-            name.endswith(("_co", "_contra"))
-        ):
-            suggest_name = re.sub("_contra$|_co$", "", name)
-            self.add_message(
-                "typevar-name-incorrect-variance",
-                node=node,
-                args=(f'. "{name}" is invariant, use "{suggest_name}" instead'),
-                confidence=interfaces.INFERENCE,
-            )
+        match variance:
+            case TypeVarVariance.inferred:
+                # Ignore variance check for PEP 695 type parameters.
+                # The variance is inferred by the type checker.
+                # Adding _co or _contra suffix can help to reason about TypeVar.
+                pass
+            case TypeVarVariance.double_variant:
+                self.add_message(
+                    "typevar-double-variance",
+                    node=node,
+                    confidence=interfaces.INFERENCE,
+                )
+                self.add_message(
+                    "typevar-name-incorrect-variance",
+                    node=node,
+                    args=("",),
+                    confidence=interfaces.INFERENCE,
+                )
+            case TypeVarVariance.covariant if not name.endswith("_co"):
+                suggest_name = f"{re.sub('_contra$', '', name)}_co"
+                self.add_message(
+                    "typevar-name-incorrect-variance",
+                    node=node,
+                    args=(f'. "{name}" is covariant, use "{suggest_name}" instead'),
+                    confidence=interfaces.INFERENCE,
+                )
+            case TypeVarVariance.contravariant if not name.endswith("_contra"):
+                suggest_name = f"{re.sub('_co$', '', name)}_contra"
+                self.add_message(
+                    "typevar-name-incorrect-variance",
+                    node=node,
+                    args=(f'. "{name}" is contravariant, use "{suggest_name}" instead'),
+                    confidence=interfaces.INFERENCE,
+                )
+            case TypeVarVariance.invariant if name.endswith(("_co", "_contra")):
+                suggest_name = re.sub("_contra$|_co$", "", name)
+                self.add_message(
+                    "typevar-name-incorrect-variance",
+                    node=node,
+                    args=(f'. "{name}" is invariant, use "{suggest_name}" instead'),
+                    confidence=interfaces.INFERENCE,
+                )
 
         if name_arg is not None and name_arg != name:
             self.add_message(