sarj-python-lint 1.2.4__tar.gz → 1.2.7__tar.gz

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/PKG-INFO

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

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

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/_registry.py

@@ -75,6 +75,7 @@ from sarj_python_lint.rules.no_secret_in_log import NoSecretInLog
 from sarj_python_lint.rules.no_select_star import NoSelectStar
 from sarj_python_lint.rules.no_service_behavior_in_settings import NoServiceBehaviorInSettings
 from sarj_python_lint.rules.no_string_concat_in_loop import NoStringConcatInLoop
+from sarj_python_lint.rules.no_swallowed_asyncio_cancellation import NoSwallowedAsyncioCancellation
 from sarj_python_lint.rules.no_tautological_expect import NoTautologicalExpect
 from sarj_python_lint.rules.no_typed_doc_sections import NoTypedDocSections
 from sarj_python_lint.rules.no_unique_violation_message_match import (
@@ -181,6 +182,7 @@ if TYPE_CHECKING:
 
 REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        NoSwallowedAsyncioCancellation.id: NoSwallowedAsyncioCancellation,
         AsyncMockCallWithoutAwaitAssertion.id: AsyncMockCallWithoutAwaitAssertion,
         ComplexPostgresQueryRequiresArchitectureReview.id: ComplexPostgresQueryRequiresArchitectureReview,
         ExcessiveCommentary.id: ExcessiveCommentary,

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/_test_composition.py

@@ -189,16 +189,27 @@ def local_names(function: Function) -> set[str]:
     return names
 
 
-def changed_before(function: Function, call: ast.Call) -> set[str]:
+def changed_before(function: Function, call: ast.Call, aliases: dict[str, ast.expr]) -> set[str]:
     changed: set[str] = set()
     for node in direct_nodes(function):
-        if not isinstance(node, (ast.Call, ast.Attribute)) or node.lineno >= call.lineno:
+        if not isinstance(node, (ast.Call, ast.Attribute, ast.Subscript)) or (node.lineno, node.col_offset) >= (
+            call.lineno,
+            call.col_offset,
+        ):
             continue
         target = node.func.value if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) else None
-        if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del)):
+        if isinstance(node, (ast.Attribute, ast.Subscript)) and isinstance(node.ctx, (ast.Store, ast.Del)):
             target = node.value
-        if isinstance(target, ast.Name):
+        while isinstance(target, (ast.Attribute, ast.Subscript)):
+            target = target.value
+        seen: set[str] = set()
+        while isinstance(target, ast.Name) and target.id not in seen:
+            seen.add(target.id)
             changed.add(target.id)
+            value = aliases.get(target.id)
+            if value is None or (value.lineno, value.col_offset) >= (node.lineno, node.col_offset):
+                break
+            target = value
     return changed
 
 

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -41,6 +41,7 @@ _AWAIT_ASSERTIONS: Final = frozenset(
     }
 )
 _AWAIT_STATE: Final = frozenset({"await_count", "await_args", "await_args_list"})
+_CALL_STATE: Final = frozenset({"called", "call_count"})
 _CONSTRUCTOR_KEYWORDS: Final = frozenset({"return_value", "side_effect", "name", "wraps", "unsafe", "spec", "spec_set"})
 _MUTATORS: Final = frozenset({"reset_mock", "configure_mock", "attach_mock", "mock_add_spec"})
 _IMMEDIATE_CHILD_PARTS: Final = 2
@@ -86,10 +87,25 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             "Only direct statements in collected test functions and methods are inspected; fixtures, helpers, nested blocks, and generated files are excluded.",
             "Requires a fresh local unittest.mock.AsyncMock constructor with unshadowed imports; aliases, reassignment, reset, and ambiguous configuration are excluded.",
             "Only the mock itself and unchanged immediate children of unspecced, unwrapped mocks are inferred; spec children, return values, and deeper chains are excluded.",
