ucn 3.8.21 → 3.8.23

package/cli/index.js

@@ -14,7 +14,7 @@ const { detectLanguage } = require('../core/parser');
 const { ProjectIndex } = require('../core/project');
 const { expandGlob, findProjectRoot } = require('../core/discovery');
 const output = require('../core/output');
-const { getCliCommandSet, resolveCommand, FLAG_APPLICABILITY, toCliName } = require('../core/registry');
+const { getCliCommandSet, resolveCommand, FLAG_APPLICABILITY, toCliName, FILE_LOCAL_COMMANDS } = require('../core/registry');
 const { execute } = require('../core/execute');
 const { ExpandCache } = require('../core/expand-cache');
 
@@ -322,7 +322,7 @@ function runFileCommand(filePath, command, arg) {
     const canonical = resolveCommand(command, 'cli') || command;
 
     // Commands that need full project index — auto-route to project mode
-    const fileLocalCommands = new Set(['toc', 'fn', 'class', 'find', 'usages', 'search', 'lines', 'typedef', 'api']);
+    const fileLocalCommands = FILE_LOCAL_COMMANDS;
 
     if (!fileLocalCommands.has(canonical)) {
         // Auto-detect project root and route to project mode

package/core/analysis.js

@@ -353,13 +353,24 @@ function related(index, name, options = {}) {
     if (related.similarNames.length > similarLimit) related.similarNames = related.similarNames.slice(0, similarLimit);
 
     // 3. Shared callers - functions called by the same callers
-    const myCallers = new Set(index.findCallers(name).map(c => c.callerName).filter(Boolean));
+    // Cap findCallers to avoid O(hundreds × findCallees) on ambiguous names
+    const maxSharedCallerScan = options.all ? 50 : 20;
+    const myCallersRaw = index.findCallers(name, { maxResults: maxSharedCallerScan * 3 });
+    const myCallers = new Set(myCallersRaw.map(c => c.callerName).filter(Boolean));
     if (myCallers.size > 0) {
         const callerCounts = new Map();
+        const calleeCache = new Map();
+        let scannedCallers = 0;
         for (const callerName of myCallers) {
+            if (scannedCallers >= maxSharedCallerScan) break;
             const callerDef = index.symbols.get(callerName)?.[0];
             if (callerDef) {
-                const callees = index.findCallees(callerDef);
+                let callees = calleeCache.get(callerName);
+                if (!callees) {
+                    callees = index.findCallees(callerDef);
+                    calleeCache.set(callerName, callees);
+                }
+                scannedCallers++;
                 for (const callee of callees) {
                     if (callee.name !== name) {
                         callerCounts.set(callee.name, (callerCounts.get(callee.name) || 0) + 1);
@@ -394,9 +405,14 @@ function related(index, name, options = {}) {
         const myCalleeNames = new Set(myCallees.map(c => c.name));
         if (myCalleeNames.size > 0) {
             const calleeCounts = new Map();
+            // Cap callee scan to avoid O(callees × findCallers) explosion
+            const maxCalleeScan = options.all ? 30 : 15;
+            let scannedCallees = 0;
             for (const calleeName of myCalleeNames) {
+                if (scannedCallees >= maxCalleeScan) break;
+                scannedCallees++;
                 // Find other functions that also call this callee
-                const callers = index.findCallers(calleeName);
+                const callers = index.findCallers(calleeName, { maxResults: 50 });
                 for (const caller of callers) {
                     if (caller.callerName && caller.callerName !== name) {
                         calleeCounts.set(caller.callerName, (calleeCounts.get(caller.callerName) || 0) + 1);
@@ -789,7 +805,9 @@ function about(index, name, options = {}) {
     let aboutConfFiltered = 0;
     if (primary.type === 'function' || primary.params !== undefined) {
         // Use maxResults to limit file iteration (with buffer for exclude filtering)
-        const callerCap = maxCallers === Infinity ? undefined : maxCallers * 3;
+        // Reduce buffer for highly ambiguous names (many definitions = more noise, less value per caller)
+        const callerMultiplier = definitions.length > 5 ? 1.5 : 3;
+        const callerCap = maxCallers === Infinity ? undefined : Math.ceil(maxCallers * callerMultiplier);
         allCallers = index.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary], maxResults: callerCap });
         // Apply exclude filter before slicing
         if (options.exclude && options.exclude.length > 0) {
@@ -837,7 +855,8 @@ function about(index, name, options = {}) {
     }
 
     // Find tests — scope to the same file/class as the primary definition
-    const tests = index.tests(symbolName, {
+    // Skip expensive test search for highly ambiguous names (>10 other definitions)
+    const tests = (others.length > 10 && !options.all) ? [] : index.tests(symbolName, {
         file: options.file,
         className: options.className || primary.className,
         exclude: options.exclude,

package/core/cache.js

@@ -68,31 +68,22 @@ function saveCache(index, cachePath) {
         strippedFiles.push([rp, rest]);
     }
 
-    // Convert graph paths from absolute to relative
+    // Convert graph paths from absolute to relative (Sets serialized as arrays)
     const relGraph = (graph) => {
         const result = [];
         for (const [absKey, absValues] of graph) {
             const relKey = path.relative(root, absKey);
-            const relValues = absValues.map(v => path.relative(root, v));
+            const relValues = [...absValues].map(v => path.relative(root, v));
             result.push([relKey, relValues]);
         }
         return result;
     };
 
-    // Persist calleeIndex if built (paths must be absolute from this.files keys)
-    let calleeIndexData;
-    if (index.calleeIndex && index.calleeIndex.size > 0) {
-        calleeIndexData = [];
-        for (const [name, files] of index.calleeIndex) {
-            const relFiles = [...files].map(f =>
-                path.isAbsolute(f) ? path.relative(root, f) : f
-            );
-            calleeIndexData.push([name, relFiles]);
-        }
-    }
+    // calleeIndex is NOT persisted in index.json — it's rebuilt lazily from callsCache
+    // on first findCallers/buildCalleeIndex call. Removing it saves ~22MB (14%) on large projects.
 
     const cacheData = {
-        version: 7,  // v7: strip symbols/bindings from file entries (dedup ~45% cache reduction)
+        version: 8,  // v8: remove calleeIndex from index.json (rebuilt from callsCache)
         ucnVersion: UCN_VERSION,  // Invalidate cache when UCN is updated
         configHash,
         root,
@@ -108,23 +99,22 @@ function saveCache(index, cachePath) {
         failedFiles: index.failedFiles
             ? Array.from(index.failedFiles).map(f => path.relative(root, f))
             : [],
-        ...(calleeIndexData && { calleeIndex: calleeIndexData })
     };
 
     fs.writeFileSync(cacheFile, JSON.stringify(cacheData));
 
-    // Save callsCache sharded by directory for lazy loading
+    // Save callsCache sharded by directory for lazy loading.
+    // Write to a temp directory first, then atomic swap to avoid data loss on crash.
     if (callsCacheData.length > 0) {
-        const callsDir = path.join(path.dirname(cacheFile), 'calls');
-        // Clean up old shards and legacy monolithic file
-        if (fs.existsSync(callsDir)) {
-            fs.rmSync(callsDir, { recursive: true, force: true });
-        }
-        const legacyFile = path.join(path.dirname(cacheFile), 'calls-cache.json');
-        if (fs.existsSync(legacyFile)) {
-            fs.rmSync(legacyFile, { force: true });
+        const cacheDir = path.dirname(cacheFile);
+        const callsDir = path.join(cacheDir, 'calls');
+        const callsTmpDir = path.join(cacheDir, 'calls.tmp');
+
+        // Clean up any leftover temp dir from a previous crashed save
+        if (fs.existsSync(callsTmpDir)) {
+            fs.rmSync(callsTmpDir, { recursive: true, force: true });
         }
-        fs.mkdirSync(callsDir, { recursive: true });
+        fs.mkdirSync(callsTmpDir, { recursive: true });
 
         // Group by directory
         const shards = new Map();
@@ -134,17 +124,29 @@ function saveCache(index, cachePath) {
             shards.get(dir).push([relPath, entry]);
         }
 
-        // Write one shard per directory
+        // Write all shards to temp directory
         const shardManifest = [];
         for (const [dir, entries] of shards) {
             const hash = crypto.createHash('md5').update(dir).digest('hex').slice(0, 10);
-            const shardFile = path.join(callsDir, `${hash}.json`);
+            const shardFile = path.join(callsTmpDir, `${hash}.json`);
             fs.writeFileSync(shardFile, JSON.stringify(entries));
             shardManifest.push([dir, hash, entries.length]);
         }
 
-        // Write manifest for lazy loading
-        fs.writeFileSync(path.join(callsDir, 'manifest.json'), JSON.stringify(shardManifest));
+        // Write manifest to temp directory
+        fs.writeFileSync(path.join(callsTmpDir, 'manifest.json'), JSON.stringify(shardManifest));
+
+        // Atomic swap: remove old, rename temp to final
+        if (fs.existsSync(callsDir)) {
+            fs.rmSync(callsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(callsTmpDir, callsDir);
+
+        // Clean up legacy monolithic file
+        const legacyFile = path.join(cacheDir, 'calls-cache.json');
+        if (fs.existsSync(legacyFile)) {
+            fs.rmSync(legacyFile, { force: true });
+        }
     }
 
     return cacheFile;
@@ -168,7 +170,8 @@ function loadCache(index, cachePath) {
 
         // Check version compatibility
         // v7: symbols/bindings stripped from file entries (dedup)
-        if (cacheData.version !== 7) {
+        // v8: calleeIndex removed from index.json (rebuilt from callsCache)
+        if (cacheData.version !== 7 && cacheData.version !== 8) {
             return false;
         }
 
@@ -186,12 +189,19 @@ function loadCache(index, cachePath) {
         }
 
         const root = cacheData.root || index.root;
+        // Fast path conversion: string concat is ~70x faster than path.join for
+        // cache-stored relative paths (no '..' segments). On Windows, path.relative
+        // produces backslash paths, so rootPrefix uses the native separator.
+        const rootPrefix = root.endsWith(path.sep) ? root : root + path.sep;
+        const toAbs = path.sep === '/'
+            ? (relPath) => rootPrefix + relPath
+            : (relPath) => rootPrefix + relPath.replace(/\//g, path.sep);
 
         // Reconstruct files Map: relative key → absolute key, restore path and relativePath
         // Initialize symbols/bindings arrays (will be populated from top-level symbols)
         index.files = new Map();
         for (const [relPath, entry] of cacheData.files) {
-            const absPath = path.join(root, relPath);
+            const absPath = toAbs(relPath);
             entry.path = absPath;
             entry.relativePath = relPath;
             if (!entry.symbols) entry.symbols = [];
@@ -204,7 +214,7 @@ function loadCache(index, cachePath) {
         index.symbols = new Map(cacheData.symbols);
         for (const [, defs] of index.symbols) {
             for (const s of defs) {
-                if (!s.file && s.relativePath) s.file = path.join(root, s.relativePath);
+                if (!s.file && s.relativePath) s.file = toAbs(s.relativePath);
                 if (!s.bindingId && s.relativePath && s.type && s.startLine) {
                     s.bindingId = `${s.relativePath}:${s.type}:${s.startLine}`;
                 }
@@ -222,11 +232,14 @@ function loadCache(index, cachePath) {
             }
         }
 
-        // Reconstruct graphs: relative paths → absolute paths
+        // Reconstruct graphs: relative paths → absolute paths (as Sets)
+        // Uses string concat (toAbs) instead of path.join — 70x faster on 464K edges
         const absGraph = (data) => {
             const m = new Map();
             for (const [relKey, relValues] of data) {
-                m.set(path.join(root, relKey), relValues.map(v => path.join(root, v)));
+                const absValues = new Set();
+                for (const v of relValues) absValues.add(toAbs(v));
+                m.set(toAbs(relKey), absValues);
             }
             return m;
         };
@@ -243,10 +256,10 @@ function loadCache(index, cachePath) {
             index.extendedByGraph = new Map(cacheData.extendedByGraph);
         }
 
-        // Eagerly load callsCache from separate file.
-        // Prevents 10K cold tree-sitter re-parses (2GB+ peak) when findCallers runs.
+        // Prepare lazy calls cache loading — load manifest but defer shard parsing.
+        // Shards are loaded on first getCachedCalls access via ensureCallsCacheLoaded().
         if (index.callsCache.size === 0) {
-            loadCallsCache(index);
+            _prepareCallsCache(index);
         }
 
         // Build directory→files index from loaded data
@@ -257,17 +270,17 @@ function loadCache(index, cachePath) {
         // Restore failedFiles if present (convert relative paths back to absolute)
         if (Array.isArray(cacheData.failedFiles)) {
             index.failedFiles = new Set(
-                cacheData.failedFiles.map(f => path.isAbsolute(f) ? f : path.join(root, f))
+                cacheData.failedFiles.map(f => path.isAbsolute(f) ? f : toAbs(f))
             );
         }
 
-        // Restore calleeIndex if persisted
+        // Restore calleeIndex if persisted (v7 caches only; v8+ rebuilds lazily)
         if (Array.isArray(cacheData.calleeIndex)) {
             index.calleeIndex = new Map();
             for (const [name, files] of cacheData.calleeIndex) {
                 if (!Array.isArray(files)) continue;
                 index.calleeIndex.set(name, new Set(
-                    files.map(f => path.isAbsolute(f) ? f : path.join(root, f))
+                    files.map(f => path.isAbsolute(f) ? f : toAbs(f))
                 ));
             }
         }
@@ -292,6 +305,12 @@ function loadCache(index, cachePath) {
  * @returns {boolean} - True if cache needs rebuilding
  */
 function isCacheStale(index) {
+    // Ultra-fast path: skip full check if last confirmed-fresh < 2s ago (covers MCP burst calls).
+    // Only uses _lastFreshAt (set at the end of a successful full check), not cache save timestamp.
+    if (index._lastFreshAt && Date.now() - index._lastFreshAt < 2000) {
+        return false;
+    }
+
     // Fast path: check cached files for modifications/deletions first (stat-only).
     // This returns early without the expensive directory walk when any file changed.
     for (const [filePath, fileEntry] of index.files) {
@@ -337,44 +356,64 @@ function isCacheStale(index) {
         }
     }
 
+    // Record when we last confirmed the cache is fresh (enables 2s skip on burst calls)
+    index._lastFreshAt = Date.now();
     return false;
 }
 
 /**
- * Load callsCache from separate file on demand.
- * Only loads if callsCache is empty (not already populated from inline or prior load).
+ * Prepare calls cache for lazy loading — reads manifest but defers shard parsing.
+ * Called during loadCache() to set up the manifest without the ~1s shard parse cost.
+ * Actual shards are loaded on first ensureCallsCacheLoaded() call.
  * @param {object} index - ProjectIndex instance
- * @returns {boolean} - True if loaded successfully
  */
-function loadCallsCache(index) {
-    if (index.callsCache.size > 0) return true; // Already populated
-    if (index._callsCacheLoaded) return false;   // Already attempted, file didn't exist
-    index._callsCacheLoaded = true;
-
+function _prepareCallsCache(index) {
+    if (index._callsCacheLoaded) return;
     const cacheDir = path.join(index.root, '.ucn-cache');
-
-    // Try sharded format first (calls/manifest.json)
     const manifestFile = path.join(cacheDir, 'calls', 'manifest.json');
     if (fs.existsSync(manifestFile)) {
         try {
             const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf-8'));
-            // Store manifest for lazy loading
             index._callsManifest = new Map();
             for (const [dir, hash, count] of manifest) {
                 index._callsManifest.set(dir, { hash, count, loaded: false });
             }
-            // Eagerly load all shards (matches previous behavior)
-            for (const [, { hash }] of index._callsManifest) {
-                _loadCallsShard(index, hash);
-            }
-            return true;
+            index._callsCachePrepared = true;
+            return;
         } catch (e) {
-            // Corrupted manifest — fall through to legacy
+            // Corrupted manifest — fall through
+        }
+    }
+    // Check legacy format
+    const legacyFile = path.join(cacheDir, 'calls-cache.json');
+    if (fs.existsSync(legacyFile)) {
+        index._callsCacheLegacyFile = legacyFile;
+        index._callsCachePrepared = true;
+    }
+}
+
+/**
+ * Load callsCache from separate file on demand.
+ * Only loads if callsCache is empty (not already populated from inline or prior load).
+ * @param {object} index - ProjectIndex instance
+ * @returns {boolean} - True if loaded successfully
+ */
+function loadCallsCache(index) {
+    if (index.callsCache.size > 0) return true; // Already populated
+    if (index._callsCacheLoaded) return false;   // Already attempted, file didn't exist
+    index._callsCacheLoaded = true;
+
+    // If manifest was prepared lazily, load all shards now
+    if (index._callsManifest) {
+        for (const [, { hash }] of index._callsManifest) {
+            _loadCallsShard(index, hash);
         }
+        return index.callsCache.size > 0;
     }
 
     // Legacy format: single calls-cache.json
-    const callsCacheFile = path.join(cacheDir, 'calls-cache.json');
+    const callsCacheFile = index._callsCacheLegacyFile ||
+        path.join(index.root, '.ucn-cache', 'calls-cache.json');
     if (!fs.existsSync(callsCacheFile)) return false;
 
     try {
@@ -393,6 +432,17 @@ function loadCallsCache(index) {
     return false;
 }
 
+/**
+ * Ensure calls cache is fully loaded (trigger lazy load if prepared but not loaded).
+ * Call this before any operation that needs callsCache (findCallers, buildCalleeIndex, etc.)
+ * @param {object} index - ProjectIndex instance
+ */
+function ensureCallsCacheLoaded(index) {
+    if (index._callsCachePrepared && !index._callsCacheLoaded) {
+        loadCallsCache(index);
+    }
+}
+
 /**
  * Load a single calls shard by hash.
  * @param {object} index - ProjectIndex instance
@@ -403,9 +453,13 @@ function _loadCallsShard(index, hash) {
     try {
         const data = JSON.parse(fs.readFileSync(shardFile, 'utf-8'));
         if (!Array.isArray(data)) return;
+        const rootPrefix = index.root.endsWith(path.sep) ? index.root : index.root + path.sep;
+        const toAbsShard = path.sep === '/'
+            ? (rp) => rootPrefix + rp
+            : (rp) => rootPrefix + rp.replace(/\//g, path.sep);
         for (const [relPath, entry] of data) {
             if (!relPath || !entry) continue;
-            const absPath = path.isAbsolute(relPath) ? relPath : path.join(index.root, relPath);
+            const absPath = path.isAbsolute(relPath) ? relPath : toAbsShard(relPath);
             index.callsCache.set(absPath, entry);
         }
     } catch (e) {
@@ -413,4 +467,4 @@ function _loadCallsShard(index, hash) {
     }
 }
 
-module.exports = { saveCache, loadCache, loadCallsCache, isCacheStale };
+module.exports = { saveCache, loadCache, loadCallsCache, isCacheStale, ensureCallsCacheLoaded };

package/core/callers.js

@@ -13,6 +13,14 @@ const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES } = require('./shared');
 const { scoreEdge } = require('./confidence');
 
+/** Set.some() helper — like Array.some() but for Sets */
+function setSome(set, predicate) {
+    for (const item of set) {
+        if (predicate(item)) return true;
+    }
+    return false;
+}
+
 /**
  * Extract a single line from content without splitting the entire string.
  * @param {string} content - Full file content
@@ -40,6 +48,11 @@ function getLine(content, lineNum) {
  */
 function getCachedCalls(index, filePath, options = {}) {
     try {
+        // Trigger lazy calls cache load if prepared but not yet loaded
+        if (index._callsCachePrepared && !index._callsCacheLoaded) {
+            const { ensureCallsCacheLoaded } = require('./cache');
+            ensureCallsCacheLoaded(index);
+        }
         const cached = index.callsCache.get(filePath);
 
         // Fast path: check mtime first (stat is much faster than read+hash)
@@ -91,6 +104,8 @@ function getCachedCalls(index, filePath, options = {}) {
         }
         const calls = langModule.findCallsInCode(content, parser, callOpts);
 
+        // Remove old callee index entries before overwriting cache
+        if (cached) index._removeFromCalleeIndex(filePath, cached.calls);
         index.callsCache.set(filePath, {
             mtime,
             hash,
@@ -98,6 +113,8 @@ function getCachedCalls(index, filePath, options = {}) {
             content: options.includeContent ? content : undefined
         });
         index.callsCacheDirty = true;
+        // Incrementally update callee index with new calls
+        index._addToCalleeIndex(filePath, calls);
 
         if (options.includeContent) {
             return { calls, content };
@@ -109,7 +126,14 @@ function getCachedCalls(index, filePath, options = {}) {
 }
 
 /**
- * Find all callers of a function using AST-based detection
+ * Find all call sites that invoke the named symbol.
+ *
+ * ReceiverType filtering (nominal vs structural):
+ * - Nominal languages (Go/Java/Rust): uses call.receiverType (from parser-inferred
+ *   method receivers, constructors, composite literals) to filter false positives.
+ * - Structural languages (JS/TS/Python): checks receiver binding evidence from imports
+ *   instead of receiverType, since structural typing makes receiver types ambiguous.
+ *
  * @param {object} index - ProjectIndex instance
  * @param {string} name - Function name to find callers for
  * @param {object} [options] - Options
@@ -383,14 +407,14 @@ function findCallers(index, name, options = {}) {
                     langTraits(fileEntry.language)?.typeSystem === 'structural') {
                     const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                     if (targetFiles.size > 0 && !targetFiles.has(filePath)) {
-                        const imports = index.importGraph.get(filePath) || [];
-                        const importsTarget = imports.some(imp => targetFiles.has(imp));
+                        const imports = index.importGraph.get(filePath);
+                        const importsTarget = imports && setSome(imports, imp => targetFiles.has(imp));
                         if (!importsTarget) {
                             // Check one level of re-exports (barrel files)
                             let foundViaReexport = false;
-                            for (const imp of imports) {
-                                const transImports = index.importGraph.get(imp) || [];
-                                if (transImports.some(ti => targetFiles.has(ti))) {
+                            if (imports) for (const imp of imports) {
+                                const transImports = index.importGraph.get(imp);
+                                if (transImports && setSome(transImports, ti => targetFiles.has(ti))) {
                                     foundViaReexport = true;
                                     break;
                                 }
@@ -448,10 +472,10 @@ function findCallers(index, name, options = {}) {
                             continue;
                         }
                         // Multi-segment import — verify via import graph
-                        const callerImportedFiles = index.importGraph.get(filePath) || [];
+                        const callerImportedFiles = index.importGraph.get(filePath);
                         const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                         if (!targetFiles.has(filePath)) {
-                            const hasImportEdge = callerImportedFiles.some(imp => targetFiles.has(imp));
+                            const hasImportEdge = callerImportedFiles && setSome(callerImportedFiles, imp => targetFiles.has(imp));
                             if (!hasImportEdge) {
                                 // No import edge — allow same-package (same directory) calls
                                 const callerDir = path.dirname(filePath);
@@ -576,13 +600,13 @@ function findCallers(index, name, options = {}) {
                 // Check import graph evidence: does this file import from the target definition's file?
                 const targetDefs2 = options.targetDefinitions || definitions;
                 const targetFiles2 = new Set(targetDefs2.map(d => d.file).filter(Boolean));
-                const callerImports = index.importGraph.get(filePath) || [];
-                let hasImportLink = targetFiles2.has(filePath) || callerImports.some(imp => targetFiles2.has(imp));
+                const callerImports = index.importGraph.get(filePath);
+                let hasImportLink = targetFiles2.has(filePath) || (callerImports && setSome(callerImports, imp => targetFiles2.has(imp)));
                 // Check one level of re-exports (barrel files) for import evidence
-                if (!hasImportLink) {
+                if (!hasImportLink && callerImports) {
                     for (const imp of callerImports) {
-                        const transImports = index.importGraph.get(imp) || [];
-                        if (transImports.some(ti => targetFiles2.has(ti))) {
+                        const transImports = index.importGraph.get(imp);
+                        if (transImports && setSome(transImports, ti => targetFiles2.has(ti))) {
                             hasImportLink = true;
                             break;
                         }
@@ -652,7 +676,15 @@ function findCallers(index, name, options = {}) {
 }
 
 /**
- * Find all functions called by a function using AST-based detection
+ * Find all symbols called from within a function definition.
+ *
+ * Method resolution uses receiverType when available:
+ * - Go: receiverType from method receiver params + _buildTypedLocalTypeMap (New*() patterns)
+ * - Java: receiverType from `new Foo()` constructors + typed parameter declarations
+ * - Rust: receiverType from impl block context + _buildTypedLocalTypeMap
+ * - JS/TS: receiverType from constructor calls + import binding evidence
+ * - Python: receiverType from __init__ attribute type inference (getInstanceAttributeTypes)
+ *
  * @param {object} index - ProjectIndex instance
  * @param {object} def - Symbol definition with file, name, startLine, endLine
  * @param {object} [options] - Options
@@ -1160,7 +1192,7 @@ function findCallees(index, def, options = {}) {
         const defFileEntry = fileEntry;
         const callerIsTest = defFileEntry && isTestFile(defFileEntry.relativePath, defFileEntry.language);
         // Pre-compute import graph for callee confidence scoring
-        const callerImportSet = new Set(index.importGraph.get(def.file) || []);
+        const callerImportSet = index.importGraph.get(def.file) || new Set();
 
         for (const { name: calleeName, bindingId, count, isConstructor } of callees.values()) {
             const symbols = index.symbols.get(calleeName);
@@ -1351,6 +1383,7 @@ function _buildLocalTypeMap(index, def, calls) {
     }
     const lines = content.split('\n');
     const localTypes = new Map();
+    const regexCache = new Map();
 
     for (const call of calls) {
         // Only look at calls within this function's scope
@@ -1368,18 +1401,21 @@ function _buildLocalTypeMap(index, def, calls) {
         const sourceLine = lines[call.line - 1];
         if (!sourceLine) continue;
 
-        // Match: identifier = ClassName(...) or identifier: Type = ClassName(...)
-        const escapedName = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const assignMatch = sourceLine.match(
-            new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${escapedName}\\s*\\(`)
-        );
+        // Memoize compiled regex per call name (same name → same pattern)
+        let patterns = regexCache.get(call.name);
+        if (!patterns) {
+            const esc = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            patterns = {
+                assign: new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${esc}\\s*\\(`),
+                with: new RegExp(`with\\s+${esc}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
+            };
+            regexCache.set(call.name, patterns);
+        }
+        const assignMatch = sourceLine.match(patterns.assign);
         if (assignMatch) {
             localTypes.set(assignMatch[1], call.name);
         }
-        // Match: with ClassName(...) as identifier:
-        const withMatch = sourceLine.match(
-            new RegExp(`with\\s+${escapedName}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
-        );
+        const withMatch = sourceLine.match(patterns.with);
         if (withMatch) {
             localTypes.set(withMatch[1], call.name);
         }
@@ -1395,6 +1431,11 @@ function _buildLocalTypeMap(index, def, calls) {
  * @param {object} index - ProjectIndex instance
  * @param {object} def - Function definition with file, startLine, endLine
  * @param {Array} calls - Cached call sites for the file
+ *
+ * Sources: parser-inferred receiverType from method receivers, constructor calls,
+ * composite literals. Used by Go, Java, Rust (nominal languages) to infer local
+ * variable types for method resolution. Not used by JS/TS/Python -- structural
+ * languages use import evidence via _buildLocalTypeMap instead.
  */
 function _buildTypedLocalTypeMap(index, def, calls) {
     const localTypes = new Map();
@@ -1412,10 +1453,11 @@ function _buildTypedLocalTypeMap(index, def, calls) {
         // Handles: x := NewFoo(), x, err := NewFoo(), x := pkg.NewFoo(), x, err := pkg.NewFoo()
         const newName = call.isMethod ? call.name : call.name;
         if (/^New[A-Z]/.test(newName) && !call.isPotentialCallback) {
+            if (_cachedLines === false) continue; // File unreadable, skip all
             if (!_cachedLines) {
                 try {
                     _cachedLines = index._readFile(def.file).split('\n');
-                } catch { continue; }
+                } catch { _cachedLines = false; continue; }
             }
             const sourceLine = _cachedLines[call.line - 1];
             if (!sourceLine) continue;
@@ -1437,7 +1479,10 @@ function _buildTypedLocalTypeMap(index, def, calls) {
 }
 
 /**
- * Check if a function is used as a callback anywhere in the codebase
+ * Find higher-order function usages where `name` is passed as a callback argument.
+ * Handles patterns like .map(fn), setTimeout(fn), promise.then(handler).
+ * Delegates to per-language findCallbackUsages implementations.
+ *
  * @param {object} index - ProjectIndex instance
  * @param {string} name - Function name
  * @returns {Array} Callback usages