sarj-python-lint 0.87.0__tar.gz → 0.87.2__tar.gz

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/.gitignore

@@ -32,9 +32,10 @@ Thumbs.db
 .zed/
 *.swp
 
-# Claude Code local state (shared settings.json is tracked)
-.claude/*
-!.claude/settings.json
+.claude/
+apps/docs/.wrangler/
+apps/docs/.dev.vars*
+!apps/docs/.dev.vars.example
 .worktrees/
 .sarj-private-refs.toml
 .sarj-standards-rollout.toml

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 0.87.0
+Version: 0.87.2
 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-0.87.0 → sarj_python_lint-0.87.2}/pyproject.toml

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

sarj_python_lint-0.87.2/src/sarj_python_lint/rules/_ast_position.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    import ast
+
+
+@dataclass(frozen=True, order=True, slots=True)
+class AstPosition:
+    line: int
+    column: int
+
+
+def ast_position(node: ast.AST, *, missing: int) -> AstPosition:
+    return AstPosition(
+        line=getattr(node, "lineno", missing),
+        column=getattr(node, "col_offset", missing),
+    )

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/fastapi_explicit_openapi_contract.py

@@ -674,12 +674,12 @@ def _check_direct_responses(
     routes: tuple[Route, ...],
     index: FastapiIndex,
 ) -> list[_Finding]:
-    statuses, invalid = _direct_response_statuses(function, index)
+    direct = _direct_response_statuses(function, index)
     findings = [
         _Finding(node, f"[status] {status} is outside the HTTP status range 100..599.")
-        for status, node in invalid.items()
+        for status, node in direct.invalid.items()
     ]
-    if not statuses:
+    if not direct.statuses:
         return findings
     for route in _operations(routes):
         responses = _route_response_nodes(route)
@@ -689,7 +689,7 @@ def _check_direct_responses(
             status for node in responses if isinstance(node, ast.Dict) for status in _response_codes(node, index)
         }
         primary = _status_code(route.keywords.get("status_code"), index)
-        missing = sorted(statuses - documented - ({primary} if primary is not None else set()))
+        missing = sorted(direct.statuses - documented - ({primary} if primary is not None else set()))
         if missing:
             findings.append(
                 _Finding(
@@ -700,9 +700,15 @@ def _check_direct_responses(
     return findings
 
 
+@dataclass(frozen=True, slots=True)
+class _DirectResponseStatuses:
+    statuses: set[int]
+    invalid: dict[int, ast.Call]
+
+
 def _direct_response_statuses(
     function: ast.FunctionDef | ast.AsyncFunctionDef, index: FastapiIndex
-) -> tuple[set[int], dict[int, ast.Call]]:
+) -> _DirectResponseStatuses:
     statuses: set[int] = set()
     invalid: dict[int, ast.Call] = {}
     stack: list[tuple[ast.AST, bool]] = [(node, False) for node in function.body]
@@ -721,7 +727,7 @@ def _direct_response_statuses(
             else:
                 invalid.setdefault(status, call)
         stack.extend((child, catches_http_exception) for child in children(current))
-    return statuses, invalid
+    return _DirectResponseStatuses(statuses=statuses, invalid=invalid)
 
 
 def _extend_response_try(

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/no_positional_psycopg_row_escape.py

@@ -20,6 +20,7 @@ from sarj_python_lint.rule_base import (
     is_suppressed,
     parse_or_none,
 )
+from sarj_python_lint.rules._ast_position import AstPosition, ast_position
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_generated, is_test_path, is_test_support_path
 
@@ -954,8 +955,8 @@ def _target_names(node: ast.expr) -> set[str]:
     return set()
 
 
-def _position(node: ast.AST) -> tuple[int, int]:
-    return getattr(node, "lineno", -1), getattr(node, "col_offset", -1)
+def _position(node: ast.AST) -> AstPosition:
+    return ast_position(node, missing=-1)
 
 
 def _scope_nodes(statements: Iterable[ast.stmt], *, stop_rebinding: str | None = None) -> Iterator[ast.AST]:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/no_random_uuid_in_sql.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 import re
 from typing import TYPE_CHECKING, ClassVar, final, override
@@ -26,6 +27,13 @@ if TYPE_CHECKING:
 
 _RANDOM_UUID_RE = re.compile(r"\b(?:gen_random_uuid|uuid_generate_v4)\s*\(", re.IGNORECASE)
 
+
+@dataclass(frozen=True, slots=True)
+class _IdentifierEnd:
+    end: int
+    after_whitespace: int
+
+
 # Require SQL structure so prose that merely names the function stays valid.
 _SQL_SHAPE_RE = re.compile(
     r"\b(?:CREATE|ALTER|INSERT|UPDATE|SELECT|DEFAULT|VALUES)\b",
@@ -132,12 +140,12 @@ def _inside_uuidv7_builder(sql: str, position: int) -> bool:
     index = 0
     while index < position:
         if sql[index].isalpha() or sql[index] == "_":
-            end, after = _identifier_end(sql, index, position)
-            if after < position and sql[after] == "(":
-                calls.append(sql[index:end].lower())
-                index = after + 1
+            identifier = _identifier_end(sql, index, position)
+            if identifier.after_whitespace < position and sql[identifier.after_whitespace] == "(":
+                calls.append(sql[index : identifier.end].lower())
+                index = identifier.after_whitespace + 1
                 continue
-            index = end
+            index = identifier.end
             continue
         if sql[index] == "(":
             calls.append(None)
@@ -147,11 +155,11 @@ def _inside_uuidv7_builder(sql: str, position: int) -> bool:
     return any(call in _UUIDV7_BUILDERS for call in calls)
 
 
-def _identifier_end(sql: str, index: int, position: int) -> tuple[int, int]:
+def _identifier_end(sql: str, index: int, position: int) -> _IdentifierEnd:
     end = index + 1
     while end < position and (sql[end].isalnum() or sql[end] == "_"):
         end += 1
     after = end
     while after < position and sql[after].isspace():
         after += 1
-    return end, after
+    return _IdentifierEnd(end=end, after_whitespace=after)

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/no_unused_value_marker.py

@@ -32,7 +32,8 @@ class NoUnusedValueMarker(Rule):
         summary="Do not use standalone assignments to `_` to discard values.",
         rationale=(
             "A standalone `_ = value` assignment adds a binding without clarifying intent. A side-effecting call can "
-            "be invoked directly, while an unused parameter should be addressed at its declaration."
+            "be invoked directly. Pure references to formal parameters are excluded because callback and protocol "
+            "signatures may require names that Ruff otherwise reports as unused."
         ),
         remediation=(
             "Invoke calls directly instead of assigning their result to `_`. Remove or rename locally owned unused "
@@ -43,14 +44,15 @@ class NoUnusedValueMarker(Rule):
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Plain and annotated assignments whose standalone target is `_` are reported, including chained assignments.",
+            "Pure name or tuple references to the enclosing function's unchanged parameters are excluded.",
             "Unpacking placeholders, loop targets, wildcard imports, and underscore-prefixed names are excluded.",
             "Generated and vendored files are excluded.",
         ),
         examples=(
             RuleExample(
-                example_id="unused-parameter-marker",
-                title="Do not manufacture a use for interface parameters",
-                outcome=ExampleOutcome.MATCH,
+                example_id="callback-parameter-marker",
+                title="A callback keeps its required parameter names",
+                outcome=ExampleOutcome.NO_MATCH,
                 files=(
                     ExampleFile.python(
                         "app/adapter.py",
@@ -58,6 +60,15 @@ class NoUnusedValueMarker(Rule):
                     ),
                 ),
                 focus_path=PurePosixPath("app/adapter.py"),
+                expected_count=0,
+                public=False,
+            ),
+            RuleExample(
+                example_id="discarded-nonparameter-value",
+                title="A standalone discard binding is unnecessary",
+                outcome=ExampleOutcome.MATCH,
+                files=(ExampleFile.python("app/adapter.py", "value = 1\n_ = value\n"),),
+                focus_path=PurePosixPath("app/adapter.py"),
                 expected_count=1,
                 public=True,
             ),
@@ -116,6 +127,18 @@ class NoUnusedValueMarker(Rule):
         if tree is None:
             return []
         source_lines = source.splitlines()
+        markers = [
+            node
+            for node in ast.walk(tree)
+            if isinstance(node, (ast.Assign, ast.AnnAssign)) and _is_unused_value_marker(node)
+        ]
+        if not markers:
+            return []
+        parents = (
+            {child: parent for parent in ast.walk(tree) for child in ast.iter_child_nodes(parent)}
+            if any(isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Tuple)) for node in markers)
+            else {}
+        )
         return [
             Diagnostic(
                 path=path,
@@ -128,10 +151,8 @@ class NoUnusedValueMarker(Rule):
                     "directly or address unused values at their declaration."
                 ),
             )
-            for node in ast.walk(tree)
-            if isinstance(node, (ast.Assign, ast.AnnAssign))
-            and _is_unused_value_marker(node)
-            and not is_suppressed(source_lines, node.lineno, self.code)
+            for node in markers
+            if not _is_pure_parameter_marker(node, parents) and not is_suppressed(source_lines, node.lineno, self.code)
         ]
 
 
@@ -139,3 +160,42 @@ def _is_unused_value_marker(node: ast.Assign | ast.AnnAssign) -> bool:
     if isinstance(node, ast.AnnAssign):
         return node.value is not None and isinstance(node.target, ast.Name) and node.target.id == "_"
     return any(isinstance(target, ast.Name) and target.id == "_" for target in node.targets)
+
+
+def _is_pure_parameter_marker(
+    node: ast.Assign | ast.AnnAssign,
+    parents: dict[ast.AST, ast.AST],
+) -> bool:
+    if not isinstance(node, ast.Assign) or len(node.targets) != 1:
+        return False
+    if not isinstance(node.targets[0], ast.Name) or node.targets[0].id != "_":
+        return False
+    names = _marker_reference_names(node.value)
+    if names is None:
+        return False
+    function = _enclosing_function(node, parents)
+    if function is None:
+        return False
+    parameters = {argument.arg for argument in ast.walk(function.args) if isinstance(argument, ast.arg)}
+    return names <= parameters and not any(
+        isinstance(child, ast.Name) and isinstance(child.ctx, ast.Store) and child.id in names
+        for child in ast.walk(function)
+    )
+
+
+def _marker_reference_names(value: ast.expr) -> set[str] | None:
+    values = value.elts if isinstance(value, ast.Tuple) else [value]
+    if not values or not all(isinstance(item, ast.Name) for item in values):
+        return None
+    return {item.id for item in values if isinstance(item, ast.Name)}
+
+
+def _enclosing_function(
+    node: ast.AST, parents: dict[ast.AST, ast.AST]
+) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+    current = node
+    while current in parents:
+        current = parents[current]
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return current
+    return None

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_injected_dependency_over_monkeypatch.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
+from sarj_python_lint.rules._ast_position import AstPosition, ast_position
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_generated, is_test_path
 
@@ -250,10 +251,10 @@ def _parameter_rebound_before(
     return any(handle in _bound_targets(node) and _position(node) < use_position for node in nodes)
 
 
-def _position(node: ast.AST) -> tuple[int, int]:
+def _position(node: ast.AST) -> AstPosition:
     if isinstance(node, ast.withitem):
         return _position(node.context_expr)
-    return (getattr(node, "lineno", 0), getattr(node, "col_offset", 0))
+    return ast_position(node, missing=0)
 
 
 def _direct_aliases(nodes: tuple[ast.AST, ...], handles: set[str], parameters: set[str]) -> set[str]:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_match_exception_dispatch.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, ClassVar, NamedTuple, final, override
 
@@ -215,17 +216,23 @@ def _classifier_starts(
     for statements in _nested_statement_lists(body):
         index = 0
         while index < len(statements):
-            candidates, cursor = _adjacent_bare_ifs(statements, index)
-            branches = _validated_branches(candidates, subject, imports)
-            if branches is not None and _is_classifier(branches, statements, cursor):
+            adjacent = _adjacent_bare_ifs(statements, index)
+            branches = _validated_branches(adjacent.candidates, subject, imports)
+            if branches is not None and _is_classifier(branches, statements, adjacent.cursor):
                 findings.append(branches[0][0])
-                index = cursor + 1
+                index = adjacent.cursor + 1
             else:
-                index = max(cursor, index + 1)
+                index = max(adjacent.cursor, index + 1)
     return tuple(findings)
 
 
-def _adjacent_bare_ifs(statements: list[ast.stmt], start: int) -> tuple[list[ast.If], int]:
+@dataclass(frozen=True, slots=True)
+class _AdjacentBareIfs:
+    candidates: list[ast.If]
+    cursor: int
+
+
+def _adjacent_bare_ifs(statements: list[ast.stmt], start: int) -> _AdjacentBareIfs:
     cursor = start
     candidates: list[ast.If] = []
     while cursor < len(statements):
@@ -234,7 +241,7 @@ def _adjacent_bare_ifs(statements: list[ast.stmt], start: int) -> tuple[list[ast
             break
         candidates.append(candidate)
         cursor += 1
-    return candidates, cursor
+    return _AdjacentBareIfs(candidates=candidates, cursor=cursor)
 
 
 def _validated_branches(

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_match_value_dispatch.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import ast
 from collections import Counter
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, ClassVar, final, override
 
@@ -164,12 +165,12 @@ class PreferMatchValueDispatch(Rule):
         for node in ast.walk(tree):
             if not isinstance(node, ast.If) or id(node) in continuations:
                 continue
-            branches, current = _elif_chain(node, lines, continuations)
-            if len(branches) < _MIN_TESTS or not current.orelse:
+            chain = _elif_chain(node, lines, continuations)
+            if len(chain.branches) < _MIN_TESTS or not chain.last.orelse:
                 continue
-            subject = _dispatch_subject(branches, constants)
+            subject = _dispatch_subject(chain.branches, constants)
             if subject is None:
-                subject = _expanded_dispatch_subject(branches, constants)
+                subject = _expanded_dispatch_subject(chain.branches, constants)
             if subject is not None:
                 candidates.append((node, subject))
         for branches in _terminal_sibling_dispatches(tree):
@@ -368,7 +369,13 @@ def _subject(expression: ast.expr) -> str | None:
             return None
 
 
-def _elif_chain(node: ast.If, lines: list[str], continuations: set[int]) -> tuple[list[ast.If], ast.If]:
+@dataclass(frozen=True, slots=True)
+class _ElifChain:
+    branches: list[ast.If]
+    last: ast.If
+
+
+def _elif_chain(node: ast.If, lines: list[str], continuations: set[int]) -> _ElifChain:
     branches = [node]
     current = node
     while len(current.orelse) == 1:
@@ -378,7 +385,7 @@ def _elif_chain(node: ast.If, lines: list[str], continuations: set[int]) -> tupl
         continuations.add(id(child))
         branches.append(child)
         current = child
-    return branches, current
+    return _ElifChain(branches=branches, last=current)
 
 
 def _collect_terminal_siblings(field: list[ast.stmt], candidates: list[list[ast.If]]) -> None:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_monkeypatch_for_process_state_in_test.py

@@ -16,6 +16,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     parse_or_none,
 )
+from sarj_python_lint.rules._ast_position import AstPosition, ast_position
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._paths import is_generated, is_test_path
 
@@ -294,8 +295,8 @@ def _import_root_rebound_before(
     )
 
 
-def _position(node: ast.AST) -> tuple[int, int]:
-    return (getattr(node, "lineno", 0), getattr(node, "col_offset", 0))
+def _position(node: ast.AST) -> AstPosition:
+    return ast_position(node, missing=0)
 
 
 def _restored_mutations(

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_nominal_id_types.py

@@ -377,9 +377,11 @@ def _collect_type_aliases(
     aliases: dict[str, ast.expr],
 ) -> None:
     for statement in tree.body:
-        target, value = _alias_assignment(statement)
-        if target is None or value is None:
+        assignment = _alias_assignment(statement)
+        if assignment is None:
             continue
+        target = assignment.target
+        value = assignment.value
         if _is_new_type_call(value, imports):
             if len(value.args) >= _MIN_SWAPPABLE_ROLES:
                 carrier = _carrier(value.args[_SECOND_ARGUMENT], imports, _TypeFacts(raw_aliases, nominal_aliases))
@@ -389,14 +391,20 @@ def _collect_type_aliases(
         aliases[target] = _type_alias_type_value(value, imports) or value
 
 
-def _alias_assignment(statement: ast.stmt) -> tuple[str | None, ast.expr | None]:
+@dataclass(frozen=True, slots=True)
+class _AliasAssignment:
+    target: str
+    value: ast.expr
+
+
+def _alias_assignment(statement: ast.stmt) -> _AliasAssignment | None:
     if isinstance(statement, ast.TypeAlias):
-        return statement.name.id, statement.value
+        return _AliasAssignment(target=statement.name.id, value=statement.value)
     if isinstance(statement, ast.Assign) and len(statement.targets) == 1 and isinstance(statement.targets[0], ast.Name):
-        return statement.targets[0].id, statement.value
-    if isinstance(statement, ast.AnnAssign) and isinstance(statement.target, ast.Name):
-        return statement.target.id, statement.value
-    return None, None
+        return _AliasAssignment(target=statement.targets[0].id, value=statement.value)
+    if isinstance(statement, ast.AnnAssign) and isinstance(statement.target, ast.Name) and statement.value is not None:
+        return _AliasAssignment(target=statement.target.id, value=statement.value)
+    return None
 
 
 def _is_new_type_call(value: ast.expr, imports: ImportIndex) -> TypeGuard[ast.Call]:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_self_type_annotation.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from enum import StrEnum
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, ClassVar, override
@@ -237,8 +238,8 @@ class PreferSelfTypeAnnotation(Rule):
                 if method_kind is None or method_kind is _MethodKind.STATIC:
                     return
                 receiver = _first_positional_parameter(node)
-                bindings, is_generator = _method_scope_facts(node)
-                if receiver is None or receiver in bindings or is_generator:
+                scope = _method_scope_facts(node)
+                if receiver is None or receiver in scope.bindings or scope.is_generator:
                     return
                 returns = node.returns
                 if returns is None:
@@ -337,7 +338,13 @@ def _matched_enclosing_class_annotation(node: ast.expr, class_name: str) -> str
     return None
 
 
-def _method_scope_facts(node: ast.FunctionDef | ast.AsyncFunctionDef) -> tuple[frozenset[str], bool]:
+@dataclass(frozen=True, slots=True)
+class _MethodScopeFacts:
+    bindings: frozenset[str]
+    is_generator: bool
+
+
+def _method_scope_facts(node: ast.FunctionDef | ast.AsyncFunctionDef) -> _MethodScopeFacts:
     bindings: set[str] = set()
     has_yield = False
 
@@ -409,7 +416,7 @@ def _method_scope_facts(node: ast.FunctionDef | ast.AsyncFunctionDef) -> tuple[f
     visitor = Visitor()
     for statement in node.body:
         visitor.visit(statement)
-    return frozenset(bindings), has_yield
+    return _MethodScopeFacts(bindings=frozenset(bindings), is_generator=has_yield)
 
 
 def _is_final_class(node: ast.ClassDef, imports: ImportIndex) -> bool:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/prefer_str_enum.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 import re
 from types import MappingProxyType
@@ -499,9 +500,9 @@ class PreferStrEnum(Rule):
         choice_groups = _class_choice_groups(cls)
         candidates = _class_choice_fields(cls, raw_string_aliases, imports)
         for stmt, name, default in candidates:
-            associated_values, generic_values = _choice_values_for_field(choice_groups, name)
-            if not associated_values and not (
-                default is not None and len(candidates) == 1 and default in generic_values
+            choices = _choice_values_for_field(choice_groups, name)
+            if not choices.associated and not (
+                default is not None and len(candidates) == 1 and default in choices.generic
             ):
                 continue
             diags.append(
@@ -1429,14 +1430,20 @@ def _match_pattern_literals(pattern: ast.pattern) -> list[str]:
             return []
 
 
-def _choice_values_for_field(choice_groups: list[tuple[str, set[str]]], name: str) -> tuple[set[str], set[str]]:
+@dataclass(frozen=True, slots=True)
+class _ChoiceValues:
+    associated: set[str]
+    generic: set[str]
+
+
+def _choice_values_for_field(choice_groups: list[tuple[str, set[str]]], name: str) -> _ChoiceValues:
     associated_values = {
         value for binding, values in choice_groups if _choice_binding_field(binding) == name.lower() for value in values
     }
     generic_values = {
         value for binding, values in choice_groups if _choice_binding_field(binding) is None for value in values
     }
-    return associated_values, generic_values
+    return _ChoiceValues(associated=associated_values, generic=generic_values)
 
 
 def _choice_binding_field(binding: str) -> str | None:

{sarj_python_lint-0.87.0 → sarj_python_lint-0.87.2}/src/sarj_python_lint/rules/require_port_for_service.py

@@ -703,29 +703,35 @@ def _annotation_allows_none(annotation: ast.expr | None) -> bool:
     return isinstance(annotation, ast.Subscript) and _subscript_allows_none(annotation)
 
 
-def _statements_invoke_field(statements: list[ast.stmt], fields: frozenset[str]) -> tuple[bool, bool]:
+@dataclass(frozen=True, slots=True)
+class _InvocationFlow:
+    found: bool
+    falls_through: bool
+
+
+def _statements_invoke_field(statements: list[ast.stmt], fields: frozenset[str]) -> _InvocationFlow:
     for statement in statements:
         if isinstance(statement, ast.If):
-            found, falls_through = _conditional_invokes_field(statement, fields)
-            if found or not falls_through:
-                return found, falls_through
+            flow = _conditional_invokes_field(statement, fields)
+            if flow.found or not flow.falls_through:
+                return flow
             continue
         if (
             isinstance(statement, ast.While)
             and isinstance(statement.test, ast.Constant)
             and not bool(statement.test.value)
         ):
-            found, falls_through = _statements_invoke_field(statement.orelse, fields)
-            if found or not falls_through:
-                return found, falls_through
+            flow = _statements_invoke_field(statement.orelse, fields)
+            if flow.found or not flow.falls_through:
+                return flow
             continue
         if isinstance(statement, (ast.While, *_UNSUPPORTED_COMPOUND_STATEMENTS)):
             continue
         if _node_invokes_field(statement, fields):
-            return True, True
+            return _InvocationFlow(found=True, falls_through=True)
         if isinstance(statement, ast.Return | ast.Raise):
-            return False, False
-    return False, True
+            return _InvocationFlow(found=False, falls_through=False)
+    return _InvocationFlow(found=False, falls_through=True)
 
 
 def _node_invokes_field(node: ast.AST, fields: frozenset[str]) -> bool:
@@ -881,8 +887,7 @@ def _method_invokes_field(
 ) -> bool:
     if _has_unsupported_control_flow(method.body):
         return False
-    found, _falls_through = _statements_invoke_field(method.body, fields)
-    return found
+    return _statements_invoke_field(method.body, fields).found
 
 
 def _has_unsupported_control_flow(statements: list[ast.stmt]) -> bool:
@@ -945,17 +950,18 @@ def _constant_annotation_allows_none(annotation: ast.Constant) -> bool:
     return False
 
 
-def _conditional_invokes_field(statement: ast.If, fields: frozenset[str]) -> tuple[bool, bool]:
+def _conditional_invokes_field(statement: ast.If, fields: frozenset[str]) -> _InvocationFlow:
     if _node_invokes_field(statement.test, fields):
-        return True, True
+        return _InvocationFlow(found=True, falls_through=True)
     if isinstance(statement.test, ast.Constant):
         branch = statement.body if bool(statement.test.value) else statement.orelse
-        found, falls_through = _statements_invoke_field(branch, fields)
-    else:
-        body_found, body_falls = _statements_invoke_field(statement.body, fields)
-        else_found, else_falls = _statements_invoke_field(statement.orelse, fields)
-        found, falls_through = body_found or else_found, body_falls or else_falls
-    return found, falls_through
+        return _statements_invoke_field(branch, fields)
+    body = _statements_invoke_field(statement.body, fields)
+    otherwise = _statements_invoke_field(statement.orelse, fields)
+    return _InvocationFlow(
+        found=body.found or otherwise.found,
+        falls_through=body.falls_through or otherwise.falls_through,
+    )
 
 
 def _boolean_invokes_field(node: ast.BoolOp, fields: frozenset[str]) -> bool: