gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/languages/python/interpret.js

@@ -17,10 +17,17 @@ export function interpretPythonImport(captures) {
     //   `@import.name`  : the imported symbol name (or module name for plain imports)
     //   `@import.alias` : the local alias name (for `as` forms)
     //   `@import.source`: the module path (always present except for `dynamic`)
+    //   `@import.publishes`: present iff the statement is at module level
     const kindCap = captures['@import.kind'];
     const nameCap = captures['@import.name'];
     const aliasCap = captures['@import.alias'];
     const sourceCap = captures['@import.source'];
+    // Python has no dedicated re-export form: a module-level `from m import x`
+    // binds `x` AND publishes it as `<this module>.x`. See `reexportsName` on
+    // `ParsedImport` for the contract, and `import-decomposer.ts` for why the
+    // marker — not this function — decides whether the statement is at module
+    // level.
+    const republishes = captures['@import.publishes'] !== undefined;
     const kind = kindCap?.text;
     if (kind === undefined)
         return null;
@@ -56,10 +63,14 @@ export function interpretPythonImport(captures) {
                 localName: nameCap.text,
                 importedName: nameCap.text,
                 targetRaw: sourceCap.text,
+                ...(republishes ? { reexportsName: true } : {}),
             };
         }
         case 'from-alias': {
-            // `from m import x as y`
+            // `from m import x as y` — republished under the alias (`<module>.y`).
+            // PEP 484 treats `import x as x` as an explicit re-export; Python's
+            // runtime namespace republishes every module-level form, so the flag
+            // follows module level rather than the redundant-alias case.
             if (sourceCap === undefined || nameCap === undefined || aliasCap === undefined)
                 return null;
             return {
@@ -68,6 +79,7 @@ export function interpretPythonImport(captures) {
                 importedName: nameCap.text,
                 alias: aliasCap.text,
                 targetRaw: sourceCap.text,
+                ...(republishes ? { reexportsName: true } : {}),
             };
         }
         case 'wildcard': {
@@ -118,12 +130,18 @@ export function interpretPythonTypeBinding(captures) {
     // `Registry.lookup` Step 2 treats them identically.
     else if (captures['@type-binding.cls'] !== undefined)
         source = 'self';
-    else if (captures['@type-binding.instance-field'] !== undefined) {
-        source =
-            captures['@type-binding.parameter'] !== undefined ? 'parameter-annotation' : 'annotation';
-    }
+    // Before the instance-field arm, not after it: `self.x = Outer()` (#2807)
+    // carries BOTH markers, and its type is inferred from the CONSTRUCTOR CALL —
+    // the weakest of the three tiers — so a class that also annotates the field
+    // keeps the annotation. Testing constructor first is what lets the
+    // instance-field arm below stay flat; the two orders agree on every input,
+    // since they differ only where both markers are present and both then say
+    // 'constructor-inferred'.
     else if (captures['@type-binding.constructor'] !== undefined)
         source = 'constructor-inferred';
+    else if (captures['@type-binding.instance-field'] !== undefined)
+        source =
+            captures['@type-binding.parameter'] !== undefined ? 'parameter-annotation' : 'annotation';
     else if (captures['@type-binding.annotation'] !== undefined)
         source = 'annotation';
     else if (captures['@type-binding.alias'] !== undefined)
@@ -139,6 +157,41 @@ function stripForwardRefQuotes(text) {
     }
     return text;
 }
+/**
+ * Container bases whose SINGLE type argument is the element type.
+ *
+ * The single source of truth for both the matcher below and the property test
+ * that asserts every one of them is also declined as a user generic — the two
+ * lists drifting apart is the defect this arrangement exists to make
+ * impossible. Order is significant only in that it is the regex alternation
+ * order; keep additions grouped with their family.
+ */
+export const SINGLE_ARG_CONTAINERS = [
+    'list',
+    'List',
+    'set',
+    'Set',
+    'tuple',
+    'Tuple',
+    'Iterable',
+    'Iterator',
+    'Sequence',
+    'Generator',
+    'AsyncIterable',
+    'AsyncIterator',
+];
+/** Container bases whose SECOND type argument is the value type. See {@link SINGLE_ARG_CONTAINERS}. */
+export const MAPPING_CONTAINERS = [
+    'dict',
+    'Dict',
+    'Mapping',
+    'MutableMapping',
+    'OrderedDict',
+    'DefaultDict',
+];
+const QUALIFIER = '(?:[A-Za-z_][A-Za-z0-9_]*\\.)?';
+const SINGLE_ARG_CONTAINER_RE = new RegExp(`^${QUALIFIER}(?:${SINGLE_ARG_CONTAINERS.join('|')})\\[([^,\\]]+)\\]$`);
+const MAPPING_CONTAINER_RE = new RegExp(`^${QUALIFIER}(?:${MAPPING_CONTAINERS.join('|')})\\[[^,\\]]+,\\s*([^\\]]+)\\]$`);
 /**
  * Unwrap a single-arg generic collection wrapper — `list[User]`,
  * `set[User]`, `Iterable[User]`, `Sequence[User]`, `Iterator[User]`,
@@ -151,7 +204,7 @@ function stripForwardRefQuotes(text) {
  * resolution time.
  */
 function stripGeneric(text) {
-    const single = text.match(/^(?:[A-Za-z_][A-Za-z0-9_]*\.)?(?:list|List|set|Set|tuple|Tuple|Iterable|Iterator|Sequence|Generator|AsyncIterable|AsyncIterator)\[([^,\]]+)\]$/);
+    const single = text.match(SINGLE_ARG_CONTAINER_RE);
     if (single !== null)
         return single[1].trim();
     // dict[K, V] / Dict[K, V] / Mapping[K, V] — strip to value type V.
@@ -161,11 +214,200 @@ function stripGeneric(text) {
     // only shape worth handling. Match a top-level K up to the first
     // comma and a V to the closing bracket; nested generics in V (e.g.
     // `dict[str, list[User]]`) are left for a downstream strip pass.
-    const dict = text.match(/^(?:[A-Za-z_][A-Za-z0-9_]*\.)?(?:dict|Dict|Mapping|MutableMapping|OrderedDict|DefaultDict)\[[^,\]]+,\s*([^\]]+)\]$/);
+    const dict = text.match(MAPPING_CONTAINER_RE);
     if (dict !== null)
         return dict[1].trim();
+    // A subscripted type the two allow-lists above did NOT claim is a
+    // user-defined GENERIC, not a container: `Repo[User]`, `Handler[Req, Res]`.
+    // Its base names one declaration — `Repo[User]` and `Repo[Order]` are the
+    // same `class Repo(Generic[T])` — so reduce to that base, exactly as Java's
+    // and Swift's interpreters already do for their `<…>` spelling (#2833).
+    //
+    // Guarded by a DENY set rather than reached by fallthrough, because "the two
+    // rules above did not match" is NOT the same as "not a container". Two
+    // measured counterexamples, both of which this branch got wrong before the
+    // guard existed:
+    //   - `dict[str, list[User]]` — the dict rule's value group cannot span a
+    //     nested `]`, so it declines and the shape falls through. Reducing it to
+    //     `dict` destroys the value type the dict rule explicitly leaves "for a
+    //     downstream strip pass"; the annotation must survive intact instead.
+    //   - `Callable[[int], User]`, `Literal["a"]`, `Annotated[int, F()]`,
+    //     `Union[A, B]`, `tuple[int, ...]` — typing SPECIAL FORMS, not classes.
+    //     Reducing them yields a bare `Callable`/`Literal`/`Union`, which binds
+    //     to a workspace class of that name if one exists — a fabricated edge,
+    //     and those names are ordinary enough for a real codebase to declare.
+    // Anything named here keeps its as-written text and resolves as it did
+    // before #2833.
+    //
+    // Only reached for genuine annotations: every Python `@type-binding.type`
+    // capture is a `(type)`, `(identifier)`, `(attribute)` or `(dotted_name)`
+    // node, so a subscripted VALUE expression (`arr[0]`) never arrives here.
+    //
+    // The as-written spelling is not lost — `scope-extractor` keeps it on
+    // `TypeRef.declaredSpelling` whenever it differs from the reduced name,
+    // which is what the receiver fold's index step reads.
+    const userGeneric = text.match(/^((?:[A-Za-z_][A-Za-z0-9_]*\.)*[A-Za-z_][A-Za-z0-9_]*)\[.+\]$/s);
+    if (userGeneric !== null) {
+        const qualified = userGeneric[1].trim();
+        const base = qualified.slice(qualified.lastIndexOf('.') + 1);
+        if (!isNotAUserGenericBase(base))
+            return qualified;
+    }
     return text;
 }
