ucn 5.5.0 → 5.5.2

package/core/project.js

@@ -19,7 +19,8 @@ const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits, PA
 const { validateFileIR } = require('./ir');
 const { createFileEntryFromIR, populateFileEntryFromIR } = require('./index-ir');
 const { getTokenTypeAtPosition } = require('../languages/utils');
-const { escapeRegExp, NON_CALLABLE_TYPES, codeUnitCompare, literalNameRegex } = require('./shared');
+const { escapeRegExp, isCallableMember, codeUnitCompare, literalNameRegex, calleeNames } = require('./shared');
+const { containsCall } = require('./callable-scope');
 const stacktrace = require('./stacktrace');
 const indexCache = require('./cache');
 // Loaded on first use (fix #375): most commands never reach dead-code
@@ -35,6 +36,11 @@ const graphModule = require('./graph');
 const graphBuildModule = require('./graph-build');
 const reportingModule = require('./reporting');
 
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazyClassIdentityModuleCache = null;
+const lazyClassIdentityModule = () => lazyClassIdentityModuleCache || (lazyClassIdentityModuleCache = require('./class-identity'));
+
 // Lazy-initialized per-language keyword sets (populated on first isKeyword call)
 let LANGUAGE_KEYWORDS = null;
 
@@ -42,10 +48,16 @@ let LANGUAGE_KEYWORDS = null;
 // small cross-operation LRU so a sequence of agent queries does not reparse the
 // same large headers/modules for every conservation-account classification.
 // The source-byte budget is deliberately conservative because tree-sitter's
-// native tree is larger than its source. Evictions explicitly release native
-// memory instead of waiting for N-API finalizers.
-const PARSED_TREE_CACHE_MAX_ENTRIES = 128;
-const PARSED_TREE_CACHE_MAX_SOURCE_BYTES = 32 * 1024 * 1024;
+// native tree is larger than its source (~40x). Evictions explicitly release
+// native memory instead of waiting for N-API finalizers. The bound is the
+// source bytes (fix #436): a 128-tree cap evicted in scan order whenever one
+// query read more files than that (clap `Command`: 164), so every later read
+// of the same files re-parsed them, and freed trees left the heap larger.
+const PARSED_TREE_CACHE_MAX_ENTRIES = 2048;
+const PARSED_TREE_CACHE_MAX_SOURCE_BYTES = 8 * 1024 * 1024;
+// The most recent tree alone stays up to the former budget, so one large
+// file (an amalgamation) is still read once across operations.
+const PARSED_TREE_CACHE_MAX_SINGLE_SOURCE_BYTES = 32 * 1024 * 1024;
 // Automatic build parallelism (fix #375): source bytes to (re)parse before a
 // build uses workers, and per worker. A worker's fixed cost (thread start
 // and its own JIT warm-up of the parsers) is about the CPU of parsing 300KB
@@ -59,6 +71,32 @@ const symbolsByNameAndLine = new WeakMap();
 /**
  * ProjectIndex - Manages symbol table for a project
  */
