sarj-python-lint 1.83.0__tar.gz → 1.84.0__tar.gz

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.83.0
+Version: 1.84.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.83.0"
+version = "1.84.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/__main__.py

@@ -187,12 +187,13 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         # A proven external or nested request boundary already requires schema
         # validation at this field read. Retain standalone shape advice when
         # that more specific rule is unselected or locally suppressed.
-        "SARJ411": frozenset({"SARJ521"}),
+        "SARJ411": frozenset({"SARJ521", "SARJ535"}),
         # Any-valued mappings are the stronger correctness failure. SARJ008
         # still owns every fixed dictionary return when selected alone, while
         # an all-rules run emits one actionable diagnostic for this overlap.
         "SARJ447": frozenset({"SARJ008"}),
-        "SARJ450": frozenset({"SARJ521"}),
+        "SARJ450": frozenset({"SARJ521", "SARJ535"}),
+        "SARJ521": frozenset({"SARJ535"}),
         "SARJ457": frozenset({"SARJ045"}),
         "SARJ465": frozenset({"SARJ071"}),
         "SARJ491": frozenset({"SARJ400"}),

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/_autofix.py

@@ -993,10 +993,13 @@ def _jwt_required_sequence(required: ast.expr) -> ast.expr | None:
     ):
         return None
     elements = [*required.elts, ast.Constant(value="exp")]
-    if isinstance(required, ast.List):
-        return ast.List(elts=elements, ctx=ast.Load())
-    if isinstance(required, ast.Tuple):
-        return ast.Tuple(elts=elements, ctx=ast.Load())
+    match required:
+        case ast.List():
+            return ast.List(elts=elements, ctx=ast.Load())
+        case ast.Tuple():
+            return ast.Tuple(elts=elements, ctx=ast.Load())
+        case _:
+            pass
     return ast.Set(elts=elements)
 
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/_autofix_enums.py

