sarj-python-lint 1.60.0__tar.gz → 1.61.1__tar.gz

{sarj_python_lint-1.60.0 → sarj_python_lint-1.61.1}/PKG-INFO

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

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

{sarj_python_lint-1.60.0 → sarj_python_lint-1.61.1}/src/sarj_python_lint/rules/no_any_mapping_types.py

@@ -117,6 +117,34 @@ class NoAnyMappingTypes(Rule):
                 expected_count=0,
                 public=True,
             ),
+            RuleExample(
+                example_id="generic-any-binding",
+                scenario="provider-identity",
+                title="A generic parameter named Any keeps its own identity",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py", "from typing import Any\nclass Rows[Any]:\n    rows: dict[str, Any]\n"
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=0,
+                public=True,
+            ),
+            RuleExample(
+                example_id="generic-typing-any",
+                scenario="provider-identity",
+                title="An unrelated generic parameter preserves actual Any erasure",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py", "from typing import Any\nclass Rows[T]:\n    rows: dict[str, Any]\n"
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=1,
+                public=True,
+            ),
         ),
     )
     description = documentation.summary
@@ -236,11 +264,12 @@ def _unshadowed_any_mappings(
     if parsed is None:
         return []
     names = {node.id for node in walk_ast(parsed) if isinstance(node, ast.Name)}
-    if not names.isdisjoint(_shadowed_names(owner, parents, scope_cache)):
+    type_parameters = frozenset(_generic_scope_names(owner, parents))
+    if not names.isdisjoint(_shadowed_names(owner, parents, scope_cache) - type_parameters):
         return []
     return [
         (mapping, expression if isinstance(expression, ast.Constant) else mapping)
-        for mapping in _any_mappings(expression, semantics)
+        for mapping in _any_mappings(expression, semantics, shadowed=type_parameters)
     ]
 
 
@@ -546,12 +575,39 @@ def _unshadowed_type_expression(
     return names.isdisjoint(_shadowed_names(node, parents, scope_cache))
 
 
+def _generic_scope_names(node: ast.AST, parents: dict[int, ast.AST]) -> set[str]:
+    names = _type_parameter_names(node)
+    below = node
+    parent = parents.get(id(below))
+    function_default = False
+    while parent is not None:
+        match parent:
+            case ast.arguments():
+                function_default = below in parent.defaults or below in parent.kw_defaults
+            case ast.FunctionDef() | ast.AsyncFunctionDef():
+                if not function_default and below not in parent.decorator_list:
+                    names.update(_type_parameter_names(parent))
+                function_default = False
+            case ast.Lambda():
+                function_default = False
+            case ast.ClassDef():
+                if below not in parent.decorator_list:
+                    names.update(_type_parameter_names(parent))
+            case ast.TypeAlias():
+                names.update(_type_parameter_names(parent))
+            case _:
+                pass
+        below = parent
+        parent = parents.get(id(below))
+    return names
+
+
 def _shadowed_names(
     node: ast.AST,
     parents: dict[int, ast.AST],
     scope_cache: dict[int, frozenset[str]],
 ) -> set[str]:
-    shadowed: set[str] = set()
+    shadowed = _generic_scope_names(node, parents)
     crossed_function_body = False
     below = node
     parent = parents.get(id(below))
@@ -567,6 +623,16 @@ def _shadowed_names(
     return shadowed
 
 
+def _type_parameter_names(node: ast.AST) -> set[str]:
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.TypeAlias)):
+        return {
+            parameter.name
+            for parameter in node.type_params
+            if isinstance(parameter, (ast.TypeVar, ast.ParamSpec, ast.TypeVarTuple))
+        }
+    return set()
+
+
 def _scope_names(
     owner: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef,
     cache: dict[int, frozenset[str]],
@@ -628,7 +694,9 @@ def _type_comment(comment: str, owner: ast.AST) -> ast.expr | None:
     return expression
 
 
-def _any_mappings(annotation: ast.expr, semantics: AnnotationSemantics) -> list[ast.Subscript]:
+def _any_mappings(
+    annotation: ast.expr, semantics: AnnotationSemantics, *, shadowed: frozenset[str] = frozenset()
+) -> list[ast.Subscript]:
     resolved = semantics.parse(annotation)
     if resolved is None:
         return []
@@ -636,24 +704,30 @@ def _any_mappings(annotation: ast.expr, semantics: AnnotationSemantics) -> list[
     mappings: list[ast.Subscript] = []
     while pending:
         node = pending.pop()
-        if isinstance(node, ast.Subscript) and _is_any_mapping(node, semantics):
+        if isinstance(node, ast.Subscript) and _is_any_mapping(node, semantics, shadowed=shadowed):
             mappings.append(node)
-        pending.extend(_type_children(node, semantics))
+        pending.extend(_type_children(node, semantics, shadowed=shadowed))
     return mappings
 
 
-def _is_any_mapping(node: ast.Subscript, semantics: AnnotationSemantics) -> bool:
+def _is_any_mapping(node: ast.Subscript, semantics: AnnotationSemantics, *, shadowed: frozenset[str]) -> bool:
     if not isinstance(node.slice, ast.Tuple) or len(node.slice.elts) != _MAPPING_ARGUMENT_COUNT:
         return False
     imports = semantics.imports
     target = node.value
+    if _expression_root(target) in shadowed:
+        return False
     mapping = (isinstance(target, ast.Name) and target.id == "dict" and imports.builtin_is_unshadowed("dict")) or any(
         imports.resolves(target, sources=_MAPPING_SOURCES, symbol=name) for name in _MAPPING_NAMES
     )
     if not mapping:
         return False
     key, value = node.slice.elts
-    return _is_builtin_str(key, imports) and _contains_any(value, semantics, seen=frozenset())
+    return (
+        _expression_root(key) not in shadowed
+        and _is_builtin_str(key, imports)
+        and _contains_any(value, semantics, seen=frozenset(), shadowed=shadowed)
+    )
 
 
 def _is_builtin_str(node: ast.expr, imports: ImportIndex) -> bool:
@@ -665,20 +739,30 @@ def _contains_any(
     semantics: AnnotationSemantics,
     *,
     seen: frozenset[str],
+    shadowed: frozenset[str] = frozenset(),
 ) -> bool:
     parsed = semantics.parse(node)
-    if parsed is None:
+    if parsed is None or _expression_root(parsed) in shadowed:
         return False
     imports = semantics.imports
     if imports.resolves(parsed, sources=_TYPING_SOURCES, symbol="Any"):
         return True
     if isinstance(parsed, ast.Name) and parsed.id in semantics.aliases and parsed.id not in seen:
+        # Module aliases retain their declaration scope, independent of a
+        # generic name at this annotation's use site.
         return _contains_any(semantics.aliases[parsed.id], semantics, seen=seen | {parsed.id})
-    return any(_contains_any(child, semantics, seen=seen) for child in _type_children(parsed, semantics))
+    return any(
+        _contains_any(child, semantics, seen=seen, shadowed=shadowed)
+        for child in _type_children(parsed, semantics, shadowed=shadowed)
+    )
 
 
-def _type_children(node: ast.expr, semantics: AnnotationSemantics) -> tuple[ast.expr, ...]:
+def _type_children(
+    node: ast.expr, semantics: AnnotationSemantics, *, shadowed: frozenset[str] = frozenset()
+) -> tuple[ast.expr, ...]:
     if isinstance(node, ast.Subscript):
+        if _expression_root(node.value) in shadowed:
+            return ()
         imports = semantics.imports
         symbol = imports.resolved_symbol(node.value, sources=_TYPING_SOURCES | _MAPPING_SOURCES)
         if symbol == "Literal":

{sarj_python_lint-1.60.0 → sarj_python_lint-1.61.1}/src/sarj_python_lint/rules/no_mutating_container_transform.py

@@ -132,7 +132,7 @@ class NoMutatingContainerTransform(Rule):
     id = "no-mutating-container-transform"
     code = "SARJ520"
     documentation: ClassVar[RuleDocumentation | None] = RuleDocumentation(
-        default_level=Severity.WARNING,
+        default_level=Severity.ERROR,
         summary="Return container replacements without mutating borrowed builtin inputs.",
         rationale="A container-valued transformation can change caller aliases before returning its result. Copying after the write leaves the original input changed.",
         remediation="Copy each changed container before writing, return a fresh replacement, or expose a separate command returning None. Keep documented in-place contracts explicit; do not discard the operation or add a dummy assignment.",
@@ -203,7 +203,7 @@ class NoMutatingContainerTransform(Rule):
                 col=mutation.node.col_offset + 1,
                 code=self.code,
                 message=f"This container-valued transformation mutates borrowed {mutation.owner.kind} input `{mutation.owner.parameter}`; copy before writing or use a command returning None.",
-                severity=Severity.WARNING,
+                severity=Severity.ERROR,
             )
             for function in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef)
             for mutation in analysis.mutations(function)

{sarj_python_lint-1.60.0 → sarj_python_lint-1.61.1}/src/sarj_python_lint/rules/no_raw_source_text_test_oracle.py

@@ -148,6 +148,7 @@ class NoRawSourceTextTestOracle(Rule):
         autofix=AutofixPolicy.NONE,
         aliases=("source-coupled-test",),
         limitations=(
+            "A literal module-level __test__ = False disables pytest collection. Later bindings in eager module expressions or explicitly global class scopes clear that proof; class-local names, deferred bodies, and annotation-only names do not rebind it.",
             "The rule recognizes source-like suffixes, shell templates ending in .sh.tftpl, and the exact Dockerfile basename; it follows local aliases, context-managed reads, and common normalization.",
             "Direct generator/list-comprehension reads unpacked from stable module-level path tuples are followed; mutable collections, rebinding, filtered comprehensions, and interprocedural flows remain unreported.",
             "Literal shebang startswith checks are representation contracts and remain unreported; other text compatibility sentinels require an exact suppression.",
@@ -186,6 +187,38 @@ class NoRawSourceTextTestOracle(Rule):
                 expected_count=1,
                 public=True,
             ),
+            RuleExample(
+                example_id="disabled-module-source-oracle",
+                scenario="module-collection",
+                title="An explicitly disabled module has no collected source oracle",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_policy.py",
+                        "__test__ = False\nfrom pathlib import Path\ndef test_policy():\n"
+                        "    source = Path('workflow.yml').read_text()\n    assert 'permissions:' in source\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_policy.py"),
+                expected_count=0,
+                public=True,
+            ),
+            RuleExample(
+                example_id="enabled-module-source-oracle",
+                scenario="module-collection",
+                title="An enabled module still needs a parsed source contract",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_policy.py",
+                        "__test__ = True\nfrom pathlib import Path\ndef test_policy():\n"
+                        "    source = Path('workflow.yml').read_text()\n    assert 'permissions:' in source\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_policy.py"),
+                expected_count=1,
+                public=True,
+            ),
         ),
     )
     description = documentation.summary
