ucn 3.7.45 → 3.7.47

package/core/project.js

@@ -14,7 +14,7 @@ const { extractImports, extractExports, resolveImport } = require('./imports');
 const { parse, parseFile, cleanHtmlScriptTags } = require('./parser');
 const { detectLanguage, getParser, getLanguageModule, safeParse } = require('../languages');
 const { getTokenTypeAtPosition } = require('../languages/utils');
-const { escapeRegExp, NON_CALLABLE_TYPES } = require('./shared');
+const { escapeRegExp, NON_CALLABLE_TYPES, addTestExclusions } = require('./shared');
 const stacktrace = require('./stacktrace');
 const indexCache = require('./cache');
 const deadcodeModule = require('./deadcode');
@@ -157,7 +157,7 @@ class ProjectIndex {
 
         const globOpts = {
             root: this.root,
-            maxFiles: options.maxFiles || 10000,
+            maxFiles: options.maxFiles || this.config.maxFiles || 50000,
             followSymlinks: options.followSymlinks
         };
 
@@ -170,10 +170,18 @@ class ProjectIndex {
 
         const files = expandGlob(pattern, globOpts);
 
+        // Track if files were truncated by maxFiles limit
+        if (files.length >= globOpts.maxFiles) {
+            this.truncated = { indexed: files.length, maxFiles: globOpts.maxFiles };
+        } else {
+            this.truncated = null;
+        }
+
         if (!quiet) {
             console.error(`Indexing ${files.length} files in ${this.root}...`);
         }
 
+        let deletedInRebuild = 0;
         if (options.forceRebuild) {
             // Incremental rebuild: only remove files that no longer exist on disk.
             // indexFile() already skips unchanged files and calls removeFileSymbols()
@@ -184,6 +192,7 @@ class ProjectIndex {
                     this.removeFileSymbols(cachedPath);
                     this.files.delete(cachedPath);
                     this.callsCache.delete(cachedPath);
+                    deletedInRebuild++;
                 }
             }
         }
@@ -193,10 +202,11 @@ class ProjectIndex {
         this._attrTypeCache = null;
 
         let indexed = 0;
+        let changed = 0;
         if (!this.failedFiles) this.failedFiles = new Set();
         for (const file of files) {
             try {
-                this.indexFile(file);
+                if (this.indexFile(file)) changed++;
                 indexed++;
                 this.failedFiles.delete(file); // Succeeded now, remove from failed
             } catch (e) {
@@ -207,8 +217,11 @@ class ProjectIndex {
             }
         }
 
-        this.buildImportGraph();
-        this.buildInheritanceGraph();
+        // Skip graph rebuild when incremental rebuild found no changes
+        if (changed > 0 || deletedInRebuild > 0 || !options.forceRebuild) {
+            this.buildImportGraph();
+            this.buildInheritanceGraph();
+        }
 
         this.buildTime = Date.now() - startTime;
 
@@ -234,14 +247,22 @@ class ProjectIndex {
      * Index a single file
      */
     indexFile(filePath) {
+        const stat = fs.statSync(filePath);
+        const existing = this.files.get(filePath);
+
+        // Fast path: skip read entirely when mtime+size both match
+        if (existing && existing.mtime === stat.mtimeMs && existing.size === stat.size) {
+            return false;
+        }
+
         const content = fs.readFileSync(filePath, 'utf-8');
         const hash = crypto.createHash('md5').update(content).digest('hex');
-        const stat = fs.statSync(filePath);
 
-        // Check if already indexed and unchanged
-        const existing = this.files.get(filePath);
-        if (existing && existing.hash === hash && existing.mtime === stat.mtimeMs) {
-            return;
+        // Content-based skip: mtime changed but content didn't (touch, git checkout)
+        if (existing && existing.hash === hash) {
+            existing.mtime = stat.mtimeMs;
+            existing.size = stat.size;
+            return false;
         }
 
         if (existing) {
@@ -251,7 +272,11 @@ class ProjectIndex {
         const language = detectLanguage(filePath);
         if (!language) return;
 
-        const parsed = parseFile(filePath);
+        // Parse content once — the tree-sitter cache in safeParse ensures the tree
+        // is shared across parse()/extractImports()/extractExports() (5→1 parse per file)
+        const parsed = parse(content, language);
+        parsed.filePath = filePath;
+        parsed.relativePath = filePath;
         const { imports, dynamicCount, importAliases } = extractImports(content, language);
         const { exports } = extractExports(content, language);
 
@@ -280,6 +305,7 @@ class ProjectIndex {
             mtime: stat.mtimeMs,
             size: stat.size,
             imports: imports.map(i => i.module),
+            importNames: imports.flatMap(i => i.names || []),
             exports: exports.map(e => e.name),
             exportDetails: exports,
             symbols: [],
@@ -313,6 +339,7 @@ class ProjectIndex {
                 ...(item.receiver && { receiver: item.receiver }),
                 ...(item.className && { className: item.className }),
                 ...(item.memberType && { memberType: item.memberType }),
+                ...(item.fieldType && { fieldType: item.fieldType }),
                 ...(item.decorators && item.decorators.length > 0 && { decorators: item.decorators }),
                 ...(item.nameLine && { nameLine: item.nameLine })
             };
@@ -331,6 +358,12 @@ class ProjectIndex {
         };
 
         for (const fn of parsed.functions) {
+            // Go/Rust methods: set className from receiver for consistent method resolution.
+            // Go/Rust methods are standalone functions with receiver, not class members,
+            // so className is never set by the class member loop below.
+            if (fn.receiver && !fn.className) {
+                fn.className = fn.receiver.replace(/^\*/, '');
+            }
             addSymbol(fn, fn.isConstructor ? 'constructor' : 'function');
         }
 
@@ -349,6 +382,7 @@ class ProjectIndex {
         }
 
         this.files.set(filePath, fileEntry);
+        return true;
     }
 
     /**
@@ -382,7 +416,7 @@ class ProjectIndex {
      * Handles regular imports, static imports (strips member name), and wildcards (strips .*).
      * Progressively strips trailing segments to find the class file.
      */
-    _resolveJavaPackageImport(importModule) {
+    _resolveJavaPackageImport(importModule, javaFileIndex) {
         const isWildcard = importModule.endsWith('.*');
         // Strip wildcard suffix (e.g., "com.pkg.Class.*" -> "com.pkg.Class")
         const mod = isWildcard ? importModule.slice(0, -2) : importModule;
@@ -390,11 +424,28 @@ class ProjectIndex {
 
         // Try progressively shorter paths: full path, then strip last segment, etc.
         // This handles static imports where path includes member name after class
-        for (let i = segments.length; i > 0; i--) {
-            const fileSuffix = '/' + segments.slice(0, i).join('/') + '.java';
-            for (const absPath of this.files.keys()) {
-                if (absPath.endsWith(fileSuffix)) {
-                    return absPath;
+        if (javaFileIndex) {
+            // Fast path: use pre-built filename→files index (O(candidates) vs O(all files))
+            for (let i = segments.length; i > 0; i--) {
+                const className = segments[i - 1];
+                const candidates = javaFileIndex.get(className);
+                if (candidates) {
+                    const fileSuffix = '/' + segments.slice(0, i).join('/') + '.java';
+                    for (const absPath of candidates) {
+                        if (absPath.endsWith(fileSuffix)) {
+                            return absPath;
+                        }
+                    }
+                }
+            }
+        } else {
+            // Fallback: scan all files (used by imports() method outside buildImportGraph)
+            for (let i = segments.length; i > 0; i--) {
+                const fileSuffix = '/' + segments.slice(0, i).join('/') + '.java';
+                for (const absPath of this.files.keys()) {
+                    if (absPath.endsWith(fileSuffix)) {
+                        return absPath;
+                    }
                 }
             }
         }
@@ -420,6 +471,22 @@ class ProjectIndex {
         this.importGraph.clear();
         this.exportGraph.clear();
 
+        // Pre-build directory→files map for Go package linking (O(1) lookup vs O(n) scan)
+        const dirToGoFiles = new Map();
+        // Pre-build filename→files map for Java import resolution (O(1) vs O(n) scan)
+        const javaFileIndex = new Map();
+        for (const [fp, fe] of this.files) {
+            if (fe.language === 'go') {
+                const dir = path.dirname(fp);
+                if (!dirToGoFiles.has(dir)) dirToGoFiles.set(dir, []);
+                dirToGoFiles.get(dir).push(fp);
+            } else if (fe.language === 'java') {
+                const name = path.basename(fp, '.java');
+                if (!javaFileIndex.has(name)) javaFileIndex.set(name, []);
+                javaFileIndex.get(name).push(fp);
+            }
+        }
+
         for (const [filePath, fileEntry] of this.files) {
             const importedFiles = [];
             const seenModules = new Set();
@@ -442,16 +509,32 @@ class ProjectIndex {
                 // Java package imports: resolve by progressive suffix matching
                 // Handles regular, static (com.pkg.Class.method), and wildcard (com.pkg.Class.*) imports
                 if (!resolved && fileEntry.language === 'java' && !importModule.startsWith('.')) {
-                    resolved = this._resolveJavaPackageImport(importModule);
+                    resolved = this._resolveJavaPackageImport(importModule, javaFileIndex);
                 }
 
                 if (resolved && this.files.has(resolved)) {
-                    importedFiles.push(resolved);
+                    // For Go, a package import means all files in that directory are dependencies
+                    // (Go packages span multiple files in the same directory)
+                    const filesToLink = [resolved];
+                    if (fileEntry.language === 'go') {
+                        const pkgDir = path.dirname(resolved);
+                        const dirFiles = dirToGoFiles.get(pkgDir) || [];
+                        const importerIsTest = filePath.endsWith('_test.go');
+                        for (const fp of dirFiles) {
+                            if (fp !== resolved) {
+                                if (!importerIsTest && fp.endsWith('_test.go')) continue;
+                                filesToLink.push(fp);
+                            }
+                        }
+                    }
 
-                    if (!this.exportGraph.has(resolved)) {
-                        this.exportGraph.set(resolved, []);
+                    for (const linkedFile of filesToLink) {
+                        importedFiles.push(linkedFile);
+                        if (!this.exportGraph.has(linkedFile)) {
+                            this.exportGraph.set(linkedFile, []);
+                        }
+                        this.exportGraph.get(linkedFile).push(filePath);
                     }
-                    this.exportGraph.get(resolved).push(filePath);
                 }
             }
 
@@ -754,14 +837,41 @@ class ProjectIndex {
         // Sort by score descending, then by index order for stability
         scored.sort((a, b) => b.score - a.score);
 
-        // Tiebreaker: when top candidates have equal score, prefer by usage count
+        // Tiebreaker: when top candidates have equal score, prefer by import popularity
+        // (how many files import the candidate's file), then by usage count
         if (scored.length > 1 && scored[0].score === scored[1].score) {
             const tiedScore = scored[0].score;
             const tiedCandidates = scored.filter(s => s.score === tiedScore);
+
+            // Count how many files import each candidate's file (import popularity)
+            // For Go, count importers of any file in the same directory (same package)
             for (const candidate of tiedCandidates) {
+                let importerCount = 0;
+                for (const [, importedFiles] of this.importGraph) {
+                    if (importedFiles.includes(candidate.def.file)) {
+                        importerCount++;
+                    }
+                }
+                // For Go, also count importers of sibling files (same package)
+                const candidateEntry = this.files.get(candidate.def.file);
+                if (candidateEntry?.language === 'go') {
+                    const candidateDir = path.dirname(candidate.def.file);
+                    for (const [, importedFiles] of this.importGraph) {
+                        for (const imp of importedFiles) {
+                            if (imp !== candidate.def.file && path.dirname(imp) === candidateDir) {
+                                importerCount++;
+                                break; // count each importer once
+                            }
+                        }
+                    }
+                }
+                candidate.importerCount = importerCount;
                 candidate.usageCount = this.countSymbolUsages(candidate.def).total;
             }
-            tiedCandidates.sort((a, b) => b.usageCount - a.usageCount);
+            // Sort by import popularity first, then usage count
+            tiedCandidates.sort((a, b) =>
+                (b.importerCount - a.importerCount) || (b.usageCount - a.usageCount)
+            );
             // Rebuild scored array: sorted tied candidates first, then rest
             const rest = scored.filter(s => s.score !== tiedScore);
             scored.length = 0;
@@ -902,8 +1012,21 @@ class ProjectIndex {
         // 1. The file where it's defined
         // 2. Files that import from the definition file
         // 3. Transitively: files that import from re-exporters of this symbol
+        // 4. Go: all files in the same package directory (same-package references need no import)
         const relevantFiles = new Set([defFile]);
         const queue = [defFile];
+
+        // Go same-package: add all .go files in the same directory
+        const defEntry = this.files.get(defFile);
+        if (defEntry?.language === 'go') {
+            const pkgDir = path.dirname(defFile);
+            for (const fp of this.files.keys()) {
+                if (fp !== defFile && fp.endsWith('.go') && path.dirname(fp) === pkgDir) {
+                    relevantFiles.add(fp);
+                }
+            }
+        }
+
         while (queue.length > 0) {
             const file = queue.pop();
             const importers = this.exportGraph.get(file) || [];
@@ -1059,7 +1182,7 @@ class ProjectIndex {
                         // Filters: namespace access to external packages (DropdownMenuPrimitive.Separator).
                         if (u.receiver && !['self', 'this', 'cls', 'super'].includes(u.receiver) &&
                             fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
-                            const hasMethodDef = allDefinitions.some(d => d.className);
+                            const hasMethodDef = definitions.some(d => d.className);
                             if (!hasMethodDef && !importedFileHasDef()) {
                                 continue;
                             }
@@ -1294,6 +1417,7 @@ class ProjectIndex {
                 dynamicImports,
                 uncertain: stats.uncertain,
                 includeMethods: !!options.includeMethods,
+                projectLanguage: this._getPredominantLanguage(),
                 // Structural facts for reliability hints
                 ...(def.isMethod && { isMethod: true }),
                 ...(def.className && { className: def.className }),
@@ -1436,7 +1560,8 @@ class ProjectIndex {
                 complete: stats.uncertain === 0 && dynamicImports === 0,
                 skipped: 0,
                 dynamicImports,
-                uncertain: stats.uncertain
+                uncertain: stats.uncertain,
+                projectLanguage: this._getPredominantLanguage()
             }
         };
         } finally { this._endOp(); }
@@ -1446,6 +1571,27 @@ class ProjectIndex {
     // HELPER METHODS
     // ========================================================================
 
+    /**
+     * Get the predominant language of the project (cached).
+     * Returns 'go', 'javascript', etc. if >80% of files are that language.
+     */
+    _getPredominantLanguage() {
+        if (this._predominantLang !== undefined) return this._predominantLang;
+        const counts = {};
+        for (const [, fe] of this.files) {
+            counts[fe.language] = (counts[fe.language] || 0) + 1;
+        }
+        const total = this.files.size;
+        for (const [lang, count] of Object.entries(counts)) {
+            if (count / total > 0.8) {
+                this._predominantLang = lang;
+                return lang;
+            }
+        }
+        this._predominantLang = null;
+        return null;
+    }
+
     /**
      * Get line content from a file
      */
@@ -2054,11 +2200,23 @@ class ProjectIndex {
 
         let fileIterator;
         if (filePath) {
+            // Try exact resolution first
             const resolved = this.resolveFilePathForQuery(filePath);
-            if (typeof resolved !== 'string') return resolved;
-            const fileEntry = this.files.get(resolved);
-            if (!fileEntry) return { error: 'file-not-found', filePath };
-            fileIterator = [[resolved, fileEntry]];
+            if (typeof resolved === 'string') {
+                const fileEntry = this.files.get(resolved);
+                if (!fileEntry) return { error: 'file-not-found', filePath };
+                fileIterator = [[resolved, fileEntry]];
+            } else {
+                // Fall back to pattern filter (substring match on relative path)
+                const matches = [];
+                for (const [absPath, fe] of this.files) {
+                    if (fe.relativePath.includes(filePath)) {
+                        matches.push([absPath, fe]);
+                    }
+                }
+                if (matches.length === 0) return { error: 'file-not-found', filePath };
+                fileIterator = matches;
+            }
         } else {
             fileIterator = this.files.entries();
         }
@@ -2392,6 +2550,8 @@ class ProjectIndex {
         let evalUsage = 0;
         let reflectionUsage = 0;
 
+        const predominantLang = this._getPredominantLanguage();
+
         for (const [filePath, fileEntry] of this.files) {
             // Skip node_modules - we don't care about their patterns
             if (filePath.includes('node_modules')) continue;
@@ -2399,14 +2559,16 @@ class ProjectIndex {
             try {
                 const content = this._readFile(filePath);
 
-                // Dynamic imports: import(), require(variable), __import__
-                dynamicImports += (content.match(/import\s*\([^'"]/g) || []).length;
-                dynamicImports += (content.match(/require\s*\([^'"]/g) || []).length;
-                dynamicImports += (content.match(/__import__\s*\(/g) || []).length;
+                if (fileEntry.language !== 'go') {
+                    // Dynamic imports: import(), require(variable), __import__
+                    dynamicImports += (content.match(/import\s*\([^'"]/g) || []).length;
+                    dynamicImports += (content.match(/require\s*\([^'"]/g) || []).length;
+                    dynamicImports += (content.match(/__import__\s*\(/g) || []).length;
 
-                // eval, Function constructor
-                evalUsage += (content.match(/(^|[^a-zA-Z_])eval\s*\(/gm) || []).length;
-                evalUsage += (content.match(/new\s+Function\s*\(/g) || []).length;
+                    // eval, Function constructor
+                    evalUsage += (content.match(/(^|[^a-zA-Z_])eval\s*\(/gm) || []).length;
+                    evalUsage += (content.match(/new\s+Function\s*\(/g) || []).length;
+                }
 
                 // Reflection: getattr, hasattr, Reflect
                 reflectionUsage += (content.match(/\bgetattr\s*\(/g) || []).length;
@@ -2727,7 +2889,7 @@ class ProjectIndex {
         if (!def) {
             return null;
         }
-        const defIsMethod = def.isMethod || def.type === 'method' || def.className;
+        const defIsMethod = def.isMethod || def.type === 'method' || def.className || def.receiver;
 
         // Use findCallers for className-scoped or method queries (sophisticated binding resolution)
         // Fall back to usages-based approach for simple function queries (backward compatible)
@@ -2740,10 +2902,11 @@ class ProjectIndex {
                 targetDefinitions: [def],
             });
 
-            // When className is explicitly provided, filter out method calls whose
-            // receiver clearly belongs to a different type. This helps with common
-            // method names like .close(), .get() etc. where many objects have the same method.
-            if (options.className && def.className) {
+            // When the target definition has a className (including Go/Rust methods which
+            // now get className from receiver), filter out method calls whose receiver
+            // clearly belongs to a different type. This helps with common method names
+            // like .close(), .get() etc. where many types have the same method.
+            if (def.className) {
                 const targetClassName = def.className;
                 callerResults = callerResults.filter(c => {
                     // Keep non-method calls and self/this/cls calls (already resolved by findCallers)
@@ -2804,20 +2967,22 @@ class ProjectIndex {
                             }
                         }
                     }
-                    // Unique method heuristic: if the called method exists on exactly one class
+                    // Unique method heuristic: if the called method exists on exactly one class/type
                     // and it matches the target, include the call (no other class could match)
                     const methodDefs = this.symbols.get(name);
                     if (methodDefs) {
                         const classNames = new Set();
                         for (const d of methodDefs) {
                             if (d.className) classNames.add(d.className);
+                            // Go/Rust: use receiver type as className equivalent
+                            else if (d.receiver) classNames.add(d.receiver.replace(/^\*/, ''));
                         }
                         if (classNames.size === 1 && classNames.has(targetClassName)) {
                             return true;
                         }
                     }
-                    // className explicitly set but receiver type unknown — filter it out.
-                    // User asked for a specific class; unknown receivers are likely unrelated.
+                    // Type-scoped query but receiver type unknown — filter it out.
+                    // Unknown receivers are likely unrelated.
                     return false;
                 });
             }
@@ -2874,11 +3039,27 @@ class ProjectIndex {
 
             // Analyze each call site, filtering out method calls for non-method definitions
             callSites = [];
+            const defFileEntry = this.files.get(def.file);
+            const defLang = defFileEntry?.language;
+            const targetDir = defLang === 'go' ? path.basename(path.dirname(def.file)) : null;
             for (const call of calls) {
                 const analysis = this.analyzeCallSite(call, name);
                 // Skip method calls (obj.parse()) when target is a standalone function (parse())
+                // For Go, allow calls where receiver matches the package directory name
+                // (e.g., controller.FilterActive() where file is in pkg/controller/)
                 if (analysis.isMethodCall && !defIsMethod) {
-                    continue;
+                    if (targetDir) {
+                        // Get receiver from parsed calls cache
+                        const parsedCalls = this.getCachedCalls(call.file);
+                        const matchedCall = parsedCalls?.find(c => c.name === name && c.line === call.line);
+                        if (matchedCall?.receiver === targetDir) {
+                            // Receiver matches package directory — keep it
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
                 }
                 callSites.push({
                     file: call.relativePath,
@@ -3041,8 +3222,12 @@ class ProjectIndex {
         const isMethod = !!(primary.isMethod || primary.type === 'method' || primary.className);
         const includeMethods = options.includeMethods ?? isMethod;
 
-        // Get usage counts by type
-        const usages = this.usages(symbolName, { codeOnly: true });
+        // Get usage counts by type (exclude test files by default, matching usages command behavior)
+        const usageOpts = { codeOnly: true };
+        if (!options.includeTests) {
+            usageOpts.exclude = addTestExclusions(options.exclude);
+        }
+        const usages = this.usages(symbolName, usageOpts);
         const usagesByType = {
             definitions: usages.filter(u => u.isDefinition).length,
             calls: usages.filter(u => u.usageType === 'call').length,
@@ -3056,7 +3241,9 @@ class ProjectIndex {
         let allCallers = null;
         let allCallees = null;
         if (primary.type === 'function' || primary.params !== undefined) {
-            allCallers = this.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary] });
+            // Use maxResults to limit file iteration (with buffer for exclude filtering)
+            const callerCap = maxCallers === Infinity ? undefined : maxCallers * 3;
+            allCallers = this.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary], maxResults: callerCap });
             // Apply exclude filter before slicing
             if (options.exclude && options.exclude.length > 0) {
                 allCallers = allCallers.filter(c => this.matchesFilters(c.relativePath, { exclude: options.exclude }));
@@ -3203,6 +3390,14 @@ class ProjectIndex {
         }
 
         for (const [filePath, fileEntry] of this.files) {
+            // Apply --file filter
+            if (options.file) {
+                const fp = fileEntry.relativePath;
+                if (!fp.includes(options.file) && !fp.endsWith(options.file)) {
+                    filesSkipped++;
+                    continue;
+                }
+            }
             // Apply exclude/in filters
             if ((options.exclude && options.exclude.length > 0) || options.in) {
                 if (!this.matchesFilters(fileEntry.relativePath, { exclude: options.exclude, in: options.in })) {
@@ -3349,7 +3544,8 @@ class ProjectIndex {
             symbols: totalSymbols,  // Total symbol count, not unique names
             buildTime: this.buildTime,
             byLanguage: {},
-            byType: {}
+            byType: {},
+            ...(this.truncated && { truncated: this.truncated })
         };
 
         for (const [filePath, fileEntry] of this.files) {
@@ -3520,12 +3716,18 @@ class ProjectIndex {
             displayFiles = files.slice(0, top);
         }
 
+        // Count files with no symbols (generated/empty files)
+        const emptyFiles = files.filter(f => f.functions === 0 && f.classes === 0 && f.state === 0).length;
+
         return {
             meta: {
                 complete: totalDynamic === 0,
                 skipped: 0,
                 dynamicImports: totalDynamic,
-                uncertain: 0
+                uncertain: 0,
+                projectLanguage: this._getPredominantLanguage(),
+                ...(fileFilter && { filteredBy: options.file, matchedFiles: files.length }),
+                ...(emptyFiles > 0 && fileFilter && { emptyFiles })
             },
             totals: {
                 files: files.length,
@@ -3555,6 +3757,9 @@ class ProjectIndex {
     /** Load index from cache file */
     loadCache(cachePath) { return indexCache.loadCache(this, cachePath); }
 
+    /** Load callsCache from separate file on demand (called by findCallers/findCallees) */
+    loadCallsCache() { return indexCache.loadCallsCache(this); }
+
     /** Check if cache is stale (any files changed or new files added) */
     isCacheStale() { return indexCache.isCacheStale(this); }
 
@@ -3875,7 +4080,40 @@ class ProjectIndex {
                 const allDefs = this.symbols.get(symbol.name) || [];
                 const targetDefs = allDefs.filter(d => d.file === change.filePath && d.startLine === symbol.startLine);
 
-                const callers = this.findCallers(symbol.name, { targetDefinitions: targetDefs.length > 0 ? targetDefs : undefined });
+                let callers = this.findCallers(symbol.name, {
+                    targetDefinitions: targetDefs.length > 0 ? targetDefs : undefined,
+                    includeMethods: true,
+                    includeUncertain: false,
+                });
+
+                // For Go/Java/Rust methods with a className, filter callers whose
+                // receiver clearly belongs to a different type (same logic as impact()).
+                const targetDef = targetDefs[0] || symbol;
+                if (targetDef.className && (lang === 'go' || lang === 'java' || lang === 'rust')) {
+                    const targetClassName = targetDef.className;
+                    callers = callers.filter(c => {
+                        if (!c.isMethod) return true;
+                        const r = c.receiver;
+                        if (!r || ['self', 'cls', 'this', 'super'].includes(r)) return true;
+                        // Use receiverType from findCallers when available
+                        if (c.receiverType) {
+                            return c.receiverType === targetClassName ||
+                                   c.receiverType === targetDef.receiver?.replace(/^\*/, '');
+                        }
+                        // Unique method heuristic: if the method exists on exactly one class/type, include
+                        const methodDefs = this.symbols.get(symbol.name);
+                        if (methodDefs) {
+                            const classNames = new Set();
+                            for (const d of methodDefs) {
+                                if (d.className) classNames.add(d.className);
+                                else if (d.receiver) classNames.add(d.receiver.replace(/^\*/, ''));
+                            }
+                            if (classNames.size === 1 && classNames.has(targetClassName)) return true;
+                        }
+                        // Unknown receiver + multiple classes with this method → filter out
+                        return false;
+                    });
+                }
 
                 for (const c of callers) {
                     callerFileSet.add(c.file);

package/core/registry.js

@@ -70,6 +70,7 @@ const PARAM_MAP = {
     rename_to:         'renameTo',
     default_value:     'defaultValue',
     top_level:         'topLevel',
+    max_files:         'maxFiles',
 };
 
 // ============================================================================

package/core/shared.js

@@ -48,6 +48,6 @@ function escapeRegExp(text) {
 }
 
 // Symbol types that are not callable (used to filter class/struct/type declarations from call analysis)
-const NON_CALLABLE_TYPES = new Set(['class', 'struct', 'interface', 'type', 'enum', 'trait', 'state', 'impl']);
+const NON_CALLABLE_TYPES = new Set(['class', 'struct', 'interface', 'type', 'enum', 'trait', 'state', 'impl', 'field']);
 
 module.exports = { pickBestDefinition, addTestExclusions, escapeRegExp, NON_CALLABLE_TYPES };