+/**
+ * Whether a subscripted annotation's base names a Python type-system construct
+ * rather than a workspace class — see {@link NOT_A_USER_GENERIC_SPELLINGS}.
+ *
+ * CASE-FOLDED, and that is the load-bearing part. PEP 585 gave nearly every
+ * container two spellings — the builtin/`collections` one and the `typing`
+ * alias (`deque` / `typing.Deque`, `frozenset` / `typing.FrozenSet`,
+ * `defaultdict` / `typing.DefaultDict`) — which differ ONLY in case. Matching
+ * exactly meant each pair had to be listed twice and any half-pair was a silent
+ * escape: `deque` was listed, `Deque` was not, so `self.dq: Deque[User]`
+ * reduced to `Deque` and bound to a workspace `class Deque` (#2855). Folding
+ * case closes that axis by construction instead of by vigilance.
+ *
+ * The cost is that a workspace class whose name is a case VARIANT of a stdlib
+ * construct (`class deque(Generic[T])`) stops reducing. PEP 8 makes such a
+ * class vanishingly rare, and the loss is a missing edge — recoverable — where
+ * the gain is not minting a confident wrong one.
+ */
+function isNotAUserGenericBase(base) {
+    return NOT_A_USER_GENERIC.has(base.toLowerCase());
+}
+/**
+ * Bases a subscripted annotation may carry that are NOT user-defined generics.
+ *
+ * SCOPE — the standard library, and deliberately nothing else. The names below
+ * are the documented Python type-system surface (`typing`'s deprecated PEP 585
+ * aliases and its special forms, plus the stdlib classes those aliases point
+ * at); that universe is CLOSED and versioned by CPython, so the list is
+ * auditable against
+ * <https://docs.python.org/3/library/typing.html#deprecated-aliases>.
+ *
+ * Third-party generics (`Mapped[int]`, `QuerySet[User]`) are NOT listed. That
+ * universe is open, so enumerating it only ever chases the last escape, and
+ * denying an ordinary name like `Model` would cost real edges in the many
+ * projects that legitimately declare one. Those spellings still reduce to their
+ * base, and the base is now admitted only on the grounds `resolveErasedBaseName`
+ * applies at resolution time — the file's scope chain binds it, the declaration
+ * is in this very file, the index proves the name is a template family, or the
+ * file has no cross-file class channel to be absent from. A `Mapped[User]` whose
+ * base the file cannot see therefore binds nothing, which is the structural
+ * answer this parse-time pass cannot give and no longer has to.
+ *
+ * Two distinct reasons to decline, both always-correct at this layer:
+ *   - CONTAINERS, including ones the two rules above do not own. Reducing
+ *     `deque[User]` to `deque` types a receiver as the container and retargets
+ *     every call in a for-loop chain, and reducing `dict[str, list[User]]` to
+ *     `dict` destroys the value type the dict rule leaves for a downstream pass.
+ *   - `typing` SPECIAL FORMS, which are not classes at all. `Callable`,
+ *     `Literal`, `Union` reduce to a bare name that binds to a workspace class
+ *     of that name if one exists — a fabricated edge.
+ *
+ * Members are listed ONCE per case-insensitive concept: {@link
+ * isNotAUserGenericBase} folds case, so the builtin spelling covers its PEP 585
+ * `typing` twin (`deque` covers `Deque`, `frozenset` covers `FrozenSet`).
+ * Non-generic ABCs (`Hashable`, `Sized`) are omitted — they cannot be written
+ * subscripted, so they never reach this branch.
+ *
+ * Exported for the property test that asserts the case-fold closure holds
+ * behaviourally; nothing else should read it.
+ */
+export const NOT_A_USER_GENERIC_SPELLINGS = [
+    // ── builtins subscriptable since PEP 585 ──────────────────────────────────
+    'list',
+    'set',
+    'frozenset',
+    'tuple',
+    'dict',
+    'type',
+    // ── `collections` ─────────────────────────────────────────────────────────
+    'defaultdict',
+    'OrderedDict',
+    'ChainMap',
+    'Counter',
+    'deque',
+    // ── `collections.abc`, the subscriptable members ──────────────────────────
+    'Mapping',
+    'MutableMapping',
+    'Sequence',
+    'MutableSequence',
+    'AbstractSet',
+    'MutableSet',
+    'Collection',
+    'Container',
+    'Reversible',
+    'Iterable',
+    'Iterator',
+    'Generator',
+    'AsyncIterable',
+    'AsyncIterator',
+    'AsyncGenerator',
+    'Awaitable',
+    'Coroutine',
+    'KeysView',
+    'ValuesView',
+    'ItemsView',
+    'MappingView',
+    // ── `contextlib`, and the `typing` aliases to it ──────────────────────────
+    'ContextManager',
+    'AsyncContextManager',
+    'AbstractContextManager',
+    'AbstractAsyncContextManager',
+    // ── `re`, and the `typing` aliases to it ──────────────────────────────────
+    // `Pattern` and `Match` ARE classes, so reducing them is not wrong the way
+    // reducing `Callable` is; they are declined because in Python annotations
+    // these spellings are overwhelmingly the `re` types, while a workspace class
+    // of the same name is a parser's own `Pattern`/`Match` and would be bound
+    // with no import evidence whatsoever. Same policy as the receiver-chain
+    // resolver's: a missing edge is recoverable, a confident wrong one is not.
+    'Pattern',
+    'Match',
+    // ── I/O streams (`typing.IO` and its two subclasses) ──────────────────────
+    'IO',
+    'TextIO',
+    'BinaryIO',
+    // ── stdlib generic classes with ordinary names ────────────────────────────
+    // Same policy call as `Pattern`/`Match` above, and the sharpest instance of
+    // it: `asyncio.Task[Result]` reduces to `asyncio.Task`, whose dotted-tail
+    // fallback then single-matches an unrelated workspace `class Task`.
+    'Queue',
+    'Task',
+    'Future',
+    'PathLike',
+    // ── `typing` special forms — not classes ──────────────────────────────────
+    'Callable',
+    'Literal',
+    'Annotated',
+    'Union',
+    'Optional',
+    'Final',
+    'ClassVar',
+    // `typing.Type` is the PEP 585 alias for the builtin `type` listed above, and
+    // the case fold already covers it — see the one-entry-per-concept rule.
+    'TypeGuard',
+    'TypeIs',
+    'Unpack',
+    'Required',
+    'NotRequired',
+    'ReadOnly',
+    'Concatenate',
+    'LiteralString',
+    // ── generic machinery: bases and type-parameter declarations ──────────────
+    // `Generic[T]`/`Protocol[T]` are written subscripted for real. The three
+    // declaration forms are not subscriptable in valid Python, but this
+    // interpreter checks no grammar — it reduces whatever text the annotation
+    // capture carried — so they are declined defensively.
+    'Generic',
+    'Protocol',
+    'TypeVar',
+    'ParamSpec',
+    'TypeVarTuple',
+];
+/** Case-folded lookup index over {@link NOT_A_USER_GENERIC_SPELLINGS}. */
+const NOT_A_USER_GENERIC = new Set(NOT_A_USER_GENERIC_SPELLINGS.map((name) => name.toLowerCase()));
 /**
  * Unwrap nullable type annotations so downstream resolution treats
  * `User | None`, `None | User`, and `Optional[User]` identically to

package/dist/core/ingestion/languages/python/query.js

@@ -20,6 +20,15 @@ const PYTHON_SCOPE_QUERY = `
 (function_definition
   name: (identifier) @declaration.name) @declaration.function
 
+;; Lambda bindings (\`f = lambda x: x\`). The \`@declaration.function\` anchor
+;; sits on the INNER lambda so its range aligns with \`(lambda) @scope.function\`
+;; above; otherwise the def is owned by the module scope and calls inside the
+;; lambda lose caller attribution. Mirrors the TypeScript arrow patterns (#2687).
+(expression_statement
+  (assignment
+    left: (identifier) @declaration.name
+    right: (lambda) @declaration.function))
+
 (assignment
   left: (identifier) @declaration.name) @declaration.variable
 

package/dist/core/ingestion/languages/python/receiver-binding.d.ts

@@ -21,14 +21,16 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
 export declare function synthesizeReceiverTypeBinding(fnNode: SyntaxNode): CaptureMatch | null;
 /**
  * Synthesize class-scope field bindings for the common Python constructor
- * injection pattern:
+ * injection patterns:
  *
  *   def __init__(self, service: Service):
- *       self.service = service
+ *       self.service = service        # from the PARAMETER's annotation
+ *       self.cache: Cache = build()   # from the FIELD's own annotation
+ *       self.outer = Outer()          # from the CONSTRUCTOR called (#2807)
  *
- * An explicit field annotation (`self.service: Service = ...`) is also
- * accepted and takes precedence over a parameter annotation. Deliberately do
- * not infer from arbitrary unannotated RHS expressions: the receiver resolver
- * needs a declared type, not a name-only guess.
+ * The three tiers rank in that order — an explicit field annotation beats a
+ * parameter annotation, which beats a construction. Anything else is still
+ * refused: the receiver resolver needs positive evidence, not a name-only
+ * guess from an arbitrary RHS.
  */
 export declare function synthesizeConstructorFieldTypeBindings(fnNode: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/python/receiver-binding.js

@@ -114,17 +114,79 @@ export function synthesizeReceiverTypeBinding(fnNode) {
         '@type-binding.type': syntheticCapture('@type-binding.type', first, className),
     };
 }