-            "Any direct positive await assertion or explicit await-state assertion on the same mock is accepted; argument equality and assertion strength are not compared.",
+            "Positive call-count and called-state assertions are covered as well as call-assertion methods. Await-state assertions must prove at least one await; argument equality and exact call/await counts are not compared.",
+            "Boolean conjunctions combine evidence; disjunctions require evidence in every branch. Dynamic counts and call lists are not inferred.",
             "Custom assertion helpers and intentional scheduling contracts may require a reasoned local suppression.",
         ),
         examples=(
+            RuleExample(
+                example_id="numeric-call-with-vacuous-await-check",
+                title="A nonnegative await count does not prove execution",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    assert send.call_count == 2\n    assert send.await_count >= 0\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=1,
+                public=False,
+            ),
             RuleExample(
                 example_id="call-only-async-mock",
                 title="A call assertion does not prove awaiting",
@@ -129,7 +145,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
         if (
             path.suffix != ".py"
             or "AsyncMock" not in source
-            or "assert_called" not in source
+            or not any(token in source for token in ("assert_called", "call_count", ".called"))
             or not (path.stem.startswith("test_") or path.stem.endswith("_test"))
             or context.generated
         ):
@@ -186,30 +202,46 @@ def _test_imports(module: ImportIndex, test: _TestFunction) -> ImportIndex:
     return ImportIndex(MappingProxyType(bindings), module.shadowed_names | local.shadowed_names)
 
 
-def _uncovered_calls(imports: ImportIndex, test: _TestFunction, writes: set[_Reference]) -> Iterator[ast.Call]:
+def _uncovered_calls(
+    imports: ImportIndex, test: _TestFunction, writes: set[_Reference]
+) -> Iterator[ast.Call | ast.Attribute]:
     nodes = tuple(walk_ast(test))
     bindings = _mock_bindings(imports, test.body, writes)
     covered = _await_oracles(test.body)
     reported: set[_Reference] = set()
     for statement in test.body:
-        match statement:
-            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
-                method in _CALL_ASSERTIONS
+        for reference, oracle in _call_oracles(statement):
+            if not reference or reference in covered or reference in reported:
+                continue
+            binding = bindings.get(reference[0])
+            if (
+                binding is None
+                or not _is_async_reference(reference, binding[1])
+                or any(_invalidates_reference(node, reference, binding[0]) for node in nodes)
             ):
-                reference = _reference(receiver)
-                if not reference or reference in covered or reference in reported:
-                    continue
-                binding = bindings.get(reference[0])
-                if (
-                    binding is None
-                    or not _is_async_reference(reference, binding[1])
-                    or any(_invalidates_reference(node, reference, binding[0]) for node in nodes)
-                ):
-                    continue
-                reported.add(reference)
-                yield call
-            case _:
-                pass
+                continue
+            reported.add(reference)
+            yield oracle
+
+
+def _call_oracles(statement: ast.stmt) -> Iterator[tuple[_Reference, ast.Call | ast.Attribute]]:
+    match statement:
+        case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
+            method in _CALL_ASSERTIONS
+        ):
+            yield _reference(receiver), call
+        case ast.Assert(test=condition):
+            for reference in sorted(_positive_states(condition, _CALL_STATE)):
+                oracle = next(
+                    node
+                    for node in walk_ast(condition)
+                    if isinstance(node, ast.Attribute)
+                    and node.attr in _CALL_STATE
+                    and _reference(node.value) == reference
+                )
+                yield reference, oracle
+        case _:
+            pass
 
 
 def _mock_bindings(
@@ -269,21 +301,127 @@ def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
     covered: set[_Reference] = set()
     for statement in statements:
         match statement:
-            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method))) if (
+            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
                 method in _AWAIT_ASSERTIONS
             ):
-                covered.add(_reference(receiver))
+                if method != "assert_has_awaits" or _has_nonempty_calls_argument(call):
+                    covered.add(_reference(receiver))
             case ast.Assert(test=condition):