@@ -233,6 +266,8 @@ class NoRawSourceTextTestOracle(Rule):
 
 
 def top_level_test_functions(tree: ast.Module, imports: ImportIndex | None = None) -> list[TestFunction]:
+    if _module_collection_disabled(tree):
+        return []
     resolved_imports = imports or ImportIndex.from_tree(tree, module_scope_only=True)
     opted_out = _module_test_opt_outs(tree)
     functions: list[TestFunction] = []
@@ -249,6 +284,116 @@ def top_level_test_functions(tree: ast.Module, imports: ImportIndex | None = Non
     return functions
 
 
+def _module_collection_disabled(tree: ast.Module) -> bool:
+    disabled = False
+    for statement in tree.body:
+        match statement:
+            case ast.Assign(targets=targets) if any(
+                isinstance(target, ast.Name) and target.id == "__test__" for target in targets
+            ):
+                disabled = _assignment_disables_module_tests(statement)
+            case ast.AnnAssign(target=ast.Name(id="__test__"), value=value):
+                if value is not None:
+                    disabled = isinstance(value, ast.Constant) and value.value is False
+            case _:
+                if disabled and _eagerly_binds_module_test(statement):
+                    disabled = False
+    return disabled
+
+
+def _assignment_disables_module_tests(statement: ast.Assign) -> bool:
+    value = statement.value
+    if not isinstance(value, ast.Constant) or value.value is not False:
+        return False
+    return not any(
+        _eagerly_binds_module_test(target) for target in statement.targets if not isinstance(target, ast.Name)
+    )
+
+
+def _eagerly_binds_module_test(node: ast.AST) -> bool:
+    pending = [(node, True)]
+    while pending:
+        current, module_scope = pending.pop()
+        if module_scope and _eager_node_binds_test(current):
+            return True
+        if isinstance(current, ast.ClassDef):
+            class_module_scope = _class_declares_global_test(current)
+            pending.extend((child, class_module_scope) for child in current.body)
+        pending.extend((child, module_scope) for child in _eager_scope_children(current))
+    return False
+
+
+def _eager_node_binds_test(node: ast.AST) -> bool:
+    match node:
+        case (
+            ast.FunctionDef(name="__test__")
+            | ast.AsyncFunctionDef(name="__test__")
+            | ast.ClassDef(name="__test__")
+            | ast.TypeAlias(name=ast.Name(id="__test__"))
+            | ast.ExceptHandler(name="__test__")
+            | ast.MatchAs(name="__test__")
+            | ast.MatchStar(name="__test__")
+            | ast.MatchMapping(rest="__test__")
+            | ast.Name(id="__test__", ctx=(ast.Store() | ast.Del()))
+        ):
+            return True
+        case ast.Import(names=aliases) | ast.ImportFrom(names=aliases):
+            return any((alias.asname or alias.name.partition(".")[0]) in {"__test__", "*"} for alias in aliases)
+        case _:
+            return False
+
+
+def _eager_scope_children(node: ast.AST) -> list[ast.AST]:
+    match node:
+        case ast.FunctionDef() | ast.AsyncFunctionDef():
+            # Headers run now; annotations and the body are deferred.
+            return [*node.decorator_list, *_eager_argument_defaults(node.args)]
+        case ast.ClassDef():
+            return [*node.decorator_list, *node.bases, *(keyword.value for keyword in node.keywords)]
+        case ast.Lambda():
+            return _eager_argument_defaults(node.args)
+        case ast.ListComp() | ast.SetComp() | ast.DictComp():
+            return _comprehension_eager_children(node)
+        case ast.GeneratorExp():
+            return [node.generators[0].iter]
+        case ast.TypeAlias() | ast.Import() | ast.ImportFrom():
+            return []
+        case ast.AnnAssign():
+            return _annotated_assignment_eager_children(node)
+        case _:
+            return list(ast.iter_child_nodes(node))
+
+
+def _eager_argument_defaults(arguments: ast.arguments) -> list[ast.AST]:
+    return [*arguments.defaults, *filter(None, arguments.kw_defaults)]
+
+
+def _comprehension_eager_children(node: ast.ListComp | ast.SetComp | ast.DictComp) -> list[ast.AST]:
+    # Iteration targets stay local; walrus bindings use the enclosing scope.
+    children: list[ast.AST] = [node.key, node.value] if isinstance(node, ast.DictComp) else [node.elt]
+    children.extend(generator.iter for generator in node.generators)
+    children.extend(condition for generator in node.generators for condition in generator.ifs)
+    return children
+
+
+def _annotated_assignment_eager_children(node: ast.AnnAssign) -> list[ast.AST]:
+    if node.value is None:
+        return [] if isinstance(node.target, ast.Name) else [node.target]
+    return [node.target, node.value]
+
+
+def _class_declares_global_test(node: ast.ClassDef) -> bool:
+    pending: list[ast.AST] = list(node.body)
+    while pending:
+        current = pending.pop()
+        if isinstance(current, ast.Global) and "__test__" in current.names:
+            return True
+        if isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.Lambda):
+            continue
+        pending.extend(ast.iter_child_nodes(current))
+    return False
+
+
 def _class_test_functions(
     statement: ast.ClassDef, resolved_imports: ImportIndex, opted_out: frozenset[str]
 ) -> list[TestFunction]:

