sarj-python-lint 1.8.0__tar.gz → 1.8.3__tar.gz

{sarj_python_lint-1.8.0 → sarj_python_lint-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.8.0
+Version: 1.8.3
 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/
@@ -19,7 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.14
 Requires-Dist: packaging==26.3
 Requires-Dist: ruff>=0.16.9
-Requires-Dist: sarj-rule-contracts==0.1.1
+Requires-Dist: sarj-rule-contracts==0.2.0
 Requires-Dist: sqlglot==30.19.0
 Requires-Dist: typer==0.27.2
 Description-Content-Type: text/markdown

{sarj_python_lint-1.8.0 → sarj_python_lint-1.8.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.8.0"
+version = "1.8.3"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]
@@ -15,7 +15,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Quality Assurance",
 ]
-dependencies = ["sarj-rule-contracts==0.1.1", "packaging==26.3", "ruff>=0.16.9", "sqlglot==30.19.0", "typer==0.27.2"]
+dependencies = ["sarj-rule-contracts==0.2.0", "packaging==26.3", "ruff>=0.16.9", "sqlglot==30.19.0", "typer==0.27.2"]
 
 [project.scripts]
 sarj-python-lint = "sarj_python_lint.__main__:main"

{sarj_python_lint-1.8.0 → sarj_python_lint-1.8.3}/src/sarj_python_lint/rules/_project_index.py

@@ -4,6 +4,7 @@ import ast
 from collections.abc import Mapping
 from contextlib import suppress
 from dataclasses import dataclass
+from functools import cached_property
 import os
 from pathlib import Path
 import re
@@ -12,6 +13,7 @@ from typing import TYPE_CHECKING, final
 
 from sarj_python_lint.rules._ast_index import walk as walk_ast
 from sarj_python_lint.rules._first_party import FirstPartyFacts, project_root
+from sarj_python_lint.rules._paths import is_generated
 
 
 if TYPE_CHECKING:
@@ -179,6 +181,27 @@ class ProjectIndexSet:
             consumers.update(_unit_constructor_consumers(candidate, candidate.tree, target))
         return frozenset(consumers)
 