+// The callables of a file spanning each line, in symbol order, for a file
+// whose enclosing-function lookups miss often within one operation (fix
+// #435: a C# type query looked every record of a file up against every
+// symbol of the file). Fewer lookups scan the symbols as before.
+const ENCLOSING_LINE_INDEX = new WeakMap(); // per-operation line cache -> { misses, lines }
+const ENCLOSING_INDEX_AFTER = 16;
+function enclosingCandidates(byLine, fileEntry, lineNum) {
+    let state = ENCLOSING_LINE_INDEX.get(byLine);
+    if (!state) ENCLOSING_LINE_INDEX.set(byLine, state = { misses: 0, lines: null, symbols: null });
+    if (!state.lines || state.symbols !== fileEntry.symbols) {
+        if (++state.misses <= ENCLOSING_INDEX_AFTER) return fileEntry.symbols;
+        const lines = new Map();
+        for (const symbol of fileEntry.symbols) {
+            if (!isCallableMember(symbol) || !Number.isInteger(symbol.startLine) || !Number.isInteger(symbol.endLine)) continue;
+            for (let line = symbol.startLine; line <= symbol.endLine; line++) {
+                let list = lines.get(line);
+                if (!list) lines.set(line, list = []);
+                list.push(symbol);
+            }
+        }
+        state.lines = lines;
+        state.symbols = fileEntry.symbols;
+    }
+    return state.lines.get(lineNum) || [];
+}
+
 class ProjectIndex {
     /**
      * Create a new ProjectIndex
@@ -80,6 +118,7 @@ class ProjectIndex {
         this.lastBuildWorkerCount = 1;
         this.lastBuildParallelEligible = false;
         this.lastBuildRequestedWorkers = null;
+        this.lastBuildWorkerLimit = null;
         // Parse workers the last build kept for Rust macro expansion (0: the
         // expansion ran in place or had nothing to expand).
         this.lastBuildExpansionWorkers = 0;
@@ -101,7 +140,8 @@ class ProjectIndex {
         this._opCppTypeCategoryCache = null; // per-operation normalized C++ parameter categories
         this._opDerefPairs = null;      // per-operation Rust Deref identity pairs
         this._opAliasPairs = null;      // per-operation language type-alias identity pairs
-        this._parsedTreeCache = new Map(); // cross-operation LRU: filePath -> immutable tree entry
+        this._parsedTreeCache = new Map(); // cross-operation LRU: `${language}\0${filePath}` -> immutable tree entry
+        this._parsedTreeKeys = new Map(); // filePath -> its keys in _parsedTreeCache
         this._parsedTreeCacheSourceBytes = 0;
         // Cross-operation, content-hash-keyed usage classifications. Account
         // queries often ask several projections for the same hot symbol; the
@@ -130,6 +170,8 @@ class ProjectIndex {
         this._rustMacroState = null;     // Rust macro_rules! expansion state (core/rust-macro-expansion.js)
         this._cppScope = null;           // C++ qualified-name memo (core/cpp-scope.js)
         this._contractIndex = null;      // contract-membership index memo (core/contract-membership.js)
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
         this._typeDenotation = null;     // type-name denotation memo (core/type-denotation.js), reset with _classIdentity
         this._languageFeatureMemo = null; // fix #380 protocol-type feature memo
         this._rustScopeMemo = null; // fix #368: Rust glob/bound resolution memo, index-lifetime
@@ -137,6 +179,19 @@ class ProjectIndex {
         this.calleeIndex = null;         // name -> Set<filePath> — inverted call index (built lazily)
     }
 
+    /**
+     * The language a file is parsed in: the indexed language when the file is
+     * indexed (a `.h` header's grammar is decided at build time from the
+     * compilation database and the project's translation units), else the
+     * detection the build would make. A relative path is project-relative,
+     * never relative to the process directory (fix #436).
+     */
+    languageOf(filePath) {
+        if (!filePath) return null;
+        const absolute = path.isAbsolute(filePath) ? filePath : path.join(this.root, filePath);
+        return this.files.get(absolute)?.language || detectLanguage(absolute, this.root);
+    }
+
     /**
      * Read file content with per-operation caching.
      * When an operation cache is active (_opContentCache is set), reads are
@@ -248,37 +303,60 @@ class ProjectIndex {
         }
     }
 
-    /** Remove one persistent parsed tree, deferring disposal if an operation still uses it. */
-    _evictParsedTree(filePath) {
-        const entry = this._parsedTreeCache.get(filePath);
-        if (!entry) return;
-        this._parsedTreeCache.delete(filePath);
-        this._parsedTreeCacheSourceBytes -= entry.sourceBytes;
-        if (this._opTreeCache?.get(filePath) === entry.tree) {
-            this._opTransientTrees?.add(entry.tree);
-        } else {
-            entry.tree?.delete?.();
+    /**
+     * Remove a file's persistent parsed trees (every grammar it was read in,
+     * or only `language`'s), deferring disposal if an operation still uses one.
+     */
+    _evictParsedTree(filePath, language = null) {
+        const keys = this._parsedTreeKeys.get(filePath);
+        if (!keys) return;
+        for (const key of [...keys]) {
+            const entry = this._parsedTreeCache.get(key);
+            if (!entry || (language !== null && entry.language !== language)) continue;
+            this._parsedTreeCache.delete(key);
+            keys.delete(key);
+            this._parsedTreeCacheSourceBytes -= entry.sourceBytes;
+            if (this._opTreeCache?.get(filePath) === entry.tree) {
+                this._opTransientTrees?.add(entry.tree);
+            } else {
+                entry.tree?.delete?.();
+            }
         }
+        if (keys.size === 0) this._parsedTreeKeys.delete(filePath);
+    }
+
+    /** The persistent tree of a file in one grammar, or undefined. */
+    _persistentParsedTree(filePath, language) {
+        return this._parsedTreeCache.get(`${language}\0${filePath}`);
     }
 
     /** Dispose every cross-operation tree. Used when an index is replaced from cache. */
     _clearParsedTreeCache() {
-        for (const filePath of [...this._parsedTreeCache.keys()]) {
+        for (const filePath of [...this._parsedTreeKeys.keys()]) {
             this._evictParsedTree(filePath);
         }
         this._parsedTreeCacheSourceBytes = 0;
     }
 
+    // Keyed by grammar and path: a file read in two grammars (a header a
+    // reader detects as C, the index as C++) keeps both trees instead of
+    // evicting one for the other on every alternating read (fix #435).
     _cacheParsedTree(filePath, language, tree, sourceBytes) {
         const fileHash = this.files.get(filePath)?.hash || null;
-        this._evictParsedTree(filePath);
-        this._parsedTreeCache.set(filePath, {
-            tree, language, fileHash, sourceBytes,
+        this._evictParsedTree(filePath, language);
+        const key = `${language}\0${filePath}`;
+        this._parsedTreeCache.set(key, {
+            tree, language, fileHash, sourceBytes, filePath,
         });
+        if (!this._parsedTreeKeys.has(filePath)) this._parsedTreeKeys.set(filePath, new Set());
+        this._parsedTreeKeys.get(filePath).add(key);
         this._parsedTreeCacheSourceBytes += sourceBytes;
         while (this._parsedTreeCache.size > PARSED_TREE_CACHE_MAX_ENTRIES ||
-            this._parsedTreeCacheSourceBytes > PARSED_TREE_CACHE_MAX_SOURCE_BYTES) {
-            this._evictParsedTree(this._parsedTreeCache.keys().next().value);
+            (this._parsedTreeCacheSourceBytes > PARSED_TREE_CACHE_MAX_SOURCE_BYTES &&
+                !(this._parsedTreeCache.size === 1 &&
+                    this._parsedTreeCacheSourceBytes <= PARSED_TREE_CACHE_MAX_SINGLE_SOURCE_BYTES))) {
+            const oldest = this._parsedTreeCache.values().next().value;
+            this._evictParsedTree(oldest.filePath, oldest.language);
         }
     }
 
@@ -291,29 +369,36 @@ class ProjectIndex {
      * Returns null when parsing fails or no operation cache is active — callers
      * fall back to parsing themselves.
      */
+    _peekParsedTree(filePath, language) {
+        const cached = this._persistentParsedTree(filePath, language);
+        return cached && cached.fileHash === (this.files.get(filePath)?.hash || null)
+            ? cached.tree : null;
+    }
+
     _getParsedTree(filePath, content, language) {
         if (!this._opTreeCache) return null;
         const cached = this._opTreeCache.get(filePath);
         if (cached !== undefined) return cached;
 
-        const persistent = this._parsedTreeCache.get(filePath);
+        const persistent = this._persistentParsedTree(filePath, language);
         const currentHash = this.files.get(filePath)?.hash || null;
-        if (persistent && persistent.language === language &&
-            persistent.fileHash === currentHash) {
+        if (persistent && persistent.fileHash === currentHash) {
             // LRU touch.
-            this._parsedTreeCache.delete(filePath);
-            this._parsedTreeCache.set(filePath, persistent);
+            const key = `${language}\0${filePath}`;
+            this._parsedTreeCache.delete(key);
+            this._parsedTreeCache.set(key, persistent);
             this._opTreeCache.set(filePath, persistent.tree);
             return persistent.tree;
         }
-        if (persistent) this._evictParsedTree(filePath);
+        if (persistent) this._evictParsedTree(filePath, language);
 
         let tree;
         try {
             const parser = getParser(language);
             // A language may read files through its own view of the source
             // (C# conditional compilation, fix #391); queries read the same.
-            const queryTree = parser && getLanguageAdapter(language)?.queryTree;
+            const queryTree = parser && !langTraits(language)?.plainQueryTree &&
+                getLanguageAdapter(language)?.queryTree;
             tree = !parser ? null : queryTree
                 ? queryTree(content, parser, this.files.get(filePath))
                 : safeParse(parser, content, undefined, PARSE_OPTIONS);
@@ -330,6 +415,35 @@ class ProjectIndex {
         return tree;
     }
 
+    /**
+     * The plain parse of a file whose query view is another tree (C#
+     * conditional compilation), kept in the persistent tree cache under its
+     * own grammar key (fix #436). Null outside an operation, as
+     * _getParsedTree.
+     */
+    _plainParsedTree(filePath, content, language) {
+        if (!this._opTreeCache) return null;
+        const key = `${language}:plain`;
+        const persistent = this._persistentParsedTree(filePath, key);
+        const currentHash = this.files.get(filePath)?.hash || null;
+        if (persistent && persistent.fileHash === currentHash) {
+            const cacheKey = `${key}\0${filePath}`;
+            this._parsedTreeCache.delete(cacheKey);
+            this._parsedTreeCache.set(cacheKey, persistent);
+            return persistent.tree;
+        }
+        if (persistent) this._evictParsedTree(filePath, key);
+        let tree;
+        try {
+            const parser = getParser(language);
+            tree = parser ? safeParse(parser, content) : null;
+        } catch (e) {
+            tree = null;
+        }
+        if (tree) this._cacheParsedTree(filePath, key, tree, Buffer.byteLength(content));
+        return tree;
+    }
+
     /**
      * Split a file into lines once per operation. Callers must treat the
      * returned array as read-only — it is shared across the whole operation.
@@ -357,6 +471,8 @@ class ProjectIndex {
      * @param {object} [options]
      * @param {boolean} [options.skipCallRecovery] - omit usage-only call
      * recovery when the caller has already classified lines from the call index
+     * @param {boolean} [options.usageKindsOnly] - omit optional receiver facts
+     * when the consumer needs only occurrence positions and kinds
      * @returns {Array|null} Array of usage objects or null if parsing failed
      */
     _getCachedUsages(filePath, name, options = {}) {
@@ -365,9 +481,14 @@ class ProjectIndex {
         // C/C++ can therefore skip its expensive macro replacement-list call
         // recovery in that mode. Partition both cache layers so a partial
         // account classification can never poison the full `usages` result.
+        // An adapter may also omit receiver facts for kind-only consumers;
+        // lexical-scope requests always retain the complete usage records.
         const mode = [
-            options.skipCallRecovery ? 'skip-call-recovery' : '',
+            options.skipCallRecovery ? (langTraits(this.files.get(filePath)?.language)?.macroInvocationSyntax === 'call'
+                ? 'skip-call-recovery-v2' : 'skip-call-recovery') : '',
             options.lexicalScopes ? 'lexical-scopes' : '',
+            options.usageKindsOnly && !options.lexicalScopes &&
+                langTraits(this.files.get(filePath)?.language)?.usageKindsOnly ? 'usage-kinds-v1' : '',
         ].filter(Boolean).join('+');
         const modeSuffix = mode ? `\0${mode}` : '';
         const cacheKey = `${filePath}\0${name}${modeSuffix}`;
@@ -376,15 +497,10 @@ class ProjectIndex {
             if (cached !== undefined) return cached;
         }
 
-        const fileHash = this.files.get(filePath)?.hash || '';
-        const persistentKey = `${filePath}\0${fileHash}\0${name}${modeSuffix}`;
-        if (this._usageResultCache?.has(persistentKey)) {
-            const cached = this._usageResultCache.get(persistentKey);
-            // Map insertion order is the LRU order.
-            this._usageResultCache.delete(persistentKey);
-            this._usageResultCache.set(persistentKey, cached);
-            if (this._opUsagesCache) this._opUsagesCache.set(cacheKey, cached.value);
-            return cached.value;
+        const cached = indexCache.getUsageResult(this, filePath, name, mode);
+        if (cached !== undefined) {
+            if (this._opUsagesCache) this._opUsagesCache.set(cacheKey, cached);
+            return cached;
         }
 
         // Header language is resolved during indexing from compilation
@@ -421,19 +537,7 @@ class ProjectIndex {
                 this._opUsagesCache.set(cacheKey, usages);
             }
             if (Array.isArray(usages) && this._usageResultCache) {
-                const weight = 64 + usages.length * 40;
-                this._usageResultCache.set(persistentKey, { value: usages, weight });
-                this._usageResultCacheWeight += weight;
-                this.usageCacheDirty = true;
-                const maxEntries = 4096;
-                const maxWeight = 16 * 1024 * 1024;
-                while (this._usageResultCache.size > maxEntries ||
-                    this._usageResultCacheWeight > maxWeight) {
-                    const oldest = this._usageResultCache.entries().next().value;
-                    if (!oldest) break;
-                    this._usageResultCache.delete(oldest[0]);
-                    this._usageResultCacheWeight -= oldest[1].weight;
-                }
+                indexCache.storeUsageResult(this, filePath, name, mode, usages);
             }
             return usages;
         } catch (e) {
@@ -479,6 +583,8 @@ class ProjectIndex {
         this._rustMacroState = null; // Rust macro_rules! expansion state (core/rust-macro-expansion.js)
         this._cppScope = null; // C++ qualified-name memo (core/cpp-scope.js)
         this._contractIndex = null; // contract-membership memo (core/contract-membership.js)
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
         this._typeDenotation = null; // type-name denotation memo (core/type-denotation.js)
         this._languageFeatureMemo = null; // fix #380 protocol-type feature memo
         this._rustScopeMemo = null; // fix #368: Rust glob/bound resolution memo, index-lifetime
@@ -618,6 +724,8 @@ class ProjectIndex {
         }
 
         // Always invalidate caches on rebuild
+        this._callNameCache = null;
+        this._callsGenerationKey = null;
         this._completenessCache = null;
         this._attrTypeCache = null;
         this._computedDispatchBlindspots = null;
@@ -645,6 +753,9 @@ class ProjectIndex {
             ? workersSetting : (envWorkers > 0 ? envWorkers : null);
         this.lastBuildWorkerCount = 1;
         this.lastBuildRequestedWorkers = requestedWorkerCount;
+        // Threads later phases may start (fix #422): none when the build
+        // disabled workers, at most an explicit count, else their own choice.
+        this.lastBuildWorkerLimit = disableParallel ? 0 : requestedWorkerCount;
         let usedParallel = false;
 
         // C/C++ recovery performs materially heavier parser work per file
@@ -920,6 +1031,9 @@ class ProjectIndex {
         // These query caches depend on project symbols and include closure.
         // A changed file can alter either even before a full rebuild reaches
         // its graph phase, so no prior call-identity verdict may survive.
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
+        this._cppScope = null;
         this._cppVisibleFilesCache?.clear();
         this._textualIncludeClosureCache?.clear();
         this._translationUnitLanguageCache?.clear();
@@ -1019,6 +1133,9 @@ class ProjectIndex {
         const existing = this.files.get(filePath);
         if (!existing) return;
 
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
+        this._cppScope = null;
         this._evictParsedTree(filePath);
 
         for (const symbol of existing.symbols) {
@@ -1067,6 +1184,8 @@ class ProjectIndex {
         this._rustMacroState = null;
         this._cppScope = null;
         this._contractIndex = null;
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
         this._typeDenotation = null; // type-name denotation memo (core/type-denotation.js)
         this._languageFeatureMemo = null; // fix #380 protocol-type feature memo
         this._rustScopeMemo = null;
@@ -1129,6 +1248,8 @@ class ProjectIndex {
         this._rustMacroState = null;
         this._cppScope = null;
         this._contractIndex = null;
+        this._implicitConversionOwners = null;
+        this._constructionAliases = null;
         this._typeDenotation = null; // type-name denotation memo (core/type-denotation.js)
         this._languageFeatureMemo = null; // fix #380 protocol-type feature memo
         this._rustScopeMemo = null; // fix #368: Rust glob/bound resolution memo, index-lifetime
@@ -1182,39 +1303,10 @@ class ProjectIndex {
      */
     _addToCalleeIndex(filePath, calls) {
         if (!this.calleeIndex || !calls) return;
-        for (const call of calls) {
-            const name = call.name;
-            if (!this.calleeIndex.has(name)) {
-                this.calleeIndex.set(name, new Set());
-            }
-            this.calleeIndex.get(name).add(filePath);
-            if (call.resolvedName && call.resolvedName !== name) {
-                if (!this.calleeIndex.has(call.resolvedName)) {
-                    this.calleeIndex.set(call.resolvedName, new Set());
-                }
-                this.calleeIndex.get(call.resolvedName).add(filePath);
-            }
-            if (call.resolvedNames) {
-                for (const rn of call.resolvedNames) {
-                    if (rn !== name) {
-                        if (!this.calleeIndex.has(rn)) {
-                            this.calleeIndex.set(rn, new Set());
-                        }
-                        this.calleeIndex.get(rn).add(filePath);
-                    }
-                }
-            }
-            // A compiler-recognized type qualifier is also a semantic use of
-            // the receiver type: `JValue.Compare(...)` references both
-            // JValue and Compare. Index the receiver so class/type queries do
-            // not fall back to a full project scan or leave the occurrence as
-            // an unexplained call-not-resolved line.
-            if (call.receiverIsTypeQualified && call.receiver) {
-                if (!this.calleeIndex.has(call.receiver)) {
-                    this.calleeIndex.set(call.receiver, new Set());
-                }
-                this.calleeIndex.get(call.receiver).add(filePath);
-            }
+        for (const name of calleeNames(calls)) {
+            let files = this.calleeIndex.get(name);
+            if (!files) this.calleeIndex.set(name, files = new Set());
+            files.add(filePath);
         }
     }
 
@@ -1224,23 +1316,11 @@ class ProjectIndex {
      */
     _removeFromCalleeIndex(filePath, calls) {
         if (!this.calleeIndex || !calls) return;
-        for (const call of calls) {
-            const removeName = (n) => {
-                const fileSet = this.calleeIndex.get(n);
-                if (fileSet) {
-                    fileSet.delete(filePath);
-                    if (fileSet.size === 0) this.calleeIndex.delete(n);
-                }
-            };
-            removeName(call.name);
-            if (call.resolvedName && call.resolvedName !== call.name) removeName(call.resolvedName);
-            if (call.resolvedNames) {
-                for (const rn of call.resolvedNames) {
-                    if (rn !== call.name) removeName(rn);
-                }
-            }
-            if (call.receiverIsTypeQualified && call.receiver) {
-                removeName(call.receiver);
+        for (const name of calleeNames(calls)) {
+            const files = this.calleeIndex.get(name);
+            if (files) {
+                files.delete(filePath);
+                if (files.size === 0) this.calleeIndex.delete(name);
             }
         }
     }
@@ -1251,6 +1331,9 @@ class ProjectIndex {
      * Enables O(relevant files) lookup instead of O(all files) scan.
      */
     buildCalleeIndex() {
+        const names = require('./call-name-cache');
+        if (names.restore(this)) return;
+        const collected = new Map();
         const { getCachedCalls } = require('./callers');
         const { ensureCallsCacheLoaded } = require('./cache');
         const { withMacroExpansion } = require('./macro-expansion');
@@ -1263,7 +1346,9 @@ class ProjectIndex {
             const calls = cached ? withMacroExpansion(this, filePath, cached.calls, { materialize: false })
                 : getCachedCalls(this, filePath);
             this._addToCalleeIndex(filePath, calls);
+            names.capture(this, collected, filePath, calls);
         }
+        names.remember(this, collected);
     }
 
     /**
@@ -1336,7 +1421,7 @@ class ProjectIndex {
             // class. Only partial types gather bases from other files, and a
             // C/C++ declaration may be a forward declaration of a class
             // defined in another file.
-            if (contextFile && require('./class-identity').fileDeclaresClass(this, className, contextFile)) return null;
+            if (contextFile && lazyClassIdentityModule().fileDeclaresClass(this, className, contextFile)) return null;
 
             // Try imported file
             if (contextFile) {
@@ -2053,7 +2138,7 @@ class ProjectIndex {
         // A member declared in another same-name type's body (a
         // function-local class beside its module-level namesake, C#
         // `Outcome` beside `Outcome<T>`) is not this type's (fix #389).
-        const { ownerDefinitionOf, classKeyOf } = require('./class-identity');
+        const { ownerDefinitionOf, classKeyOf } = lazyClassIdentityModule();
         const typeKey = definition && definition.name === baseTypeName ? classKeyOf(this, definition) : null;
         const ownedHere = symbol => {
             if (!typeKey) return true;
@@ -2199,6 +2284,14 @@ class ProjectIndex {
      */
     getLineContent(filePath, lineNum) {
         try {
+            // Within an operation the file's split lines are shared, so a
+            // line is one lookup instead of a scan from the file's start
+            // (fix #436: value bands read thousands of lines of one file).
+            if (this._opLinesCache) {
+                const lines = this._getFileLines(filePath);
+                const at = lineNum >= 1 ? Math.ceil(lineNum) - 1 : 0;
+                return at < lines.length ? lines[at] : '';
+            }
             const content = this._readFile(filePath);
             // Find the Nth line without splitting the entire file
             let start = 0;
@@ -2615,34 +2708,47 @@ class ProjectIndex {
         const hint = call?.macroExpansion && call.enclosingFunction;
         if (hint?.name) {
             const exact = this._symbolsNamedAt(fileEntry, hint.name, hint.startLine)
-                .find(symbol => !NON_CALLABLE_TYPES.has(symbol.type) &&
+                .find(symbol => isCallableMember(symbol) &&
                     symbol.startLine <= lineNum && symbol.endLine >= lineNum);
             if (exact) return returnSymbol ? exact : exact.name;
         }
 
-        // Per-operation cache: avoid rescanning symbols for same (file, line)
-        const cacheKey = filePath + '\0' + lineNum;
+        // Call positions distinguish declarations sharing a line. Queries
+        // without a position retain the line-local cache entry.
+        let byLine = null;
+        const column = call?.column ?? call?.callSite?.column;
+        const offset = call?.callStart ?? call?.callSite?.start;
+        const scopeKey = Number.isInteger(column) || Number.isInteger(offset)
+            ? `${lineNum}:${column ?? ''}:${offset ?? ''}` : lineNum;
         if (this._opEnclosingFnCache) {
-            const cached = this._opEnclosingFnCache.get(cacheKey);
+            byLine = this._opEnclosingFnCache.get(filePath);
+            if (!byLine) this._opEnclosingFnCache.set(filePath, byLine = new Map());
+            const cached = byLine.get(scopeKey);
             if (cached !== undefined) {
                 return cached === null ? null : (returnSymbol ? cached : cached.name);
             }
         }
 
         let best = null;
-        for (const symbol of fileEntry.symbols) {
-            if (!NON_CALLABLE_TYPES.has(symbol.type) &&
+        let bestSourceScope = false;
+        // An arrow-function class field is a function body (fix #423).
+        for (const symbol of byLine ? enclosingCandidates(byLine, fileEntry, lineNum) : fileEntry.symbols) {
+            if (isCallableMember(symbol) &&
                 symbol.startLine <= lineNum &&
                 symbol.endLine >= lineNum) {
-                if (!best || (symbol.endLine - symbol.startLine) < (best.endLine - best.startLine)) {
+                const sourceScope = call ? containsCall(symbol, call) : null;
+                if (sourceScope === false) continue;
+                const size = candidate => sourceScope === true && candidate.sourceSpan
+                    ? candidate.sourceSpan.end - candidate.sourceSpan.start : candidate.endLine - candidate.startLine;
+                if (!best || sourceScope === true && !bestSourceScope ||
+                    (sourceScope === true) === bestSourceScope && size(symbol) < size(best)) {
                     best = symbol;
+                    bestSourceScope = sourceScope === true;
                 }
             }
         }
 
-        if (this._opEnclosingFnCache) {
-            this._opEnclosingFnCache.set(cacheKey, best);
-        }
+        if (byLine) byLine.set(scopeKey, best);
         return best ? (returnSymbol ? best : best.name) : null;
     }
 
@@ -2932,6 +3038,14 @@ class ProjectIndex {
     /** Save index to cache file */
     saveCache(cachePath) { return indexCache.saveCache(this, cachePath); }
 
+    /**
+     * Derive whole the Rust files whose macro-expansion calls were derived
+     * in part (fix #405), so a saved cache holds them. Returns the count.
+     */
+    completeMacroCallDerivations() {
+        return this._rustMacroState ? require('./rust-macro-expansion').completeRustMacroCalls(this) : 0;
+    }
+
     /** Load index from cache file */
     /**
      * Build under the cross-process build lock (fix #354) and save the cache.