{sarj_python_lint-1.60.0 → sarj_python_lint-1.61.1}/src/sarj_python_lint/rules/prefer_nominal_id_types.py

@@ -20,7 +20,7 @@ from sarj_python_lint.rule_base import (
     Severity,
     is_suppressed,
 )
-from sarj_python_lint.rules._ast_index import nodes, walk as walk_ast
+from sarj_python_lint.rules._ast_index import nodes, parent_map, walk as walk_ast
 from sarj_python_lint.rules._inherited_contract import inherited_contract
 from sarj_python_lint.rules._nominal_project import NominalSource
 
@@ -155,7 +155,7 @@ class PreferNominalIdTypes(Rule):
             "The rule checks functions, methods, constructors, and classes for at least two ID-shaped roles with the same proven carrier. Existing coverage remains an error.",
             "Imported first-party carriers and non-ID roles backed by a unique matching NewType in the owning distribution or a declared local dependency are warnings. Ambiguous exports, conditional or relative imports, cycles, and unresolved ownership are skipped.",
             "Non-ID role discovery uses exact snake-case names and proven matching carriers; it does not infer brands from names alone. Dependency discovery respects declared workspace members and exclusions, and excludes optional and transitive dependencies.",
-            "Rebound aliases, generic aliases, carrier names shadowed by type parameters, and mutated factory namespaces are skipped conservatively across the file.",
+            "Rebound aliases, generic aliases, carrier names shadowed by type parameters, and mutated or escaped canonical provider namespaces are skipped conservatively across the file.",
             "Generated code, migrations, external adapters, operational context, raw schemas, SQLAlchemy Mapped fields, ambiguous imports, and unlike carrier shapes are excluded.",
             "Classes with explicit bases, including object, are excluded without requiring an override decorator. Local base declarations do not prove runtime member ownership remains closed; class construction, native hooks and escaped handles can change inheritance. Independent module functions and plain classes remain eligible.",
         ),