@@ -164,7 +164,7 @@ class EnumFixes:
 
     def _stable_alias(self, alias: ast.TypeAlias) -> bool:
         if any(
-            bindings.get(alias.name.id, []) not in ([], [alias.name]) for bindings in self.provenance.bindings.values()
+            bindings.get(alias.name.id, ()) not in {(), (alias.name,)} for bindings in self.provenance.bindings.values()
         ):
             return False
         if any(

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/_autofix_repeated.py

@@ -115,7 +115,7 @@ class RepeatedLiteralFixes:
 
     def _stable_binding(self, binding: ast.Name, literal: ast.Constant, parent: ast.FunctionDef) -> bool:
         return (
-            self.provenance.bindings.get(parent, {}).get(binding.id) == [binding]
+            self.provenance.bindings.get(parent, {}).get(binding.id) == (binding,)
             and self.provenance.binding(binding.id, literal) is binding
             and binding.id not in self.provenance.external_bindings
             and (binding.lineno, binding.col_offset + 1) not in self.locations

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/_file_context.py

@@ -8,10 +8,12 @@ from sarj_python_lint._analysis_session import AnalysisSession
 from sarj_python_lint._source import python_source_lines, symbol_prefilter_source
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
 from sarj_python_lint.rules._ast_index import NodeIndex
+from sarj_python_lint.rules._binding_inventory import BindingInventory
 from sarj_python_lint.rules._fastapi import FastapiIndex
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
 from sarj_python_lint.rules._paths import is_generated
+from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
 if TYPE_CHECKING:
@@ -23,7 +25,7 @@ if TYPE_CHECKING:
     from sarj_python_lint.rules._test_provenance import TestProvenance
 
 
-@final
+@final  # ruff: ignore[too-many-public-methods] -- one file owns the lazy fact caches and their shared lifetime; splitting providers would duplicate semantic state.
 class PythonFileContext:
     def __init__(self, path: Path, source: str, session: AnalysisSession | None = None) -> None:
         self.path = path
@@ -85,6 +87,14 @@ class PythonFileContext:
     def parents(self) -> Mapping[ast.AST, ast.AST]:
         return self.node_index.parents
 
+    @cached_property
+    def binding_inventory(self) -> BindingInventory:
+        return BindingInventory.from_context(self)
+
+    @cached_property
+    def runtime_bindings(self) -> RuntimeBindings:
+        return RuntimeBindings(self, self.binding_inventory.bindings)
+
     @cached_property
     def imports(self) -> ImportIndex:
         return ImportIndex.from_tree(self._valid_tree())

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_annotation_origins.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from sarj_python_lint.rules._imports import ImportIndex
@@ -10,6 +11,15 @@ if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
 
 
+_MAX_ALIAS_DEPTH = 32
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedAnnotation:
+    expression: ast.expr
+    at: ast.expr
+
+
 class AnnotationOrigins:
     def __init__(self, context: PythonFileContext) -> None:
         self.context = context
@@ -19,6 +29,39 @@ class AnnotationOrigins:
             for node in context.nodes(ast.Import, ast.ImportFrom)
         }
 
+    def alias_value(self, node: ast.Name, at: ast.AST) -> ast.expr | None:
+        value = self.context.annotation_semantics.aliases.get(node.id)
+        if value is None:
+            return None
+        binding = self.provenance.binding(node.id, at)
+        if not isinstance(binding, ast.Name):
+            return None
+        parent = self.context.parents.get(binding)
+        if isinstance(parent, ast.TypeAlias | ast.AnnAssign) and parent.value is value:
+            return value
+        return None
+
+    def resolve_annotation(self, node: ast.expr, *, at: ast.expr | None = None) -> ResolvedAnnotation | None:
+        current = node
+        scope = node if at is None else at
+        seen: set[str] = set()
+        for _ in range(_MAX_ALIAS_DEPTH):
+            parsed = self.context.annotation_semantics.parse(current)
+            if parsed is None:
+                return None
+            if isinstance(parsed, ast.Name):
+                if self.shadowed(parsed.id, scope):
+                    return None
+                value = self.alias_value(parsed, scope)
+                if value is not None:
+                    if parsed.id in seen:
+                        return None
+                    seen.add(parsed.id)
+                    current = scope = value
+                    continue
+            return ResolvedAnnotation(parsed, scope)
+        return None
+
     def shadowed(self, name: str, at: ast.AST) -> bool:
         return type_parameter_shadow(name, at, self.context)
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -158,10 +158,13 @@ def _bound_names(statement: ast.stmt) -> set[str]:
 
 
 def _target_names(node: ast.expr) -> set[str]:
-    if isinstance(node, ast.Name):
-        return {node.id}
-    if isinstance(node, (ast.List, ast.Tuple)):
-        return {name for item in node.elts for name in _target_names(item)}
+    match node:
+        case ast.Name():
+            return {node.id}
+        case ast.List() | ast.Tuple():
+            return {name for item in node.elts for name in _target_names(item)}
+        case _:
+            pass
     return set()
 
 

sarj_python_lint-1.84.0/src/sarj_python_lint/rules/_binding_inventory.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_SCOPES = (
+    ast.Module,
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.ClassDef,
+    ast.Lambda,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class BindingInventory:
+    parents: Mapping[ast.AST, ast.AST]
+    bindings: Mapping[ast.AST | None, Mapping[str, tuple[ast.AST, ...]]]
+    reads: Mapping[str, tuple[ast.Name, ...]]
+    wildcard: bool
+    mutated: frozenset[str]
+    external_bindings: frozenset[str]
+
+    @classmethod
+    def from_context(cls, context: PythonFileContext) -> BindingInventory:
+        parents = context.parents
+        bindings: dict[ast.AST | None, dict[str, list[ast.AST]]] = defaultdict(lambda: defaultdict(list))
+        reads: dict[str, list[ast.Name]] = defaultdict(list)
+        mutated: set[str] = set()
+        external_bindings: set[str] = set()
+        wildcard = False
+        for node in context.nodes(ast.AST):
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+                reads[node.id].append(node)
+            for name in _bound_names(node):
+                bindings[_binding_scope(parents, node)][name].append(node)
+                wildcard |= name == "*"
+            if isinstance(node, ast.Global | ast.Nonlocal):
+                external_bindings.update(node.names)
+            if (name := _mutated_namespace(node)) is not None:
+                mutated.add(name)
+        return cls(
+            parents=parents,
+            bindings=MappingProxyType(
+                {
+                    scope: MappingProxyType({name: tuple(nodes) for name, nodes in names.items()})
+                    for scope, names in bindings.items()
+                }
+            ),
+            reads=MappingProxyType({name: tuple(nodes) for name, nodes in reads.items()}),
+            wildcard=wildcard,
+            mutated=frozenset(mutated),
+            external_bindings=frozenset(external_bindings),
+        )
+
+    def scope(self, node: ast.AST) -> ast.AST | None:
+        return _scope(self.parents, node)
+
+
+def _mutated_namespace(node: ast.AST) -> str | None:
+    if not isinstance(node, ast.Attribute) or not isinstance(node.ctx, ast.Store | ast.Del):
+        return None
+    root = node.value
+    while isinstance(root, ast.Attribute):
+        root = root.value
+    return root.id if isinstance(root, ast.Name) else None
+
+
+def _scope(parents: Mapping[ast.AST, ast.AST], node: ast.AST) -> ast.AST | None:
+    parent = parents.get(node)
+    while parent is not None:
+        if isinstance(parent, ast.arguments) and (node in parent.defaults or node in parent.kw_defaults):
+            parent = parents.get(parent)
+        elif isinstance(parent, _SCOPES) and not (
+            (
+                isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
+                and node in parent.decorator_list
+            )
+            or (isinstance(parent, ast.ClassDef) and (node in parent.bases or node in parent.keywords))
+        ):
+            return parent
+        if parent is None:
+            return None
+        node = parent
+        parent = parents.get(parent)
+    return None
+
+
+def _binding_scope(parents: Mapping[ast.AST, ast.AST], node: ast.AST) -> ast.AST | None:
+    scope = _scope(parents, node)
+    parent = parents.get(node)
+    if isinstance(parent, ast.NamedExpr) and parent.target is node:
+        while isinstance(scope, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp):
+            scope = _scope(parents, scope)
+    return scope
+
+
+def _bound_names(node: ast.AST) -> tuple[str, ...]:
+    match node:
+        case ast.Name(id=name, ctx=ast.Store() | ast.Del()) | ast.arg(arg=name):
+            return (name,)
+        case ast.alias():
+            return (node.asname or node.name.partition(".")[0],)
+        case (
+            ast.FunctionDef(name=name)
+            | ast.AsyncFunctionDef(name=name)
+            | ast.ClassDef(name=name)
+            | ast.ExceptHandler(name=str() as name)
+            | ast.MatchAs(name=str() as name)
+            | ast.MatchStar(name=str() as name)
+            | ast.MatchMapping(rest=str() as name)
+        ):
+            return (name,)
+        case ast.Global(names=names) | ast.Nonlocal(names=names):
+            return tuple(names)
+        case _:
+            return ()

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_closed_helpers.py

@@ -115,7 +115,7 @@ def call_matches(function: ast.FunctionDef, call: ast.Call) -> bool:
 def stable_class(context: PythonFileContext, declaration: ast.ClassDef, provenance: ResourceProvenance) -> bool:
     if declaration.decorator_list or declaration.keywords or context.parents.get(declaration) is not context.tree:
         return False
-    return provenance.bindings.get(context.tree, {}).get(declaration.name) == [declaration]
+    return provenance.bindings.get(context.tree, {}).get(declaration.name) == (declaration,)
 
 
 def plain_class_members(

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_copy_on_write.py

@@ -659,28 +659,37 @@ class CopyOnWriteAnalysis:
         return _Value(_Shape("dict", element=element), shared_children=shared, fields=tuple(fields.items()))
 
     def _write(self, target: ast.expr, bindings: Mapping[str, _Value]) -> None:
-        if isinstance(target, (ast.Tuple, ast.List)):
-            for item in target.elts:
-                self._write(item, bindings)
-        elif isinstance(target, (ast.Attribute, ast.Subscript)):
-            owner = self._value(target.value, bindings)
-            if (
-                owner is not None
-                and owner.borrowed
-                and (
-                    isinstance(target, ast.Subscript)
-                    or (owner.shape.model is not None and self.models.field(owner.shape.model, target.attr) is not None)
-                )
-            ):
-                self.mutations.append(Mutation(target, self._before))
+        match target:
+            case ast.Tuple() | ast.List():
+                for item in target.elts:
+                    self._write(item, bindings)
+            case ast.Attribute() | ast.Subscript():
+                owner = self._value(target.value, bindings)
+                if (
+                    owner is not None
+                    and owner.borrowed
+                    and (
+                        isinstance(target, ast.Subscript)
+                        or (
+                            owner.shape.model is not None
+                            and self.models.field(owner.shape.model, target.attr) is not None
+                        )
+                    )
+                ):
+                    self.mutations.append(Mutation(target, self._before))
+            case _:
+                pass
 
     def _expression(self, node: ast.AST, bindings: dict[str, _Value]) -> None:
-        if isinstance(node, (ast.Lambda, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            return
-        if isinstance(node, ast.NamedExpr):
-            self._expression(node.value, bindings)
-            self._bind(node.target, self._value(node.value, bindings), bindings)
-            return
+        match node:
+            case ast.Lambda() | ast.FunctionDef() | ast.AsyncFunctionDef() | ast.ClassDef():
+                return
+            case ast.NamedExpr():
+                self._expression(node.value, bindings)
+                self._bind(node.target, self._value(node.value, bindings), bindings)
+                return
+            case _:
+                pass
         if isinstance(node, ast.Call) and self._mutator_call(node, bindings):
             self.mutations.append(Mutation(node, self._before))
         if isinstance(node, (ast.ListComp, ast.SetComp, ast.GeneratorExp, ast.DictComp)):

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_data_union_discriminator.py

@@ -11,6 +11,8 @@ from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
     from sarj_python_lint._file_context import PythonFileContext
 
 
@@ -757,7 +759,7 @@ def _metadata_tuple_index(node: ast.expr) -> int | None:
     return None
 
 
-def _metadata_alias_graph(tree: ast.Module, bindings: dict[str, list[ast.AST]]) -> dict[str, set[str]]:
+def _metadata_alias_graph(tree: ast.Module, bindings: Mapping[str, Sequence[ast.AST]]) -> dict[str, set[str]]:
     graph: dict[str, set[str]] = {}
     for node in tree.body:
         binding = _value_binding(node)

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_docstrings.py

@@ -305,10 +305,13 @@ def base_names(node: ast.ClassDef) -> set[str]:
     names: set[str] = set()
     for base in node.bases:
         target = base.value if isinstance(base, ast.Subscript) else base
-        if isinstance(target, ast.Attribute):
-            names.add(target.attr)
-        elif isinstance(target, ast.Name):
-            names.add(target.id)
+        match target:
+            case ast.Attribute():
+                names.add(target.attr)
+            case ast.Name():
+                names.add(target.id)
+            case _:
+                pass
     return names
 
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_fastapi.py

@@ -241,10 +241,13 @@ class FastapiIndex:
         for node in walk_ast(tree):
             if self._node_scopes[id(node)] != 0:
                 continue
-            if isinstance(node, ast.Import):
-                self._read_import(node)
-            elif isinstance(node, ast.ImportFrom):
-                self._read_import_from(node)
+            match node:
+                case ast.Import():
+                    self._read_import(node)
+                case ast.ImportFrom():
+                    self._read_import_from(node)
+                case _:
+                    pass
 
     def _read_import(self, node: ast.Import) -> None:
         for alias in node.names:

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_imports.py

@@ -141,10 +141,13 @@ def _module_non_import_bindings(tree: ast.Module) -> set[str]:
 
 
 def _target_names(node: ast.expr) -> set[str]:
-    if isinstance(node, ast.Name):
-        return {node.id}
-    if isinstance(node, (ast.Tuple, ast.List)):
-        return {name for element in node.elts for name in _target_names(element)}
+    match node:
+        case ast.Name():
+            return {node.id}
+        case ast.Tuple() | ast.List():
+            return {name for element in node.elts for name in _target_names(element)}
+        case _:
+            pass
     return set()
 
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_mapping_shape_callbacks.py

@@ -59,14 +59,17 @@ class RawMappingCallbacks:
     def callback(self, node: ast.expr, *, seen: frozenset[ast.AST] = frozenset()) -> _Function | None:
         if len(seen) >= _MAX_DEPTH:
             return None
-        if isinstance(node, ast.Call):
-            return (
-                self._partial(node, seen)
-                if self.qualified(node.func, node) == "functools.partial"
-                else self._method(node, "__call__", seen)
-            )
-        if isinstance(node, ast.Attribute):
-            return self._method(node.value, node.attr, seen)
+        match node:
+            case ast.Call():
+                return (
+                    self._partial(node, seen)
+                    if self.qualified(node.func, node) == "functools.partial"
+                    else self._method(node, "__call__", seen)
+                )
+            case ast.Attribute():
+                return self._method(node.value, node.attr, seen)
+            case _:
+                pass
         if not isinstance(node, ast.Name) or not self._stable(node.id) or self.shadowed(node.id, node):
             return None
         binding = self.provenance.binding(node.id, node)
@@ -144,10 +147,13 @@ class RawMappingCallbacks:
     def _function(self, node: ast.AST) -> _Function | None:
         current = self.context.parents.get(node)
         while current is not None:
-            if isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef):
-                return current
-            if isinstance(current, ast.ClassDef | ast.Lambda):
-                return None
+            match current:
+                case ast.FunctionDef() | ast.AsyncFunctionDef():
+                    return current
+                case ast.ClassDef() | ast.Lambda():
+                    return None
+                case _:
+                    pass
             current = self.context.parents.get(current)
         return None
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_native_object_contracts.py

@@ -406,11 +406,14 @@ class _NamespaceFlow:
     def plain_dict(self, value: ast.expr, *, depth: int = 0) -> bool:
         if depth >= _MAX_DEPTH:
             return False
-        if isinstance(value, ast.Name):
-            assigned = self.assigned(value)
-            return assigned is not None and self.plain_dict(assigned, depth=depth + 1)
-        if isinstance(value, ast.IfExp):
-            return self.plain_dict(value.body, depth=depth + 1) and self.plain_dict(value.orelse, depth=depth + 1)
+        match value:
+            case ast.Name():
+                assigned = self.assigned(value)
+                return assigned is not None and self.plain_dict(assigned, depth=depth + 1)
+            case ast.IfExp():
+                return self.plain_dict(value.body, depth=depth + 1) and self.plain_dict(value.orelse, depth=depth + 1)
+            case _:
+                pass
         return isinstance(value, ast.Dict) or (isinstance(value, ast.Call) and self.native.dict_call(value))
 
     def _collect(self, value: ast.expr, *, execution: ast.Call, depth: int = 0) -> None:
@@ -436,10 +439,13 @@ class _NamespaceFlow:
     def _input(self, value: ast.expr, *, depth: int = 0) -> set[ast.arg]:
         if depth >= _MAX_DEPTH:
             return set()
-        if isinstance(value, ast.Name):
-            return self._name_input(value, depth)
-        if isinstance(value, ast.Dict):
-            return self._dictionary_inputs(value, depth)
+        match value:
+            case ast.Name():
+                return self._name_input(value, depth)
+            case ast.Dict():
+                return self._dictionary_inputs(value, depth)
+            case _:
+                pass
         if isinstance(value, ast.Call) and self.native.dict_call(value):
             return self._constructor_inputs(value, depth)
         found: set[ast.arg] = set()
@@ -652,13 +658,16 @@ class _NamespaceEscapes:
             return None
         binding = self.flow.binding(value)
         found: set[ast.AST] = {binding} if binding is not None else set()
-        if isinstance(value, ast.Name):
-            assigned = self.flow.assigned(value)
-            if isinstance(assigned, ast.Name | ast.Subscript):
-                previous = self._carrier_roots(assigned, depth=depth + 1)
-                return None if previous is None else found | previous
-        elif isinstance(value, ast.Subscript):
-            return self._carrier_roots(value.value, depth=depth + 1)
+        match value:
+            case ast.Name():
+                assigned = self.flow.assigned(value)
+                if isinstance(assigned, ast.Name | ast.Subscript):
+                    previous = self._carrier_roots(assigned, depth=depth + 1)
+                    return None if previous is None else found | previous
+            case ast.Subscript():
+                return self._carrier_roots(value.value, depth=depth + 1)
+            case _:
+                pass
         return found
 
 

{sarj_python_lint-1.83.0 → sarj_python_lint-1.84.0}/src/sarj_python_lint/rules/_opaque_contracts.py

@@ -427,10 +427,13 @@ class OpaqueContractFacts:
 
     def _enclosing_assertion(self, node: ast.AST) -> ast.Assert | None:
         while (parent := self.context.parents.get(node)) is not None:
-            if isinstance(parent, ast.Assert):
-                return parent
-            if isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda):
-                return None
+            match parent:
+                case ast.Assert():
+                    return parent
+                case ast.FunctionDef() | ast.AsyncFunctionDef() | ast.Lambda():
+                    return None
+                case _:
+                    pass
             node = parent
         return None
 
@@ -534,11 +537,14 @@ class OpaqueContractFacts:
             return None
         if isinstance(node, ast.Name):
             binding = self.facts.provenance.runtime_binding(node.id, node)
-            if isinstance(binding, ast.arg):
-                return binding
-            if isinstance(binding, ast.Name):
-                value = self.assigned(binding, node)
-                return self.parameter(value, depth=depth + 1) if value is not None else None
+            match binding:
+                case ast.arg():
+                    return binding
+                case ast.Name():
+                    value = self.assigned(binding, node)
+                    return self.parameter(value, depth=depth + 1) if value is not None else None
+                case _:
+                    pass
         receiver = _projection_receiver(node)
         parameter = self.parameter(receiver, depth=depth + 1) if receiver is not None else None
         return parameter if self._raw_annotation(parameter) else None
@@ -993,12 +999,13 @@ def _projection_receiver(node: ast.expr) -> ast.expr | None:
 
 
 def _control_condition(node: ast.AST, parent: ast.AST) -> tuple[ast.expr, bool] | None:
-    if isinstance(parent, ast.IfExp):
-        accepted, rejected = node is parent.body, node is parent.orelse
-    elif isinstance(parent, ast.If):
-        accepted, rejected = node in parent.body, node in parent.orelse
-    else:
-        return None
+    match parent:
+        case ast.IfExp():
+            accepted, rejected = node is parent.body, node is parent.orelse
+        case ast.If():
+            accepted, rejected = node in parent.body, node in parent.orelse
+        case _:
+            return None
     return (parent.test, accepted) if accepted or rejected else None