[colbymchenry]

Summary

In Python, a call of your own class's method named like a builtin dict, list, string or file method — get, update, items, pop, close and the rest of the builtin-method list — now links to that method when the function says what the receiver holds:

reg = SystemPackRegistry()
reg.get("y")                      # -> SystemPackRegistry::get

registry = load_registry()        # def load_registry() -> SystemPackRegistry
registry.get("x")                 # -> SystemPackRegistry::get

def annotated(reg: SystemPackRegistry):
    reg.items()                   # -> SystemPackRegistry::items

All three calls from the issue link now. The shapes from the reporter's follow-up comment, where a looser receiver typing made wrong edges, still link nothing.

Root cause

isBuiltInOrExternal (src/resolution/index.ts) drops a dotted Python call whose method is in PYTHON_BUILT_IN_METHODS before any strategy runs. It keeps the call only when the capitalized receiver name is a project class (systemPackRegistry → SystemPackRegistry) or the receiver is an imported project module (#1681). A typed local or parameter with any other name never reached matchMethodCall. self.reg.get() already linked, because the attribute reader from #1926 runs on the attribute chain.

Fix

A call the filter drops gets one way back, by evidence only. matchPythonTypedLocalCall (src/resolution/name-matcher.ts) reads the def that binds the receiver where the call reads it: the calling def, or one it is nested in. It types the name only when every binding there gives it the same project class:

• a parameter gives what its annotation names ("T", Optional[T], T | None);
• an assignment gives its own annotation, or what its whole value makes: a constructor, or a factory typed by its -> T or by its returns. These are the attribute reader's pythonValueEvidence and pythonFactoryType, so Foo().data() is no evidence of Foo;
• x = None says nothing either way;
• each class is the one the file's imports name (pythonClassNamed). from queue import Queue names no project class, even when the project has a Queue, and from b import Handler is b's Handler, not a's;
• the method must be the class's own or a declared base's, with bases resolved the same way. A method that only a base from outside the project could provide links nothing.

Everything else leaves the receiver unknown and the call dropped, as before:

• any other binding of the name: a for, with, except or comprehension target, a tuple or augmented assignment, a walrus, an import, del, a nested def or class of the name, or a nonlocal write from a nested def;
• a value that names no class, such as {}, json.load(p), Foo().data() or a union;
• a callee the scope rebinds (Store = load(); reg = Store());
• a module-level name.

These are exactly the shapes in the reporter's 2026-10-15 comment. The edge records the other files its answer was read from (typeFrom), as an attribute call's does, so a sync that edits the factory or a base re-opens it.

Only calls the filter used to drop can change, and only Python ones.

Validation

Tests. New __tests__/python-typed-builtin-method-calls.test.ts, 20 tests:

• the issue's three calls; annotated, quoted and Optional parameters; items/pop/close; a module-qualified constructor; typed, untyped and awaited factories; a None placeholder; a local annotation; a closure; typeFrom; two same-named classes; an inherited method;
• the reporter's trap shapes, which must stay unlinked: outside Queue/Session/Counter/StringIO, rebinding to {} and json.load, branches, loops, with, comprehensions, Foo().data()/Foo().build(), a union, an unannotated parameter, a rebound class name, a rebound global, module-level code, and an outside base;
• three sync cases, each checked against a fresh index: the factory changes its return, the factory gains its annotation, and the class gains and then loses the method.

Against main's source the 13 positive tests fail and the 7 trap tests pass; with the fix all 20 pass. The 29 Python-related suite files (572 tests) pass.

A/B against main 3f58e343. Both arms were built from their own sources, kernel included, indexed fresh with the default engine, dumped with scripts/dump-graph.mjs and diffed by edge site. After the rebase onto e32021f6 (#2820, Java/Kotlin/C#/Scala only), the fix arm's dumps are byte-identical to before the rebase.

repo	commit	Python files	edges added	removed	other changes	triage
psf/requests	611c6162	37	15	0	0	15/15 right
sqlalchemy/sqlalchemy	69e49c9c	677	52	0	0	52/52 right
django/django, its .py files only	8e4e95da	2,937	73	0	0	73/73 right
expressjs/express (control)	0dee2c52	0	byte-identical
gin-gonic/gin (control)	0f09c3a9	0	byte-identical

I read the source behind every added edge. Each one is a constructed local, a factory-typed local or an annotated parameter calling its own class's method, or one a declared base has. Examples:

• requests: jar = requests.cookies.RequestsCookieJar(); jar.get(…);
• sqlalchemy: record: ConnectionPoolEntry → record.close(), and sess = object_session(…) → Session.flush (through -> Optional[Session]);
• django: clause = WhereNode(…); clause.add(…) → tree.Node.add (inherited), and stream = LimitedStream(…); stream.readline().

Django was indexed as a copy of its Python files, under the sweep's RAM rule for big repos; its other files take no part in Python resolution.

The issue's fixtures link all three calls on both engines. The verification kit's nine trap call sites stay unresolved on both, identical to main.

Cost. Index CPU, median of 3 interleaved runs, main vs fix: sqlalchemy 98.6 s vs 98.5 s, django 97.9 s vs 99.1 s. Single runs vary by several seconds on this shared machine, so I also took a CPU profile: it puts the new reader at about 1.0 s on django and 1.2 s on sqlalchemy, around 1% of index CPU.

Kernel parity. scripts/kernel-parity.mjs --lang python over requests and sqlalchemy/lib: 295/295 files at parity. The change is resolution-only.

Full suite on the pushed commit 0008dc90 (CODEGRAPH_KERNEL_EXPECT=1, kernel built): 738 files (732 passed, 6 skipped), 8,852 tests: 8,770 passed, 0 failed, 82 skipped. No reruns were needed.

Fixes #2583

Related

• The reporter's follow-up comment on the issue lists the false positives of their attempted fix; those shapes are this PR's negative tests.
• PR fix(python): keep builtin-named members of absolutely imported project modules #2632 (open, @BGamboa13) changes the same filter for a different case: builtin-named functions of an absolutely imported project module. It doesn't overlap in behaviour, but the two may conflict textually around isBuiltInOrExternal.

Left out

• A class re-exported through a package __init__.py, like from django.template import Context (defined in django/template/context.py). The class lookup is the attribute reader's pythonClassNamed, which doesn't follow re-exports, so self.ctx.update() misses the same class today. Fixing it for both readers together is a separate change.
• A local annotated with a generic, like reg: Optional[Registry] = None, is not read yet. The same annotation on a parameter is.
• A module-level instance (_svc = Registry() at module scope, then _svc.get()) stays dropped for builtin names; Python: _svc.delete() on a module-level instance gets no edge unless the method name is unique #2582 types those for other method names. Reusing its reader here added 6 correct sqlalchemy edges but about 2 s per index, because it re-reads whole class bodies on every call, so I left it out.
• pytest fixture parameters stay dropped for builtin names, as before.
• Sync in a large project. When the class gains the method, or the factory gains its annotation, in a project with more than 500 failed calls of that method name (get in Django), sync doesn't retry the call, and it links at the next full index. That is the existing per-name retry ceiling. In smaller projects the sync cases above converge.

🤖 Generated with Claude Code