-                covered.update(
-                    _reference(node.value)
-                    for node in walk_ast(condition)
-                    if isinstance(node, ast.Attribute) and node.attr in _AWAIT_STATE
-                )
+                covered.update(_positive_states(condition, _AWAIT_STATE))
             case _:
                 pass
     return covered
 
 
+def _has_nonempty_calls_argument(call: ast.Call) -> bool:
+    if call.args:
+        return _nonempty_sequence(call.args[0])
+    return any(item.arg == "calls" and _nonempty_sequence(item.value) for item in call.keywords)
+
+
+def _positive_states(condition: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    if isinstance(condition, ast.UnaryOp) and isinstance(condition.op, ast.Not):
+        operand = condition.operand
+        if isinstance(operand, ast.Compare) and len(operand.ops) == 1:
+            inverse = _negated_operator(operand.ops[0])
+            if inverse is not None:
+                return _comparison_states(operand.left, inverse, operand.comparators[0], states) | _comparison_states(
+                    operand.comparators[0], _reversed_operator(inverse), operand.left, states
+                )
+        return set()
+    if isinstance(condition, ast.BoolOp):
+        branches = [_positive_states(value, states) for value in condition.values]
+        return (
+            branches[0].union(*branches[1:])
+            if isinstance(condition.op, ast.And)
+            else branches[0].intersection(*branches[1:])
+        )
+    if isinstance(condition, ast.Attribute) and condition.attr in states:
+        return {_reference(condition.value)}
+    if isinstance(condition, ast.Compare):
+        result: set[_Reference] = set()
+        for left, operator, right in zip(
+            (condition.left, *condition.comparators[:-1]), condition.ops, condition.comparators, strict=True
+        ):
+            result.update(_comparison_states(left, operator, right, states))
+            result.update(_comparison_states(right, _reversed_operator(operator), left, states))
+        return result
+    return set()
+
+
+def _negated_operator(operator: ast.cmpop) -> ast.cmpop | None:
+    inverse: dict[type[ast.cmpop], type[ast.cmpop]] = {
+        ast.Eq: ast.NotEq,
+        ast.NotEq: ast.Eq,
+        ast.Is: ast.IsNot,
+        ast.IsNot: ast.Is,
+        ast.Lt: ast.GtE,
+        ast.LtE: ast.Gt,
+        ast.Gt: ast.LtE,
+        ast.GtE: ast.Lt,
+    }
+    factory = inverse.get(type(operator))
+    return factory() if factory is not None else None
+
+
+def _reversed_operator(operator: ast.cmpop) -> ast.cmpop:
+    match operator:
+        case ast.Lt():
+            return ast.Gt()
+        case ast.LtE():
+            return ast.GtE()
+        case ast.Gt():
+            return ast.Lt()
+        case ast.GtE():
+            return ast.LtE()
+        case _:
+            return operator
+
+
+def _comparison_states(left: ast.expr, operator: ast.cmpop, right: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    if not isinstance(left, ast.Attribute):
+        return set()
+    if (
+        states == _AWAIT_STATE
+        and isinstance(left.value, ast.Attribute)
+        and left.value.attr == "await_args"
+        and left.attr in {"args", "kwargs"}
+    ):
+        return {_reference(left.value.value)}
+    if left.attr not in states:
+        return set()
+    positive = False
+    if left.attr in {"call_count", "await_count"} and isinstance(right, ast.Constant) and type(right.value) is int:
+        positive = _proves_positive_count(operator, right.value)
+    elif left.attr == "called" and isinstance(right, ast.Constant):
+        positive = (isinstance(operator, (ast.Eq, ast.Is)) and right.value is True) or (
+            isinstance(operator, (ast.NotEq, ast.IsNot)) and right.value is False
+        )
+    elif left.attr == "await_args" and isinstance(right, ast.Constant) and right.value is None:
+        positive = isinstance(operator, (ast.NotEq, ast.IsNot))
+    elif left.attr == "await_args_list":
+        positive = (isinstance(operator, ast.Eq) and _nonempty_sequence(right)) or (
+            isinstance(operator, ast.NotEq) and isinstance(right, ast.List) and not right.elts
+        )
+    return {_reference(left.value)} if positive else set()
+
+
+def _proves_positive_count(operator: ast.cmpop, value: int) -> bool:
+    match operator:
+        case ast.Eq() | ast.GtE():
+            return value > 0
+        case ast.NotEq():
+            return value == 0
+        case ast.Gt():
+            return value >= 0
+        case _:
+            return False
+
+
+def _nonempty_sequence(node: ast.expr) -> bool:
+    return isinstance(node, (ast.List, ast.Tuple)) and any(not isinstance(item, ast.Starred) for item in node.elts)
+
+
 def _invalidates_reference(node: ast.AST, reference: _Reference, binding: ast.Name) -> bool:
     match node:
         case ast.Name(id=name, ctx=ast.Store() | ast.Del()):
@@ -295,7 +433,11 @@ def _invalidates_reference(node: ast.AST, reference: _Reference, binding: ast.Na
         case ast.Attribute(ctx=ast.Store() | ast.Del()):
             changed = _reference(node)
             return bool(changed) and (
-                reference[: len(changed)] == changed or (changed[:-1] == reference and changed[-1].startswith("assert"))
+                reference[: len(changed)] == changed
+                or (
+                    changed[:-1] == reference
+                    and (changed[-1].startswith("assert") or changed[-1] in _CALL_STATE | _AWAIT_STATE)
+                )
             )
         case ast.Call(func=ast.Attribute(value=receiver, attr=method)) if method in _MUTATORS:
             changed = _reference(receiver)

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -789,7 +789,7 @@ def _keyword_supplies_contract(keyword: ast.keyword, names: _MockNames, symbol:
             return False
         return names.resolve(keyword.value) not in _UNSPECCED_FACTORIES
     return keyword.arg in _PATCH_CONTRACT_KEYWORDS and not (
-        isinstance(keyword.value, ast.Constant) and keyword.value.value is None
+        isinstance(keyword.value, ast.Constant) and (keyword.value.value is None or keyword.value.value is False)
     )
 
 

sarj_python_lint-1.2.7/src/sarj_python_lint/rules/no_swallowed_asyncio_cancellation.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import ast
+from itertools import pairwise
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, ClassVar, final, override
+
+from sarj_python_lint.rule_base import (
+    AutofixPolicy,
+    Diagnostic,
+    ExampleFile,
+    ExampleOutcome,
+    Rule,
+    RuleCategory,
+    RuleDocumentation,
+    RuleExample,
+    Severity,
+    is_suppressed,
+)
+from sarj_python_lint.rules._ast_index import nodes
+from sarj_python_lint.rules._paths import is_test_path, is_test_support_path
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rules._imports import ImportIndex
+
+
+_ASYNCIO = frozenset({"asyncio", "asyncio.exceptions"})
+_SIMPLE_STATEMENTS = (ast.Expr, ast.Assign, ast.AnnAssign, ast.AugAssign, ast.Delete, ast.Pass)
+_MESSAGE = (
+    "CancelledError handler completes normally; re-raise caller cancellation after cleanup, "
+    "or guard intentional child cancellation with the current task's cancellation state."
+)
+
+
+@final
+class NoSwallowedAsyncioCancellation(Rule):
+    id = "no-swallowed-asyncio-cancellation"
+    code = "SARJ458"
+    documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
+        default_level=Severity.WARNING,
+        summary="Preserve cancellation when an async operation is cancelled.",
+        rationale=(
+            "Returning or falling through after catching CancelledError can make cancelled work look successful "
+            "and interfere with task groups and timeout shutdown. Child cancellation must be distinguished from "
+            "cancellation of the caller."
+        ),
+        remediation=(
+            "Re-raise after cleanup. If child cancellation is an expected result, first propagate cancellation "
+            "when asyncio.current_task().cancelling() is nonzero. Use an exact suppression for a documented "
+            "boundary that deliberately consumes cancellation."
+        ),
+        category=RuleCategory.CORRECTNESS,
+        autofix=AutofixPolicy.NONE,
+        limitations=(
+            "Only explicit, import-proven asyncio.CancelledError handlers in async functions are inspected; broad handlers, contextlib.suppress, tests, support fixtures, and generated files are excluded.",
+            "Only straight-line handlers with a return or normal fallthrough are reported. Compound handlers, re-raising, and translated exceptions are excluded. Any attribute call named uncancel is conservatively excluded without proving its receiver, so unrelated methods can hide a finding.",
+            "A single-name task created by asyncio.create_task, immediately cancelled before a try that only awaits it, is intentionally excluded as child cleanup; this does not prove concurrent caller cancellation cannot occur.",
+            "Try statements with control-transferring or compound finalizers are excluded, including handlers nested beneath them. Runtime helper effects and interprocedural task ownership are not inferred.",
+        ),
+        examples=(
+            RuleExample(
+                example_id="cancelled-operation-returns-success",
+                title="Cancellation becomes a successful return",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "worker.py",
+                        "import asyncio\n\nasync def worker():\n    try:\n        await asyncio.sleep(10)\n    except asyncio.CancelledError:\n        return None\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("worker.py"),
+                expected_count=1,
+                public=True,
+            ),
+            RuleExample(
+                example_id="cancelled-operation-reraises",
+                title="Cleanup preserves cancellation",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "worker.py",
+                        "import asyncio\n\nasync def worker():\n    try:\n        await asyncio.sleep(10)\n    except asyncio.CancelledError:\n        raise\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("worker.py"),
+                expected_count=0,
+                public=True,
+            ),
+        ),
+    )
+    description = documentation.summary
+
+    @override
+    def check_context(self, context: PythonFileContext) -> list[Diagnostic]:
+        if "CancelledError" not in context.source:
+            return []
+        if context.generated or is_test_path(context.path) or is_test_support_path(context.path):
+            return []
+        tree = context.tree
+        if tree is None:
+            return []
+        diagnostics: list[Diagnostic] = []
+        for function in nodes(tree, ast.AsyncFunctionDef, index=context.node_index):
+            diagnostics.extend(_function_diagnostics(function, context, self.code))
+        return sorted(diagnostics, key=lambda item: (item.line, item.col))
+
+
+def _function_diagnostics(function: ast.AsyncFunctionDef, context: PythonFileContext, code: str) -> list[Diagnostic]:
+    local = tuple(_local_nodes(function))
+    children = _owned_tasks(local, context.imports)
+    previous = _preceding_statements(local)
+    diagnostics: list[Diagnostic] = []
+    for node in local:
+        if not isinstance(node, ast.Try) or _owned_child_cleanup(node, previous.get(id(node)), children):
+            continue
+        for handler in node.handlers:
+            if not _catches_cancellation(handler.type, context.imports) or not _normal_exit(handler.body):
+                continue
+            if is_suppressed(context.source_lines, handler.lineno, code):
+                continue
+            diagnostics.append(
+                Diagnostic(
+                    path=context.path,
+                    line=handler.lineno,
+                    col=handler.col_offset + 1,
+                    code=code,
+                    message=_MESSAGE,
+                    severity=Severity.WARNING,
+                )
+            )
+    return diagnostics
+
+
+def _local_nodes(function: ast.AsyncFunctionDef) -> Iterator[ast.AST]:
+    stack: list[ast.AST] = list(reversed(function.body))
+    yield function
+    while stack:
+        node = stack.pop()
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.Lambda):
+            continue
+        if isinstance(node, ast.Try | ast.TryStar) and any(
+            not isinstance(statement, _SIMPLE_STATEMENTS) for statement in node.finalbody
+        ):
+            continue
+        yield node
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+
+
+def _catches_cancellation(exception: ast.expr | None, imports: ImportIndex) -> bool:
+    if isinstance(exception, ast.Tuple):
+        return any(_catches_cancellation(item, imports) for item in exception.elts)
+    return exception is not None and imports.resolves(exception, sources=_ASYNCIO, symbol="CancelledError")
+
+
+def _normal_exit(statements: list[ast.stmt]) -> bool:
+    for statement in statements:
+        if any(
+            isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "uncancel"
+            for node in ast.walk(statement)
+        ):
+            return False
+        if isinstance(statement, ast.Return):
+            return True
+        if not isinstance(statement, _SIMPLE_STATEMENTS):
+            return False
+    return True
+
+
+def _owned_tasks(local: tuple[ast.AST, ...], imports: ImportIndex) -> frozenset[str]:
+    bindings: dict[str, list[ast.AST]] = {}
+    for node in local:
+        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store | ast.Del):
+            bindings.setdefault(node.id, []).append(node)
+        if (
+            isinstance(node, ast.Attribute)
+            and isinstance(node.ctx, ast.Store | ast.Del)
+            and isinstance(node.value, ast.Name)
+        ):
+            bindings.setdefault(node.value.id, []).append(node)
+    return frozenset(
+        node.targets[0].id
+        for node in local
+        if isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and isinstance(node.targets[0], ast.Name)
+        and len(bindings[node.targets[0].id]) == 1
+        and isinstance(node.value, ast.Call)
+        and imports.resolves(node.value.func, sources=frozenset({"asyncio"}), symbol="create_task")
+    )
+
+
+def _preceding_statements(local: tuple[ast.AST, ...]) -> dict[int, ast.stmt]:
+    previous: dict[int, ast.stmt] = {}
+    for node in local:
+        for suite in _statement_suites(node):
+            for first, second in pairwise(suite):
+                previous[id(second)] = first
+    return previous
+
+
+def _owned_child_cleanup(node: ast.Try, previous: ast.stmt | None, children: frozenset[str]) -> bool:
+    if len(node.body) != 1:
+        return False
+    match node.body[0], previous:
+        case (
+            ast.Expr(value=ast.Await(value=ast.Name(id=awaited))),
+            ast.Expr(value=ast.Call(func=ast.Attribute(value=ast.Name(id=cancelled), attr="cancel"))),
+        ):
+            return awaited == cancelled and awaited in children
+        case _:
+            return False
+
+
+def _statement_suites(node: ast.AST) -> tuple[list[ast.stmt], ...]:
+    match node:
+        case ast.Try() | ast.TryStar():
+            return node.body, node.orelse, node.finalbody
+        case ast.If() | ast.For() | ast.AsyncFor() | ast.While():
+            return node.body, node.orelse
+        case ast.AsyncFunctionDef() | ast.With() | ast.AsyncWith() | ast.ExceptHandler() | ast.match_case():
+            return (node.body,)
+        case _:
+            return ()

{sarj_python_lint-1.2.4 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/repeated_test_composition.py

@@ -168,7 +168,7 @@ def _candidate(
     identity = f"{spec.symbol.module}.{spec.symbol.name}"
     if not _unconditional(context, node, function) or not _subject_called(context, function, node):
         return identity, None
-    blocked = (available.blocked - aliases.keys()) | changed_before(function, node)
+    blocked = (available.blocked - aliases.keys()) | changed_before(function, node, aliases)
     scope = WiringScope(available.parameters, aliases, frozenset(blocked))
     arguments = wiring(context, project, node, spec, scope)
     return identity, f"{identity}:{arguments!r}" if arguments is not None else None