+    def constructor_operations(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
+        if unit.module is None:
+            return frozenset()
+        return self._constructor_operations.get(SymbolRef(unit.module, name), frozenset())
+
+    @cached_property
+    def _constructor_operations(self) -> Mapping[SymbolRef, frozenset[tuple[Path, str]]]:
+        module_counts: dict[str, int] = {}
+        for unit in self._units.values():
+            if unit.module is not None:
+                module_counts[unit.module] = module_counts.get(unit.module, 0) + 1
+        owned_modules = frozenset(module for module, count in module_counts.items() if count == 1)
+        operations: dict[SymbolRef, set[tuple[Path, str]]] = {}
+        for unit in self._units.values():
+            if unit.tree is None or unit.module not in owned_modules or is_generated(unit.path, unit.source):
+                continue
+            for symbol, operation in _unit_constructor_operations(unit, unit.tree, owned_modules):
+                if symbol.module in owned_modules and symbol in self._classes:
+                    operations.setdefault(symbol, set()).add((unit.path, operation))
+        return MappingProxyType({symbol: frozenset(calls) for symbol, calls in operations.items()})
+
     def direct_subclasses(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
         if unit.module is None:
             return frozenset()
@@ -554,6 +577,160 @@ def _unit_constructor_consumers(
             yield (candidate.path, owner.name)
 
 
+def _unit_constructor_operations(
+    unit: SourceUnit, tree: ast.Module, owned_modules: frozenset[str]
+) -> Iterator[tuple[SymbolRef, str]]:
+    if any(
+        isinstance(item, ast.ImportFrom) and any(alias.name == "*" for alias in item.names) for item in walk_ast(tree)
+    ):
+        return
+    rebound = _module_constructor_rebindings(tree)
+    for owner in tree.body:
+        self_symbol = SymbolRef(unit.module or "", owner.name) if isinstance(owner, ast.ClassDef) else None
+        for method in _direct_functions(owner):
+            for symbol, operation in _function_constructor_operations(unit, method, rebound, owned_modules):
+                if symbol != self_symbol:
+                    yield symbol, operation
+
+
+def _module_constructor_rebindings(tree: ast.Module) -> frozenset[str]:
+    names: set[str] = set()
+    declarations: dict[str, int] = {}
+    for statement in tree.body:
+        for name in _module_constructor_declarations(statement):
+            declarations[name] = declarations.get(name, 0) + 1
+        if isinstance(statement, ast.FunctionDef | ast.AsyncFunctionDef):
+            names.add(statement.name)
+        elif not isinstance(statement, ast.ClassDef | ast.Import | ast.ImportFrom):
+            names.update(_bound_constructor_names(statement))
+    names.update(name for name, count in declarations.items() if count > 1)
+    return frozenset(names)
+
+
+def _module_constructor_declarations(statement: ast.stmt) -> frozenset[str]:
+    if isinstance(statement, ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef):
+        return frozenset({statement.name})
+    return _bound_constructor_names(statement)
+
+
+def _direct_functions(owner: ast.stmt) -> tuple[ast.FunctionDef | ast.AsyncFunctionDef, ...]:
+    if isinstance(owner, ast.FunctionDef | ast.AsyncFunctionDef):
+        return (owner,)
+    if isinstance(owner, ast.ClassDef):
+        return tuple(item for item in owner.body if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef))
+    return ()
+
+
+def _function_constructor_operations(
+    unit: SourceUnit,
+    method: ast.FunctionDef | ast.AsyncFunctionDef,
+    rebound: frozenset[str],
+    owned_modules: frozenset[str],
+) -> Iterator[tuple[SymbolRef, str]]:
+    shadowed = _bound_constructor_names(method) | rebound
+    for statement in method.body:
+        if isinstance(statement, ast.Expr | ast.Assign | ast.AnnAssign | ast.Return):
+            operation = _direct_constructor_operation(unit, statement.value, shadowed, owned_modules)
+            if operation is not None:
+                yield operation
+        if isinstance(
+            statement,
+            ast.Return
+            | ast.Raise
+            | ast.If
+            | ast.For
+            | ast.AsyncFor
+            | ast.While
+            | ast.Try
+            | ast.TryStar
+            | ast.With
+            | ast.AsyncWith
+            | ast.Match,
+        ):
+            break
+
+
+def _direct_constructor_operation(
+    unit: SourceUnit, value: ast.expr | None, shadowed: frozenset[str], owned_modules: frozenset[str]
+) -> tuple[SymbolRef, str] | None:
+    if isinstance(value, ast.Await):
+        value = value.value
+    if not isinstance(value, ast.Call) or not isinstance(value.func, ast.Attribute):
+        return None
+    if not isinstance(value.func.value, ast.Call):
+        return None
+    constructor = value.func.value.func
+    root = constructor
+    while isinstance(root, ast.Attribute):
+        root = root.value
+    if not isinstance(root, ast.Name) or root.id in shadowed:
+        return None
+    symbol = _owned_constructor_symbol(unit, constructor, owned_modules)
+    return (symbol, value.func.attr) if symbol is not None else None
+
+
+def _owned_constructor_symbol(
+    unit: SourceUnit, expression: ast.expr, owned_modules: frozenset[str]
+) -> SymbolRef | None:
+    if isinstance(expression, ast.Name):
+        return _resolve(unit, expression)
+    parts: list[str] = []
+    current = expression
+    while isinstance(current, ast.Attribute):
+        parts.append(current.attr)
+        current = current.value
+    if not isinstance(current, ast.Name) or not parts:
+        return None
+    imported = unit.imports.get(current.id)
+    if imported is None or imported.name:
+        return None
+    ordered = list(reversed(parts))
+    module = ".".join((imported.module, *ordered[:-1]))
+    if len(ordered) > 1 and not _explicit_constructor_module(unit, module):
+        return None
+    return SymbolRef(module, ordered[-1]) if module in owned_modules else None
+
+
+def _explicit_constructor_module(unit: SourceUnit, module: str) -> bool:
+    if unit.tree is None:
+        return False
+    return any(
+        alias.name == module and alias.asname is None
+        for statement in _module_import_statements(unit.tree)
+        if isinstance(statement, ast.Import)
+        for alias in statement.names
+    )
+
+
+def _bound_constructor_names(node: ast.AST) -> frozenset[str]:
+    names: set[str] = set()
+    for item in walk_ast(node):
+        match item:
+            case (
+                ast.Name(id=name, ctx=(ast.Store() | ast.Del()))
+                | ast.arg(arg=name)
+                | ast.ClassDef(name=name)
+                | ast.FunctionDef(name=name)
+                | ast.AsyncFunctionDef(name=name)
+                | ast.ExceptHandler(name=str(name))
+                | ast.MatchAs(name=str(name))
+                | ast.MatchStar(name=str(name))
+                | ast.MatchMapping(rest=str(name))
+            ):
+                names.add(name)
+            case ast.Import(names=aliases) | ast.ImportFrom(names=aliases):
+                names.update(alias.asname or alias.name.split(".", 1)[0] for alias in aliases)
+            case ast.Attribute(ctx=(ast.Store() | ast.Del())):
+                root = item.value
+                while isinstance(root, ast.Attribute):
+                    root = root.value
+                if isinstance(root, ast.Name):
+                    names.add(root.id)
+            case _:
+                pass
+    return frozenset(names)
+
+
 def _class_has_typed_dependency(unit: SourceUnit, owner: ast.ClassDef, target: SymbolRef) -> bool:
     for statement in owner.body:
         if isinstance(statement, ast.AnnAssign) and _annotation_contains_symbol(unit, statement.annotation, target):

{sarj_python_lint-1.8.0 → sarj_python_lint-1.8.3}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from enum import Enum, auto
 from pathlib import PurePosixPath
 from types import MappingProxyType
 from typing import TYPE_CHECKING, ClassVar, Final, final, override
@@ -65,12 +66,18 @@ type _TestFunction = ast.FunctionDef | ast.AsyncFunctionDef
 type _Reference = tuple[str, ...]
 
 
+class _Evidence(Enum):
+    POSITIVE = auto()
+    INSUFFICIENT = auto()
+    UNRESOLVED = auto()
+
+
 @final
 class AsyncMockCallWithoutAwaitAssertion(Rule):
     id = "async-mock-call-without-await-assertion"
     code = "SARJ456"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.ERROR,
+        default_level=Severity.WARNING,
         summary="Pair positive AsyncMock call assertions with evidence that the mock was awaited.",
         rationale=(
             "Calling an AsyncMock records a call before its coroutine is awaited. A positive call assertion can "
@@ -87,33 +94,50 @@ 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.",
-            "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.",
+            "Positive call evidence includes direct assertion methods and literal integer or boolean call-state checks; unresolved call expectations are excluded.",
+            "Await evidence excludes provably vacuous checks, including zero or nonnegative counts and empty expected await sequences; unresolved expectations are accepted without inferring their values.",
+            "Conjunctions need one accepted await branch; disjunctions need accepted evidence for the same mock in every branch. Argument equality and assertion strength are not compared.",
+            "Compound negation and custom expression semantics remain unresolved; no variable values or fixture graphs are 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",
+                example_id="call-only-async-mock",
+                title="A call assertion does not prove awaiting",
                 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",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once_with('item')\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_delivery.py"),
                 expected_count=1,
-                public=False,
+                public=True,
             ),
             RuleExample(
-                example_id="call-only-async-mock",
-                title="A call assertion does not prove awaiting",
+                example_id="call-and-await-async-mock",
+                title="Call and await assertions protect different contracts",
+                outcome=ExampleOutcome.NO_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    send.assert_called_once_with('item')\n    send.assert_awaited_once_with('item')\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=0,
+                public=True,
+            ),
+            RuleExample(
+                example_id="vacuous-await-count",
+                scenario="await-expectation-boundaries",
+                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    send.assert_called_once_with('item')\n",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    assert send.call_count == 1\n    assert send.await_count >= 0\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_delivery.py"),
@@ -121,13 +145,14 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
                 public=True,
             ),
             RuleExample(
-                example_id="call-and-await-async-mock",
-                title="Call and await assertions protect different contracts",
+                example_id="dynamic-expected-awaits",
+                scenario="await-expectation-boundaries",
+                title="Unresolved await expectations retain their acceptance",
                 outcome=ExampleOutcome.NO_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    send.assert_called_once_with('item')\n    send.assert_awaited_once_with('item')\n",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery(expected):\n    send = AsyncMock()\n    await deliver(send)\n    send.assert_called_once()\n    send.assert_has_awaits(expected)\n",
                     ),
                 ),
                 focus_path=PurePosixPath("tests/test_delivery.py"),
