Python: an import in a module-scope if binds at module scope

[knutwannheden]

A call to a removed API gets no declaring type when the import binding it sits inside a module-scope if — the shape a codebase mid-migration actually writes:

if sys.version_info < (3, 11):
    from gettext import lgettext

Measured on gettext.lgettext, which 3.14's typeshed does not declare. Position is not the problem: ty resolves a live symbol from every one of these.

	live symbol	removed symbol
module scope	owner ✓	owner ✓
star import	owner ✓	owner ✓
aliased	owner ✓	owner ✓
if-guarded	owner ✓	owner ✗
function-local	owner ✓	owner ✗
try/except	owner ✓	owner ✗

The mechanism

A symbol ty cannot type is attributed from the file's own import bindings instead. _import_bindings indexed tree.body only, so a nested alias never entered the index; _rebound_names then added every alias outside that index to the shadowed set, so the name was actively excluded rather than merely absent. That exclusion is deliberate — a name bound twice cannot be read off an import — and right for a function-local or else-guarded import.

The fix

_module_scope_statements walks a module body plus the bodies of ifs with no else or elif: those bind into the enclosing scope, and nothing else binds them. Only that shape widens.

• The LST layer already encodes the same rule as import_utils.unconditional_body (Python: imports in an if TYPE_CHECKING: block are module scope #8739), which RemoveImport and PythonRemoveImportVisitor read. Attribution runs during parse, before any LST or Cursor exists, so the rule is now stated in two layers — over ast here, over J.If there. That is the parser-layer boundary Python: a call names the member its import binds #8758 ran into; the new helper's docstring points at its LST twin so the next person changing either finds the other.

The two other failing rows keep failing, and need no new predicate. A try's handler can bind the name to a shim (gone = None), a genuine second binding _rebound_names already excludes on its own merits. A function-local import is scoped, and a module-level reference is not that binding.

Tests

• The new rows go in TestSymbolTheStubsDoNotDeclare, which calls a symbol its fixture module does not define. A fixture using a symbol the typeshed still declares passes whether or not the binding path was reached — the confound behind the wrong conclusions on Python: let a project's declared version pick the typeshed #8759.

test_an_import_under_an_unconditional_if_binds_at_module_scope covers one guard and nested guards; ..._with_an_else_branch_... and ..._in_a_try_... pin the declines. Each mutation-checked against the line it claims: dropping the orelse guard fails the else test, widening the helper to ast.Try fails the try test, and dropping its recursion fails the nested row.

Downstream

In moderneinc/rewrite-migrate-python this is necessary but not sufficient. Run against the same guarded fixture per recipe, on this branch:

• FindSslMatchHostname and FindLocaleGetdefaultlocale act on it. The first gates on _is_ssl_method(...) before member_called(...); the second is a bare MethodMatcher.create("locale getdefaultlocale(..)"). Both read the declaring type directly.
• gettext lgettext, locale resetlocale and platform popen still decline. They reach the receiver-less form only through FromImports.member_called, whose index is built from cu.statements — top-level only, exactly as this one was.

That helper's docstring gives the limit try/except's reasoning, applied to the unconditional if too: the same conflation, one layer down. It widens separately, after this merges.

Full downstream suite on this branch: 668 passed, no test changed outcome in either direction.