@@ -221,6 +221,21 @@ class PreferNominalIdTypes(Rule):
                 expected_count=0,
                 public=False,
             ),
+            RuleExample(
+                example_id="escaped-canonical-provider",
+                scenario="provider-identity",
+                title="An escaped factory namespace does not establish canonical domain roles",
+                outcome=ExampleOutcome.NO_MATCH,
+                files=(
+                    ExampleFile.python(
+                        "app/service.py",
+                        "import typing\ndef replace(namespace):\n    namespace.NewType = lambda name, value: value\nreplace(typing)\nRoomName = typing.NewType('RoomName', str)\nCallId = typing.NewType('CallId', str)\ndef record(room_name: str, call_id: str) -> None: ...\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("app/service.py"),
+                expected_count=0,
+                public=False,
+            ),
         ),
     )
     description: str = documentation.summary
@@ -611,22 +626,103 @@ def _carrier_shadowed_names(
 ) -> frozenset[str]:
     # Match ImportIndex's conservative whole-file treatment of ambiguous bindings.
     # PEP 695 parameters and mutations of imported namespaces also defeat identity.
-    shadowed: set[str] = set()
+    shadowed = _escaped_provider_names(tree, imports, node_index=node_index)
     for node in nodes(tree, ast.TypeVar, ast.ParamSpec, ast.TypeVarTuple, ast.Attribute, ast.Call, index=node_index):