@@ -166,7 +191,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
                 line=call.lineno,
                 col=call.col_offset + 1,
                 code=self.code,
-                severity=Severity.ERROR,
+                severity=Severity.WARNING,
                 message="AsyncMock call assertions do not prove awaiting; keep this assertion and add an await assertion",
             )
             for test in _collected_tests(tree.body)
@@ -231,7 +256,7 @@ def _call_oracles(statement: ast.stmt) -> Iterator[tuple[_Reference, ast.Call |
         ):
             yield _reference(receiver), call
         case ast.Assert(test=condition):
-            for reference in sorted(_positive_states(condition, _CALL_STATE)):
+            for reference in sorted(_asserted_states(condition, _CALL_STATE)):
                 oracle = next(
                     node
                     for node in walk_ast(condition)
@@ -304,49 +329,60 @@ def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
             case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
                 method in _AWAIT_ASSERTIONS
             ):
-                if method != "assert_has_awaits" or _has_nonempty_calls_argument(call):
+                if method != "assert_has_awaits" or _calls_evidence(call) is not _Evidence.INSUFFICIENT:
                     covered.add(_reference(receiver))
             case ast.Assert(test=condition):
-                covered.update(_positive_states(condition, _AWAIT_STATE))
+                covered.update(_asserted_states(condition, _AWAIT_STATE))
             case _:
                 pass
     return covered
 
 
-def _has_nonempty_calls_argument(call: ast.Call) -> bool:
+def _calls_evidence(call: ast.Call) -> _Evidence:
     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()
+        return _sequence_evidence(call.args[0])
+    for keyword in call.keywords:
+        if keyword.arg == "calls":
+            return _sequence_evidence(keyword.value)
+    return _Evidence.UNRESOLVED
+
+
+def _sequence_evidence(node: ast.expr) -> _Evidence:
+    if isinstance(node, (ast.List, ast.Tuple)):
+        if not node.elts:
+            return _Evidence.INSUFFICIENT
+        if any(not isinstance(item, ast.Starred) for item in node.elts):
+            return _Evidence.POSITIVE
+    return _Evidence.UNRESOLVED
+
+
+def _asserted_states(condition: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    match condition:
+        case ast.UnaryOp(op=ast.Not(), operand=ast.UnaryOp(op=ast.Not(), operand=operand)):
+            return _asserted_states(operand, states)
+        case ast.UnaryOp(op=ast.Not(), operand=ast.Compare(left=left, ops=[operator], comparators=[right])):
+            inverse = _negated_operator(operator)
+            return _comparison_states(left, inverse, right, states) if inverse is not None else set()
+        case ast.UnaryOp(op=ast.Not(), operand=ast.Attribute(attr=attribute)) if attribute in states:
+            return set()
+        case ast.BoolOp(op=operator, values=values):
+            branches = [_asserted_states(value, states) for value in values]
+            return (
+                branches[0].union(*branches[1:])
+                if isinstance(operator, ast.And)
+                else branches[0].intersection(*branches[1:])
+            )
+        case ast.Attribute(value=receiver, attr=attribute) if attribute in states:
+            return {_reference(receiver)}
+        case ast.Compare(left=left, ops=operators, comparators=rights):
+            result: set[_Reference] = set()
+            for first, operator, second in zip((left, *rights[:-1]), operators, rights, strict=True):
+                result.update(_comparison_states(first, operator, second, states))
+            return result
+        case _:
+            # Preserve acceptance of unresolved await-state assertions, such as
+            # len(mock.await_args_list) == expected, without value propagation.
+            return _unresolved_await_states(condition, states)
 
 
 def _negated_operator(operator: ast.cmpop) -> ast.cmpop | None:
@@ -364,6 +400,18 @@ def _negated_operator(operator: ast.cmpop) -> ast.cmpop | None:
     return factory() if factory is not None else None
 
 
+def _comparison_states(left: ast.expr, operator: ast.cmpop, right: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    result: set[_Reference] = set()
+    for node, comparison, expected in ((left, operator, right), (right, _reversed_operator(operator), left)):
+        if isinstance(node, ast.Attribute) and node.attr in states:
+            evidence = _state_evidence(node.attr, comparison, expected)
+            if evidence is _Evidence.POSITIVE or (states == _AWAIT_STATE and evidence is _Evidence.UNRESOLVED):
+                result.add(_reference(node.value))
+        else:
+            result.update(_unresolved_await_states(node, states))
+    return result
+
+
 def _reversed_operator(operator: ast.cmpop) -> ast.cmpop:
     match operator:
         case ast.Lt():
@@ -378,32 +426,38 @@ def _reversed_operator(operator: ast.cmpop) -> ast.cmpop:
             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):
+def _unresolved_await_states(node: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    if states != _AWAIT_STATE:
         return set()
+    return {
+        _reference(child.value) for child in walk_ast(node) if isinstance(child, ast.Attribute) and child.attr in states
+    }
+
+
+def _state_evidence(attribute: str, operator: ast.cmpop, expected: ast.expr) -> _Evidence:
+    positive: bool
     if (
-        states == _AWAIT_STATE
-        and isinstance(left.value, ast.Attribute)
-        and left.value.attr == "await_args"
-        and left.attr in {"args", "kwargs"}
+        attribute in {"call_count", "await_count"}
+        and isinstance(expected, ast.Constant)
+        and isinstance(expected.value, int)
     ):
-        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
+        positive = _proves_positive_count(operator, expected.value)
+    elif attribute == "called" and isinstance(expected, ast.Constant) and isinstance(expected.value, bool):
+        positive = (isinstance(operator, (ast.Eq, ast.Is)) and expected.value) or (
+            isinstance(operator, (ast.NotEq, ast.IsNot)) and not expected.value
         )
-    elif left.attr == "await_args" and isinstance(right, ast.Constant) and right.value is None:
+    elif attribute == "await_args" and isinstance(expected, ast.Constant) and expected.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
+    elif attribute == "await_args_list" and isinstance(operator, (ast.Eq, ast.NotEq)):
+        sequence = _sequence_evidence(expected)
+        if sequence is _Evidence.UNRESOLVED:
+            return sequence
+        positive = (isinstance(operator, ast.Eq) and sequence is _Evidence.POSITIVE) or (
+            isinstance(operator, ast.NotEq) and isinstance(expected, ast.List) and sequence is _Evidence.INSUFFICIENT
         )
-    return {_reference(left.value)} if positive else set()
+    else:
+        return _Evidence.UNRESOLVED
+    return _Evidence.POSITIVE if positive else _Evidence.INSUFFICIENT
 
 
 def _proves_positive_count(operator: ast.cmpop, value: int) -> bool:
@@ -418,10 +472,6 @@ def _proves_positive_count(operator: ast.cmpop, value: int) -> bool:
             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()):