gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -15,7 +15,7 @@
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
-import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { splitImportStatement } from './import-decomposer.js';
 import { getPythonParser, getPythonScopeQuery } from './query.js';
 import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
@@ -26,9 +26,10 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { pythonFunctionDefinitionLabel } from './simple-hooks.js';
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
-    // Skip the parse when the caller (parse phase's ASTCache) already
-    // produced a Tree for this source. Cache miss = re-parse, same as
-    // before. The cachedTree parameter is typed as `unknown` at the
+    // Skip the parse when the caller (the scope-resolution orchestrator's
+    // `treeCache`) already produced a Tree for this source — empty under
+    // worker-pool runs, so cache miss = re-parse. The cachedTree parameter
+    // is typed as `unknown` at the
     // contract layer (see `LanguageProvider.emitScopeCaptures`); cast
     // here at the use site.
     let tree = cachedTree;
@@ -59,20 +60,30 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
         // `@`; we put it back so the central extractor's prefix lookups
         // (`@scope.`, `@declaration.`, …) work.
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // hands us each matched node as `c.node`, so anchor nodes can be used
+        // directly (or via a bounded LOCAL walk) instead of re-deriving them with
+        // `findNodeAtRange(tree.rootNode, ...)`, which scanned all of root's named
+        // children on every match -> O(matches x rootChildren). That was the #1848
+        // hotpath in Go (fixed in eaf0a305); the same shape lived here in Python.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
         if (grouped['@import.statement'] !== undefined) {
-            // Decompose multi-name imports. Both `import_statement` and
-            // `import_from_statement` share the matched range, so we try the
-            // `from` form first and fall back to plain.
-            const stmtCapture = grouped['@import.statement'];
-            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'import_from_statement') ??
-                findNodeAtRange(tree.rootNode, stmtCapture.range, 'import_statement');
-            if (stmtNode !== null) {
+            // `@import.statement` is captured directly ON the `import_statement` /
+            // `import_from_statement` node (query: `(import_statement) @import.statement`
+            // and `(import_from_statement) @import.statement`), so the captured node IS
+            // the one the old findNodeAtRange re-derived. `splitImportStatement`
+            // dispatches on those two types; a captured node of any other type would
+            // have made the old range+type lookup return null -> the defensive raw
+            // fallback, which the type guard below reproduces exactly.
+            const stmtNode = nodeMap['@import.statement'];
+            if (stmtNode.type === 'import_from_statement' || stmtNode.type === 'import_statement') {
                 for (const piece of splitImportStatement(stmtNode))
                     out.push(piece);
             }
@@ -84,7 +95,11 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
-            const fnNode = findNodeAtRange(tree.rootNode, grouped['@scope.function'].range, 'function_definition');
+            // `@scope.function` is captured directly on the `function_definition`
+            // node (query: `(function_definition) @scope.function`), so it IS the
+            // node the old findNodeAtRange re-derived at that range.
+            const scopeNode = nodeMap['@scope.function'];
+            const fnNode = scopeNode.type === 'function_definition' ? scopeNode : null;
             if (fnNode !== null) {
                 const synth = synthesizeReceiverTypeBinding(fnNode);
                 if (synth !== null)
@@ -100,7 +115,11 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
             // The anchor range is the function_definition itself — we resolve
             // the node and pipe it through the arity helper.
             const anchorCap = grouped['@declaration.function'];
-            const fnNode = findNodeAtRange(tree.rootNode, anchorCap.range, 'function_definition');
+            // `@declaration.function` is captured directly on the `function_definition`
+            // node (query: `(function_definition name: (identifier) @declaration.name)
+            // @declaration.function`), so use the captured node, not a root re-walk.
+            const anchorNode = nodeMap['@declaration.function'];
+            const fnNode = anchorNode.type === 'function_definition' ? anchorNode : null;
             if (fnNode !== null) {
                 if (pythonFunctionDefinitionLabel(fnNode, 'Function') === 'Method') {
                     delete grouped['@declaration.function'];
@@ -125,8 +144,104 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    out.push(...synthesizePythonInheritanceReferences(tree.rootNode));
     return out;
 }
+/**
+ * Synthesize `@reference.inherits` captures from Python class superclass
+ * lists so the registry-primary scope-resolution path emits EXTENDS edges
+ * (mirrors C#'s `synthesizeCsharpInheritanceReferences` / C++'s
+ * `emitCppInheritanceCaptures` / TypeScript's `synthesizeTsInheritanceReferences`).
+ * Without this, Python inheritance edges came only from the legacy
+ * heritage-capture leg (removed in #942), which is dropped for registry-primary
+ * languages in the worker pipeline (issue #1951).
+ *
+ * Scope matches the legacy Python heritage leg (config-driven since #1940):
+ * every direct base in the `superclasses` `argument_list`, resolved to its bare
+ * simple name. Three base shapes that the previous synth DROPPED — and so
+ * silently omitted in production while the legacy heritage leg captured them
+ * — are now handled (#1951):
+ *
+ *   - `class C(pkg.Base)`     → `attribute`  (trailing `.attribute` id → `Base`)
+ *   - `class C(pkg.sub.Base)` → nested `attribute` (recurse → `Base`)
+ *   - `class C(Generic[T])`   → `subscript`  (`.value` id → `Generic`)
+ *
+ * The bare-name text MUST agree with `normalizeSupertypeName` (the legacy leg's
+ * reduction in heritage-extractors/supertype-alternation.ts) so both legs emit
+ * the same edge under the CI scope-parity gate: `pkg.Base` → `Base`,
+ * `Generic[T]` → `Generic`, `pkg.Container[str]` → `Container`. Verified by a
+ * real tree-sitter-python parse. The simple `identifier` base keeps its exact
+ * prior capture (the base node itself).
+ *
+ * Tuple/multi bases (`class C(A, pkg.B, Gen[T])`) already iterate here — each
+ * `argument_list` named child is one base. Python has no interfaces, so every
+ * base resolves to a Class and the central `preEmitInheritanceEdges` pass emits
+ * EXTENDS; the EXTENDS-vs-IMPLEMENTS split is decided downstream from the
+ * resolved target's symbol kind, so all bases are emitted with the same
+ * `inherits` kind here.
+ */
+function synthesizePythonInheritanceReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type !== 'class_definition')
+            return;
+        const superclasses = node.childForFieldName('superclasses');
+        if (superclasses === null || superclasses.type !== 'argument_list')
+            return;
+        for (let i = 0; i < superclasses.namedChildCount; i++) {
+            const base = superclasses.namedChild(i);
+            if (base === null)
+                continue;
+            const nameNode = pythonBaseLookupNameNode(base);
+            if (nameNode === null)
+                continue;
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', base),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    });
+    return out;
+}
+/**
+ * Reduce a Python superclass base node to the bare simple-identifier node whose
+ * `.text` is the lookup name `findClassBindingInScope` resolves. Mirrors the
+ * TypeScript `terminalTsTypeNameNode` / C++ `extractBaseLookupName` reference
+ * patterns, and its returned node's `.text` is contractually equal to
+ * `normalizeSupertypeName(base)` for every shape (real-parse verified):
+ *
+ *   - `identifier`  (`Base`)            → the node itself
+ *   - `attribute`   (`pkg.Base`,
+ *                    `pkg.sub.Base`)    → trailing `attribute:` identifier → `Base`
+ *   - `subscript`   (`Generic[T]`,
+ *                    `pkg.Container[T]`)→ `value:` (recurse, strips `[...]` and
+ *                                          any qualifier) → `Generic` / `Container`
+ *
+ * Returns null for any other shape (no leaf identifier reachable), so it never
+ * emits a spurious edge.
+ */
+function pythonBaseLookupNameNode(base) {
+    switch (base.type) {
+        case 'identifier':
+            return base;
+        case 'attribute': {
+            // `pkg.Base` / `pkg.sub.Base`: the `attribute:` field is the trailing
+            // simple-identifier segment (`Base`); recurse so chained dotted paths
+            // still resolve to the final identifier.
+            const attr = base.childForFieldName('attribute');
+            return attr === null ? null : pythonBaseLookupNameNode(attr);
+        }
+        case 'subscript': {
+            // `Generic[T]` / `pkg.Container[str]`: the `value:` field is the
+            // subscripted base (identifier or attribute); recurse to strip the
+            // `[...]` slice and any qualifier, reaching the bare base name.
+            const value = base.childForFieldName('value');
+            return value === null ? null : pythonBaseLookupNameNode(value);
+        }
+        default:
+            return null;
+    }
+}
 function scopeExtractionError(stage, filePath, err) {
     const reason = err instanceof Error ? err.message : String(err);
     return new Error(`[python] tree-sitter ${stage} failed for ${filePath}: ${reason}; skipping scope extraction for this file`);

package/dist/core/ingestion/languages/python/depends-references.js

@@ -27,7 +27,7 @@ export function synthesizeDependsReferences(fnNode) {
         if (param.type !== 'typed_default_parameter' && param.type !== 'default_parameter') {
             continue;
         }
-        const defaultValue = param.childForFieldName('value') ?? param.childForFieldName('default');
+        const defaultValue = param.childForFieldName('value');
         if (defaultValue === null)
             continue;
         const callNode = defaultValue.type === 'call' ? defaultValue : null;

package/dist/core/ingestion/languages/python/import-target.d.ts

@@ -12,10 +12,9 @@
 import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
 export interface PythonResolveContext {
     readonly fromFile: string;
-    /** Mutable `Set` because the legacy `resolvePythonImportInternal`
-     *  chain downstream is typed to accept `Set<string>`. Callers that
-     *  only hold a `ReadonlySet` should copy via `new Set(...)` at the
-     *  adapter boundary. */
-    readonly allFilePaths: Set<string>;
+    /** `ReadonlySet` so the orchestrator's stable run-level set flows straight
+     *  through to `getPythonFileIndex`'s `WeakMap` key (built once per run, not
+     *  copied per import). The whole resolver chain only reads the set. */
+    readonly allFilePaths: ReadonlySet<string>;
 }
 export declare function resolvePythonImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;

package/dist/core/ingestion/languages/python/import-target.js

@@ -10,15 +10,23 @@
  * `linkStatus: 'unresolved'`.
  */
 import { resolvePythonImportInternal } from '../../import-resolvers/python.js';
+import { recordPythonFileIndexBuild } from './index-stats.js';
 export function resolvePythonImportTarget(parsedImport, workspaceIndex) {
     // WorkspaceIndex is `unknown` in the shared contract (Ring 1
     // placeholder). The scope-resolution orchestrator hands us a
     // PythonResolveContext-shaped object; narrow structurally rather
     // than via a cast chain so unexpected shapes return null cleanly.
     const ctx = workspaceIndex;
+    // Duck-type the set rather than `instanceof Set`: `allFilePaths` is typed
+    // `ReadonlySet<string>` and the chain only ever calls `.has()` + iterates, so
+    // any set-like is valid. An `instanceof Set` check would reject a legitimate
+    // non-`Set` `ReadonlySet` implementation and silently return null for every
+    // import (PR #1918 tri-review P2).
+    const allFilePaths = ctx?.allFilePaths;
     if (ctx === undefined ||
         typeof ctx.fromFile !== 'string' ||
-        !(ctx.allFilePaths instanceof Set)) {
+        typeof allFilePaths?.has !== 'function' ||
+        typeof allFilePaths?.[Symbol.iterator] !== 'function') {
         return null;
     }
     if (parsedImport.kind === 'dynamic-unresolved')
@@ -120,12 +128,29 @@ function resolveAbsoluteFromFiles(pathLike, allFilePaths, fromFile) {
     // multi-directory collision repos.
     const suffixFile = `/${directFile}`;
     const suffixPkg = `/${directPkg}`;
+    // Indexed suffix gather. A file matching `…/<pathLike>.py` has basename
+    // `<lastSeg>.py`; one matching `…/<pathLike>/__init__.py` has basename
+    // `__init__.py`. Look up only those basename buckets and confirm the full
+    // suffix, instead of scanning every file (the O(imports x files) hotpath).
+    // The candidate SET is identical to the old full scan, and the tie-break
+    // sort below fully determines the result, so output is unchanged. The
+    // shared buildSuffixIndex is deliberately NOT used: it keeps only one
+    // path per suffix (longest wins) and so cannot reproduce this exact
+    // fewest-segments-then-lexicographic tie-break across all candidates.
+    const index = getPythonFileIndex(allFilePaths);
+    const lastSeg = pathLike.slice(pathLike.lastIndexOf('/') + 1);
     const matches = [];
-    for (const raw of allFilePaths) {
-        const norm = raw.replace(/\\/g, '/');
-        if (norm.endsWith(suffixFile) || norm.endsWith(suffixPkg)) {
-            matches.push({ raw, norm });
-        }
+    for (const cand of index.byBasename.get(`${lastSeg}.py`) ?? []) {
+        if (cand.norm.endsWith(suffixFile))
+            matches.push(cand);
+    }
+    // Package form: only `__init__.py` files whose parent dir is named `<lastSeg>`
+    // can match `…/<lastSeg>/__init__.py` — look them up by parent key (P2b) and
+    // confirm the full suffix. Same final candidate set as the old `__init__.py`
+    // scan, just without iterating unrelated packages.
+    for (const cand of index.byInitParent.get(`${lastSeg}/__init__.py`) ?? []) {
+        if (cand.norm.endsWith(suffixPkg))
+            matches.push(cand);
     }
     if (matches.length === 0)
         return null;
@@ -178,18 +203,85 @@ function hasRepoCandidate(leadingSegment, allFilePaths, fromFile) {
     for (let i = dirParts.length; i > 0; i--) {
         ancestorPrefixes.push(`${dirParts.slice(0, i).join('/')}/${leadingSegment}/`);
     }
-    for (const raw of allFilePaths) {
-        const f = raw.replace(/\\/g, '/');
-        if (f === rootFile || f === initFile)
-            return true;
-        if (f.startsWith(prefix) && f.endsWith('.py'))
+    // Indexed equivalents of the old O(files) scan:
+    //  (1) `f === rootFile || f === initFile`  -> normalized-path membership.
+    //  (2) `f.startsWith(`${seg}/`) && f.endsWith('.py')` -> some .py file lives
+    //      under directory `${seg}/`, i.e. `${seg}/` is a known .py dir prefix.
+    //  (3) ancestor namespace case -> `${ancestor}/${seg}/` is a known .py dir
+    //      prefix.
+    const index = getPythonFileIndex(allFilePaths);
+    if (index.normSet.has(rootFile) || index.normSet.has(initFile))
+        return true;
+    if (index.dirPrefixes.has(prefix))
+        return true;
+    for (const ap of ancestorPrefixes) {
+        if (index.dirPrefixes.has(ap))
             return true;
-        if (f.endsWith('.py')) {
-            for (const ap of ancestorPrefixes) {
-                if (f.startsWith(ap))
-                    return true;
+    }
+    return false;
+}
+const PYTHON_FILE_INDEX_CACHE = new WeakMap();
+function getPythonFileIndex(allFilePaths) {
+    const cached = PYTHON_FILE_INDEX_CACHE.get(allFilePaths);
+    if (cached !== undefined)
+        return cached;
+    // Cache miss: materialize a fresh index. Counted so a test can assert this
+    // happens once per run, not once per import (PR #1918 review P1 guard).
+    recordPythonFileIndexBuild();
+    const normSet = new Set();
+    const byBasename = new Map();
+    const byInitParent = new Map();
+    const dirPrefixes = new Set();
+    for (const raw of allFilePaths) {
+        const norm = raw.replace(/\\/g, '/');
+        // Python import resolution only ever queries `.py` paths: module `<seg>.py`
+        // and package `<seg>/__init__.py` membership (normSet), `<lastSeg>.py` /
+        // `__init__.py` basename buckets (byBasename), and `.py` directory prefixes
+        // (dirPrefixes). Non-`.py` files can never match any of those, so skip them
+        // — they were dead weight in every structure on polyglot monorepos
+        // (PR #1918 review P3b; dirPrefixes was already `.py`-gated).
+        if (!norm.endsWith('.py'))
+            continue;
+        normSet.add(norm);
+        const lastSlash = norm.lastIndexOf('/');
+        const base = lastSlash >= 0 ? norm.slice(lastSlash + 1) : norm;
+        let bucket = byBasename.get(base);
+        if (bucket === undefined) {
+            bucket = [];
+            byBasename.set(base, bucket);
+        }
+        bucket.push({ raw, norm });
+        // Package files also get a parent-keyed bucket so a `pkg.sub` lookup hits
+        // only `…/sub/__init__.py` candidates, not every `__init__.py` (P2b).
+        if (base === '__init__.py' && lastSlash >= 0) {
+            const dir = norm.slice(0, lastSlash);
+            const parentSlash = dir.lastIndexOf('/');
+            const parentName = parentSlash >= 0 ? dir.slice(parentSlash + 1) : dir;
+            if (parentName) {
+                const initKey = `${parentName}/__init__.py`;
+                let ib = byInitParent.get(initKey);
+                if (ib === undefined) {
+                    ib = [];
+                    byInitParent.set(initKey, ib);
+                }
+                ib.push({ raw, norm });
             }
         }
+        // Directory prefixes: every slash-terminated prefix of the path (every
+        // index just past a '/', up to and including the file's own directory).
+        // Scanning the FULL normalized path — including any leading '/' for
+        // absolute paths — makes `dirPrefixes.has(X)` match exactly when the old
+        // gate's `f.startsWith(X)` (X always ends in '/') matched. The previous
+        // split+`filter(Boolean)` dropped the leading empty component, so an
+        // absolute file `/repo/svc/x.py` yielded `repo/svc/` (no leading slash) and
+        // gate-passed where `"/repo/svc/x.py".startsWith("repo/svc/")` is false
+        // (PR #1918 review P3a). For relative paths the set is identical.
+        for (let i = 0; i <= lastSlash; i++) {
+            if (norm[i] === '/')
+                dirPrefixes.add(norm.slice(0, i + 1));
+        }
     }
-    return false;
+    const index = { normSet, byBasename, byInitParent, dirPrefixes };
+    PYTHON_FILE_INDEX_CACHE.set(allFilePaths, index);
+    return index;
 }

package/dist/core/ingestion/languages/python/index-stats.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Build counter for the per-file-set Python import-resolution index
+ * (`getPythonFileIndex` in `import-target.ts`).
+ *
+ * A "build" is a `WeakMap` cache MISS that materializes a fresh
+ * `PythonFileIndex` (O(files)). Unlike `cache-stats.ts` (which gates its
+ * counters behind `PROF_SCOPE_RESOLUTION` because they sit on the per-capture
+ * hot path), this counter is always live: an index build happens at most once
+ * per resolution run, so the single increment is negligible and an unconditional
+ * counter avoids env-var load-order fragility in tests.
+ *
+ * Used by `test/integration/python-import-index-reuse.test.ts` to assert the
+ * index is reused across imports (built once per run) rather than rebuilt per
+ * import — the regression guard for PR #1918 review finding P1.
+ */
+export declare function recordPythonFileIndexBuild(): void;
+export declare function getPythonFileIndexBuildCount(): number;
+export declare function resetPythonFileIndexBuildCount(): void;

package/dist/core/ingestion/languages/python/index-stats.js

@@ -0,0 +1,25 @@
+/**
+ * Build counter for the per-file-set Python import-resolution index
+ * (`getPythonFileIndex` in `import-target.ts`).
+ *
+ * A "build" is a `WeakMap` cache MISS that materializes a fresh
+ * `PythonFileIndex` (O(files)). Unlike `cache-stats.ts` (which gates its
+ * counters behind `PROF_SCOPE_RESOLUTION` because they sit on the per-capture
+ * hot path), this counter is always live: an index build happens at most once
+ * per resolution run, so the single increment is negligible and an unconditional
+ * counter avoids env-var load-order fragility in tests.
+ *
+ * Used by `test/integration/python-import-index-reuse.test.ts` to assert the
+ * index is reused across imports (built once per run) rather than rebuilt per
+ * import — the regression guard for PR #1918 review finding P1.
+ */
+let INDEX_BUILDS = 0;
+export function recordPythonFileIndexBuild() {
+    INDEX_BUILDS++;
+}
+export function getPythonFileIndexBuildCount() {
+    return INDEX_BUILDS;
+}
+export function resetPythonFileIndexBuildCount() {
+    INDEX_BUILDS = 0;
+}

package/dist/core/ingestion/languages/python/index.d.ts

@@ -66,10 +66,9 @@
  *      site where the enclosing class can't be statically determined
  *      is left unresolved.
  *
- * Shadow-harness corpus parity is the authoritative signal for which
- * of these matter in practice. The CI parity gate blocks any PR that
- * regresses either the legacy or registry-primary run of
- * `test/integration/resolvers/python.test.ts`.
+ * The `test/integration/resolvers/python.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitPythonScopeCaptures } from './captures.js';
 export { getPythonCaptureCacheStats, resetPythonCaptureCacheStats } from './cache-stats.js';

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

@@ -66,10 +66,9 @@
  *      site where the enclosing class can't be statically determined
  *      is left unresolved.
  *
- * Shadow-harness corpus parity is the authoritative signal for which
- * of these matter in practice. The CI parity gate blocks any PR that
- * regresses either the legacy or registry-primary run of
- * `test/integration/resolvers/python.test.ts`.
+ * The `test/integration/resolvers/python.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitPythonScopeCaptures } from './captures.js';
 export { getPythonCaptureCacheStats, resetPythonCaptureCacheStats } from './cache-stats.js';

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

@@ -11,6 +11,7 @@ const PYTHON_SCOPE_QUERY = `
 (module) @scope.module
 (class_definition) @scope.class
 (function_definition) @scope.function
+(lambda) @scope.function
 
 ;; Declarations
 (class_definition
@@ -232,6 +233,22 @@ const PYTHON_SCOPE_QUERY = `
   name: (identifier) @type-binding.name
   return_type: (type) @type-binding.type) @type-binding.return
 
+;; Decorators — simple @decorator
+(decorator
+  (identifier) @reference.name) @reference.call.free
+
+;; Decorators — @obj.decorator (single attribute, identifier receiver)
+(decorator
+  (attribute
+    object: (identifier) @reference.receiver
+    attribute: (identifier) @reference.name)) @reference.call.member
+
+;; Decorators — @a.b.decorator (nested attributes)
+(decorator
+  (attribute
+    object: (attribute) @reference.receiver
+    attribute: (identifier) @reference.name)) @reference.call.member
+
 ;; References — calls
 (call
   function: (identifier) @reference.name) @reference.call.free

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

@@ -21,12 +21,13 @@ const pythonScopeResolver = {
     languageProvider: pythonProvider,
     importEdgeReason: 'python-scope: import',
     resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        // Copy the orchestrator's `ReadonlySet` into a `Set` because the
-        // legacy Python resolver chain (`resolvePythonImportInternal` →
-        // `resolveAbsoluteFromFiles` / `hasRepoCandidate`) is typed to
-        // receive a mutable `Set<string>`. The copy is O(N) but called
-        // once per import — trivial compared to the parser work.
-        const ws = { fromFile, allFilePaths: new Set(allFilePaths) };
+        // 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 };
         // `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);

package/dist/core/ingestion/languages/python.d.ts

@@ -5,8 +5,6 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Python traits:
- *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
  *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
- *   - namedBindingExtractor: present (from X import Y)
  */
 export declare const pythonProvider: import("../language-provider.js").LanguageProvider;

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

@@ -5,9 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Python traits:
- *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
  *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
- *   - namedBindingExtractor: present (from X import Y)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
@@ -17,7 +15,6 @@ import { typeConfig as pythonConfig } from '../type-extractors/python.js';
 import { pythonExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { pythonImportConfig } from '../import-resolvers/configs/python.js';
-import { extractPythonNamedBindings } from '../named-bindings/python.js';
 import { PYTHON_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { pythonConfig as pythonFieldConfig } from '../field-extractors/configs/python.js';
@@ -27,7 +24,6 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { pythonVariableConfig } from '../variable-extractors/configs/python.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { pythonCallConfig } from '../call-extractors/configs/python.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { emitPythonScopeCaptures, pythonFunctionDefinitionLabel, interpretPythonImport, interpretPythonTypeBinding, pythonArityCompatibility, pythonBindingScopeFor, pythonImportOwningScope, pythonMergeBindings, pythonReceiverBinding, resolvePythonImportTarget, } from './python/index.js';
 const BUILT_INS = new Set([
     'print',
@@ -105,15 +101,12 @@ export const pythonProvider = defineLanguage({
     typeConfig: pythonConfig,
     exportChecker: pythonExportChecker,
     importResolver: createImportResolver(pythonImportConfig),
-    namedBindingExtractor: extractPythonNamedBindings,
-    importSemantics: 'namespace',
     mroStrategy: 'c3',
     callExtractor: createCallExtractor(pythonCallConfig),
     fieldExtractor: createFieldExtractor(pythonFieldConfig),
     methodExtractor: createMethodExtractor(pythonMethodConfig),
     variableExtractor: createVariableExtractor(pythonVariableConfig),
     classExtractor: createClassExtractor(pythonClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Python),
     descriptionExtractor: pythonDescriptionExtractor,
     builtInNames: BUILT_INS,
     labelOverride: pythonFunctionDefinitionLabel,