-        if isinstance(node, (ast.TypeVar, ast.ParamSpec, ast.TypeVarTuple)):
-            shadowed.add(node.name)
-        elif isinstance(node, ast.Attribute):
-            if isinstance(node.ctx, (ast.Store, ast.Del)) or node.attr in {"__dict__", "__setattr__", "__delattr__"}:
-                shadowed.add(ast.unparse(node).partition(".")[0])
-        elif node.args and any(
-            (isinstance(node.func, ast.Name) and node.func.id == symbol and imports.builtin_is_unshadowed(symbol))
-            or imports.resolves(node.func, sources=_BUILTIN_SOURCES, symbol=symbol)
-            for symbol in ("setattr", "delattr", "vars")
-        ):
-            shadowed.add(ast.unparse(node.args[0]).partition(".")[0])
+        match node:
+            case ast.TypeVar() | ast.ParamSpec() | ast.TypeVarTuple():
+                shadowed.add(node.name)
+            case ast.Attribute():
+                shadowed.update(_attribute_provider_shadowed_names(node, imports))
+            case ast.Call():
+                shadowed.update(_call_provider_shadowed_names(node, imports))
     return frozenset(shadowed)
 
 
+def _attribute_provider_shadowed_names(node: ast.Attribute, imports: ImportIndex) -> set[str]:
+    if not isinstance(node.ctx, (ast.Store, ast.Del)) and node.attr not in {
+        "__dict__",
+        "__setattr__",
+        "__delattr__",
+        "__getattribute__",
+    }:
+        return set()
+    shadowed = {ast.unparse(node).partition(".")[0]}
+    if isinstance(node.value, ast.Name):
+        shadowed.update(_mutated_builtin_names(node.value, node.attr, imports))
+    return shadowed
+
+
+def _call_provider_shadowed_names(node: ast.Call, imports: ImportIndex) -> set[str]:
+    if not node.args or not _is_builtin_namespace_call(node, imports):
+        return set()
+    shadowed = {ast.unparse(node.args[0]).partition(".")[0]}
+    member = (
+        node.args[1].value
+        if len(node.args) > 1 and isinstance(node.args[1], ast.Constant) and isinstance(node.args[1].value, str)
+        else None
+    )
+    shadowed.update(_mutated_builtin_names(node.args[0], member, imports))
+    return shadowed
+
+
+def _is_builtin_namespace_call(node: ast.Call, imports: ImportIndex) -> bool:
+    return any(
+        (isinstance(node.func, ast.Name) and node.func.id == symbol and imports.builtin_is_unshadowed(symbol))
+        or imports.resolves(node.func, sources=_BUILTIN_SOURCES, symbol=symbol)
+        for symbol in ("setattr", "delattr", "vars")
+    )
+
+
+def _escaped_provider_names(tree: ast.Module, imports: ImportIndex, *, node_index: NodeIndex | None) -> set[str]:
+    providers = _TYPING_SOURCES | _BUILTIN_SOURCES | _UUID_SOURCES
+    namespaces = {
+        name: binding.module
+        for name, binding in imports.bindings.items()
+        if binding.module in providers and binding.symbol is None
+    }
+    if not namespaces:
+        return set()
+    parents = parent_map(tree, index=node_index)
+    shadowed: set[str] = set()
+    for node in nodes(tree, ast.Name, index=node_index):
+        if not isinstance(node.ctx, ast.Load) or node.id not in namespaces:
+            continue
+        if _direct_provider_access(node, parents.get(node), imports):
+            continue
+        provider = namespaces[node.id]
+        shadowed.update(name for name, binding in imports.bindings.items() if binding.module == provider)
+        shadowed.update(_mutated_builtin_names(node, None, imports))
+    return shadowed
+
+
+def _direct_provider_access(node: ast.Name, parent: ast.AST | None, imports: ImportIndex) -> bool:
+    if isinstance(parent, ast.Attribute) and parent.value is node:
+        return True
+    return (
+        isinstance(parent, ast.Call)
+        and bool(parent.args)
+        and parent.args[0] is node
+        and _is_builtin_namespace_call(parent, imports)
+    )
+
+
+def _mutated_builtin_names(node: ast.expr, member: str | None, imports: ImportIndex) -> set[str]:
+    if not isinstance(node, ast.Name):
+        return set()
+    binding = imports.bindings.get(node.id)
+    if binding is None or binding.module != "builtins" or binding.symbol is not None:
+        return set()
+    carriers = {"str", "int"} | _BUILTIN_COLLECTIONS
+    changed = carriers if member is None or member.startswith("__") else carriers & {member}
+    if not changed:
+        return set()
+    return changed | {
+        name
+        for name, imported in imports.bindings.items()
+        if imported.module == "builtins" and (imported.symbol is None or imported.symbol in changed)
+    }
+
+
 def _expression_is_shadowed(expression: ast.expr, names: frozenset[str]) -> bool:
     return bool(names) and any(isinstance(node, ast.Name) and node.id in names for node in walk_ast(expression))