+/**
+ * The class name of a direct constructor call — `Outer()` — or `undefined` for
+ * anything else. Python has no `new`, so a call is the only syntactic
+ * construction form, and a call to a plain name is the shape every other
+ * language spells `= new X()`.
+ *
+ * BARE NAMES ONLY. A dotted callee (`models.User()`, `f.Alpha()`) is refused.
+ * The first cut of #2807 returned the callee's full dotted text, on the theory
+ * that a dotted name resolves through `QualifiedNameIndex` the way the
+ * module-level `u = models.User()` capture in `query.ts` does. Measured on a
+ * fixture carrying both shapes, that arm produced no correct edge and did
+ * produce wrong ones:
+ *
+ *   - `self.svc = f.Alpha()`, where `Alpha` is a METHOD on an unrelated object
+ *     and `Alpha` is also a class elsewhere: the dotted lookup matches the
+ *     TRAILING segment against a same-named class, so `self.svc.ping()` emitted
+ *     a FABRICATED edge to `Alpha.ping`. The root does not have to be a
+ *     parameter — a module-level `shared_factory.Alpha()` fabricates the same
+ *     way — so no test on the root's binding form contains this.
+ *   - `self.u = models.User()`, the shape the arm was written FOR, emitted no
+ *     edge with the arm or without it. An instance field's binding lands in
+ *     CLASS scope, which never reaches the namespace split that makes the
+ *     module-level local form resolve.
+ *
+ * Accepted cost, stated plainly: `self.u = models.User()` still does not type
+ * its field. It did not before this narrowing either, so nothing that worked is
+ * given up — and declining to bind is the doctrine `compound-receiver.ts`
+ * states, that a confidently WRONG owner is strictly worse than a missing edge.
+ * Re-enabling dotted callees is a RESOLUTION-side change (teach the field path
+ * the namespace split that #2826/#2828 is reworking); redoing it here could
+ * only re-open the trailing-segment fabrication.
+ *
+ * This is also why the tier tie-break below can stay last-write-wins: the
+ * displacement it used to suffer — `self.conn = Outer()` then
+ * `self.conn = Registry.get()`, where the second, dotted, non-type candidate
+ * overwrote the real constructor binding at the shared weakest tier and left
+ * the field untyped — cannot arise once a dotted callee yields no candidate at
+ * all. The weakest tier now ranks only REAL constructions against each other,
+ * where the last write in `__init__` genuinely is the live one.
+ */
+function constructorCallTypeName(right, receiverName) {
+    if (right === null || right.type !== 'call')
+        return undefined;
+    const callee = right.childForFieldName('function');
+    if (callee === null)
+        return undefined;
+    // An `attribute` callee is the dotted path refused above; `self.p =
+    // self.build()` is one instance of it, and a method call is not a
+    // construction.
+    if (callee.type !== 'identifier')
+        return undefined;
+    const text = callee.text.trim();
+    if (text.length === 0)
+        return undefined;
+    // `self.p = self()` invokes the instance's own `__call__`. It is a call to a
+    // bare name, but that name is the receiver, not a type.
+    if (text === receiverName)
+        return undefined;
+    return text;
+}
 /**
  * Synthesize class-scope field bindings for the common Python constructor
- * injection pattern:
+ * injection patterns:
  *
  *   def __init__(self, service: Service):
- *       self.service = service
+ *       self.service = service        # from the PARAMETER's annotation
+ *       self.cache: Cache = build()   # from the FIELD's own annotation
+ *       self.outer = Outer()          # from the CONSTRUCTOR called (#2807)
  *
- * An explicit field annotation (`self.service: Service = ...`) is also
- * accepted and takes precedence over a parameter annotation. Deliberately do
- * not infer from arbitrary unannotated RHS expressions: the receiver resolver
- * needs a declared type, not a name-only guess.
+ * The three tiers rank in that order — an explicit field annotation beats a
+ * parameter annotation, which beats a construction. Anything else is still
+ * refused: the receiver resolver needs positive evidence, not a name-only
+ * guess from an arbitrary RHS.
  */
 export function synthesizeConstructorFieldTypeBindings(fnNode) {
     if (fnNode.childForFieldName('name')?.text !== '__init__')
@@ -151,6 +213,17 @@ export function synthesizeConstructorFieldTypeBindings(fnNode) {
         if (name !== null && annotation !== null)
             parameterTypes.set(name, annotation.text);
     }
+    // Three evidence tiers for one field, strongest first. A later assignment of
+    // the SAME tier still wins (last write in `__init__` is the live one), but a
+    // weaker one never displaces a stronger: `self.x: Outer = make()` keeps its
+    // annotation even if a later branch does `self.x = Other()`.
+    //
+    // Same-tier last-write-wins is only sound because `constructorCallTypeName`
+    // admits nothing but real constructions into the weakest tier — see the note
+    // there on the `self.conn = Registry.get()` displacement it used to allow.
+    const TIER_EXPLICIT = 2;
+    const TIER_PARAMETER = 1;
+    const TIER_CONSTRUCTOR = 0;
     const candidates = new Map();
     const stack = [body];
     while (stack.length > 0) {
@@ -175,21 +248,44 @@ export function synthesizeConstructorFieldTypeBindings(fnNode) {
                 if (object?.type === 'identifier' && object.text === receiverName && field !== null) {
                     const explicitType = node.childForFieldName('type');
                     const parameterType = right?.type === 'identifier' ? parameterTypes.get(right.text) : undefined;
-                    const typeName = explicitType?.text ?? parameterType;
+                    // `self.x = Outer()` — the type comes from the CONSTRUCTOR being
+                    // called (#2807). This is not the "arbitrary unannotated RHS" the
+                    // header warns against: a call to a name that resolves to a class is
+                    // the same positive evidence every other language reads from
+                    // `= new X()`, and without it an unannotated instance field could
+                    // never act as a call receiver at all. Weakest of the three tiers, so
+                    // an explicit annotation or a parameter annotation still wins.
+                    const constructedType = explicitType === null && parameterType === undefined
+                        ? constructorCallTypeName(right, receiverName)
+                        : undefined;
+                    const typeName = explicitType?.text ?? parameterType ?? constructedType;
                     if (typeName !== undefined) {
                         const explicit = explicitType !== null;
+                        const inferredFromConstructor = constructedType !== undefined;
+                        const tier = explicit
+                            ? TIER_EXPLICIT
+                            : inferredFromConstructor
+                                ? TIER_CONSTRUCTOR
+                                : TIER_PARAMETER;
                         const existing = candidates.get(field.text);
-                        if (existing === undefined || explicit || !existing.explicit) {
+                        if (existing === undefined || tier >= existing.tier) {
                             candidates.set(field.text, {
-                                explicit,
+                                tier,
                                 match: {
                                     '@type-binding.name': syntheticCapture('@type-binding.name', field, field.text),
                                     '@type-binding.type': syntheticCapture('@type-binding.type', explicitType ?? right ?? field, typeName),
+                                    // The marker that tells `interpretPythonTypeBinding` which
+                                    // tier this is; an explicit annotation carries neither and
+                                    // reads as `annotation`.
                                     ...(explicit
                                         ? {}
-                                        : {
-                                            '@type-binding.parameter': syntheticCapture('@type-binding.parameter', right ?? field, '1'),
-                                        }),
+                                        : inferredFromConstructor
+                                            ? {
+                                                '@type-binding.constructor': syntheticCapture('@type-binding.constructor', right ?? field, '1'),
+                                            }
+                                            : {
+                                                '@type-binding.parameter': syntheticCapture('@type-binding.parameter', right ?? field, '1'),
+                                            }),
                                     '@type-binding.instance-field': syntheticCapture('@type-binding.instance-field', node, '1'),
                                 },
                             });

package/dist/core/ingestion/languages/python/scope-resolver.js

@@ -14,24 +14,37 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { indexOnlyElementType } from '../../type-extractors/shared.js';
 import { pythonProvider } from '../python.js';
-import { pythonArityCompatibility, pythonMergeBindings, resolvePythonImportTarget, } from './index.js';
+import { isPythonImportedModule, pythonNamespaceReceiverPaths, pythonArityCompatibility, pythonMergeBindings, resolvePythonImportTarget, } from './index.js';
 const pythonScopeResolver = {
+    // A free call naming a class constructs it: `Service(db).do_work()` (#2708).
+    constructionSyntax: { bare: true },
     language: SupportedLanguages.Python,
     languageProvider: pythonProvider,
     importEdgeReason: 'python-scope: import',
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, _resolutionConfig, context) => {
         // Pass the orchestrator's stable run-level `ReadonlySet` straight through
         // (no per-import copy). The Python resolver chain only reads the set, and
         // `getPythonFileIndex` memoizes its index on the set's identity via a
         // WeakMap — so the index is built once per run and reused across every
         // import. Copying here (the previous `new Set(allFilePaths)`) handed a
         // fresh identity to every import, defeating that cache (PR #1918 review P1).
-        const ws = { fromFile, allFilePaths };
+        const ws = {
+            fromFile,
+            allFilePaths,
+            parsedFiles: context?.parsedFiles,
+        };
         // `WorkspaceIndex` is an opaque `unknown` placeholder in the
         // shared contract, so `ws` passes structurally without a cast.
-        return resolvePythonImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
+        return resolvePythonImportTarget(context?.parsedImport ?? { kind: 'namespace', localName: '_', importedName: '_', targetRaw }, ws);
     },
+    isNamespaceImport: (parsedImport, targetFile, fromFile) => isPythonImportedModule(parsedImport, targetFile, fromFile),
+    // `import a.b.c` binds only `a`, yet makes `a`, `a.b` and `a.b.c` all
+    // callable — each naming a different file. Without this the absolute-import
+    // style is invisible to the call graph, and the root key points at the leaf
+    // module instead of the package (#2826).
+    namespaceReceiverPaths: pythonNamespaceReceiverPaths,
     // Python LEGB precedence: local > import/namespace/reexport > wildcard.
     // The per-scope id is unused by pythonMergeBindings (tier ordering
     // is computed purely from BindingRef.origin), so we don't need to
@@ -45,6 +58,16 @@ const pythonScopeResolver = {
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
     isSuperReceiver: (text) => /^super\s*\(/.test(text),
+    // Subscript route only — Python spells collection views as method calls
+    // (`.values()`), which the compound resolver's call branch already handles.
+    //
+    // The hook receives the annotation AS WRITTEN (`List[User]`, `Dict[str, User]`),
+    // not the name `interpret.ts`'s `stripGeneric` reduced it to, so `undefined`
+    // here means "this spelling is not a container" — which is what stops
+    // `cfg['k'].run()` on a `__getitem__`-bearing class from folding onto the
+    // class itself. Answering the route at all is what keeps `repos[0].save()`
+    // resolving.
+    elementTypeOf: indexOnlyElementType,
     // Python is dynamically typed — field-fallback heuristic on, return-
     // type propagation across imports on. Both default to true; listed
     // explicitly here for documentation.

package/dist/core/ingestion/languages/python/simple-hooks.js

@@ -6,6 +6,7 @@
  * analysis.
  */
 import { findAncestorBeforeBoundary, FUNCTION_NODE_TYPES } from '../../utils/ast-helpers.js';
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 const PYTHON_METHOD_CONTAINER_TYPES = new Set(['class_definition']);
 export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
     if (defaultLabel !== 'Function')
@@ -21,14 +22,7 @@ export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
  *  field type on the enclosing Class scope. */
 export function pythonBindingScopeFor(decl, innermost, tree) {
     if (decl['@type-binding.instance-field'] !== undefined) {
-        let current = innermost;
-        while (current !== undefined) {
-            if (current.kind === 'Class')
-                return current.id;
-            if (current.parent === null)
-                break;
-            current = tree.getScope(current.parent);
-        }
+        return walkToScope(innermost, tree, 'Class');
     }
     return null;
 }

package/dist/core/ingestion/languages/python.js

@@ -28,6 +28,7 @@ import { createPythonCfgVisitor } from '../cfg/visitors/python.js';
 import { emitPythonScopeCaptures, pythonFunctionDefinitionLabel, interpretPythonImport, interpretPythonTypeBinding, pythonArityCompatibility, pythonBindingScopeFor, pythonImportOwningScope, pythonMergeBindings, pythonReceiverBinding, resolvePythonImportTarget, } from './python/index.js';
 import { extractDjangoRoutes } from '../route-extractors/django.js';
 import { discoverDjangoRootUrls } from '../route-extractors/django-root-discovery.js';
+import { extractPythonModuleConstants } from '../route-extractors/python-const-resolver.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -134,4 +135,16 @@ export const pythonProvider = defineLanguage({
     receiverBinding: pythonReceiverBinding,
     arityCompatibility: pythonArityCompatibility,
     resolveImportTarget: resolvePythonImportTarget,
+    // ── #2391 constant harvest, provider-hook form (#2980): module-level string
+    // constants + from-imports for non-literal decorator route paths. Bare-name
+    // refs fold through the shared resolver (no foldRoutePathOperands needed).
+    // No `moduleConstantHeuristic`: Python harvests unconditionally, exactly as
+    // #2391 shipped it. A content gate was tried here and removed on review — it
+    // required `NAME` immediately followed by `=`, so it silently dropped the two
+    // idiomatic typed-FastAPI shapes (`API: str = "/api"`,
+    // `API: Final[str] = "/api"`) and every composed constant whose RHS starts
+    // with an identifier (`USERS = BASE + "/users"`), i.e. it REGRESSED routes
+    // that already resolve on main. The worker treats a missing heuristic as
+    // default-open; only Java opts into a gate, where the cost actually bites.
+    extractModuleConstants: extractPythonModuleConstants,
 });