ucn 3.7.46 → 3.8.0

package/core/callers.js

@@ -12,6 +12,22 @@ const { detectLanguage, getParser, getLanguageModule } = require('../languages')
 const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES } = require('./shared');
 
+/**
+ * Extract a single line from content without splitting the entire string.
+ * @param {string} content - Full file content
+ * @param {number} lineNum - 1-indexed line number
+ * @returns {string} The line content
+ */
+function getLine(content, lineNum) {
+    let start = 0;
+    for (let i = 1; i < lineNum; i++) {
+        start = content.indexOf('\n', start) + 1;
+        if (start === 0) return ''; // past end
+    }
+    const end = content.indexOf('\n', start);
+    return end === -1 ? content.slice(start) : content.slice(start, end);
+}
+
 /**
  * Get cached call sites for a file, with mtime/hash validation
  * Uses mtime for fast cache validation, falls back to hash if mtime matches but content changed
@@ -63,7 +79,16 @@ function getCachedCalls(index, filePath, options = {}) {
         if (!langModule.findCallsInCode) return null;
 
         const parser = getParser(language);
-        const calls = langModule.findCallsInCode(content, parser);
+        // Pass import alias names to Go parser for package vs method call disambiguation
+        // importNames contains resolved alias names (e.g., 'utilversion' for renamed imports)
+        const callOpts = {};
+        if (language === 'go') {
+            const fileEntry = index.files.get(filePath);
+            if (fileEntry?.importNames) {
+                callOpts.imports = fileEntry.importNames;
+            }
+        }
+        const calls = langModule.findCallsInCode(content, parser, callOpts);
 
         index.callsCache.set(filePath, {
             mtime,
@@ -92,6 +117,9 @@ function getCachedCalls(index, filePath, options = {}) {
 function findCallers(index, name, options = {}) {
     index._beginOp();
     try {
+    // Lazy-load callsCache from disk if not already populated
+    if (index.loadCallsCache) index.loadCallsCache();
+
     const callers = [];
     const stats = options.stats;
 
@@ -102,13 +130,24 @@ function findCallers(index, name, options = {}) {
         definitionLines.add(`${def.file}:${def.startLine}`);
     }
 
-    for (const [filePath, fileEntry] of index.files) {
+    // Phase 1: Find matching calls without reading file content.
+    // Collect pending callers keyed by file — content is read only in Phase 2.
+    const pendingByFile = new Map(); // filePath -> [{ call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver }]
+    let pendingCount = 0;
+    const maxResults = options.maxResults;
+
+    // Use inverted callee index to skip files that don't contain calls to this name
+    const calleeFiles = index.getCalleeFiles(name);
+    const fileIterator = calleeFiles
+        ? [...calleeFiles].map(fp => [fp, index.files.get(fp)]).filter(([, fe]) => fe)
+        : index.files;
+
+    for (const [filePath, fileEntry] of fileIterator) {
+        // Early exit when maxResults is reached
+        if (maxResults && pendingCount >= maxResults) break;
         try {
-            const result = getCachedCalls(index, filePath, { includeContent: true });
-            if (!result) continue;
-
-            const { calls, content } = result;
-            const lines = content.split('\n');
+            const calls = getCachedCalls(index, filePath);
+            if (!calls) continue;
 
             for (const call of calls) {
                 // Skip if not matching our target name (also check alias resolution)
@@ -120,31 +159,53 @@ function findCallers(index, name, options = {}) {
                 if (call.isPotentialCallback) {
                     const syms = definitions;
                     if (!syms || syms.length === 0) continue;
+
+                    // Go unexported visibility: lowercase functions are package-private.
+                    // Only allow callers from the same package directory.
+                    if (fileEntry.language === 'go' && /^[a-z]/.test(name)) {
+                        const targetDefs = options.targetDefinitions || definitions;
+                        const targetPkgDirs = new Set(
+                            targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
+                        );
+                        if (targetPkgDirs.size > 0 && !targetPkgDirs.has(path.dirname(filePath))) {
+                            continue;
+                        }
+                    }
+
+                    // Go/Java/Rust receiver disambiguation for callbacks (e.g. dc.worker)
+                    if (call.isMethod && call.receiver &&
+                        (fileEntry.language === 'go' || fileEntry.language === 'java' || fileEntry.language === 'rust')) {
+                        const targetDefs = options.targetDefinitions || definitions;
+                        const targetTypes = new Set();
+                        for (const td of targetDefs) {
+                            if (td.className) targetTypes.add(td.className);
+                            if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
+                        }
+                        if (targetTypes.size > 0 && call.receiverType) {
+                            if (!targetTypes.has(call.receiverType)) continue;
+                        }
+                    }
+
                     // Find the enclosing function
                     const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
-                    callers.push({
-                        file: filePath,
-                        relativePath: fileEntry.relativePath,
-                        line: call.line,
-                        content: lines[call.line - 1] || '',
-                        callerName: callerSymbol ? callerSymbol.name : null,
-                        callerFile: callerSymbol ? filePath : null,
-                        callerStartLine: callerSymbol ? callerSymbol.startLine : null,
-                        callerEndLine: callerSymbol ? callerSymbol.endLine : null,
-                        isMethod: false,
-                        isFunctionReference: true
+                    if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
+                    pendingByFile.get(filePath).push({
+                        call, fileEntry, callerSymbol,
+                        isMethod: false, isFunctionReference: true, receiver: undefined
                     });
+                    pendingCount++;
                     continue;
                 }
 
                 // Resolve binding within this file (without mutating cached call objects)
                 let bindingId = call.bindingId;
                 let isUncertain = call.uncertain;
-                // Skip binding resolution for method calls with non-self/this/cls receivers:
+                // Skip binding resolution for calls with non-self/this/cls receivers:
                 // e.g., analyzer.analyze_instrument() should NOT resolve to a local
                 // standalone function def `analyze_instrument` — they're different symbols.
+                // Also skip for Go package-qualified calls (isMethod:false but has receiver like 'cli')
                 const selfReceivers = new Set(['self', 'cls', 'this', 'super']);
-                const skipLocalBinding = call.isMethod && call.receiver && !selfReceivers.has(call.receiver);
+                const skipLocalBinding = call.receiver && !selfReceivers.has(call.receiver);
                 if (!bindingId && !skipLocalBinding) {
                     let bindings = (fileEntry.bindings || []).filter(b => b.name === call.name);
                     // For Go, also check sibling files in same directory (same package scope)
@@ -306,34 +367,106 @@ function findCallers(index, name, options = {}) {
                     continue;
                 }
 
+                // Import-graph disambiguation for JS/TS/Python: when multiple definitions of
+                // the same name exist and this call has no bindingId, check whether the calling
+                // file imports from the target definition's file. Skips false positives like
+                // user_b importing from b.js being reported as a caller of a.js:process.
+                // Go/Java/Rust are excluded — they use package/module scoping, not file imports.
+                if (!bindingId && options.targetDefinitions && definitions.length > 1 &&
+                    fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
+                    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));
+                        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))) {
+                                    foundViaReexport = true;
+                                    break;
+                                }
+                            }
+                            if (!foundViaReexport) continue;
+                        }
+                    }
+                }
+
+                // Go unexported visibility: lowercase functions are package-private.
+                // Only allow callers from the same package directory.
+                if (fileEntry.language === 'go' && /^[a-z]/.test(name)) {
+                    const targetPkgDirs = new Set(
+                        targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
+                    );
+                    if (targetPkgDirs.size > 0 && !targetPkgDirs.has(path.dirname(filePath))) {
+                        continue;
+                    }
+                }
+
+                // Go/Java/Rust: method vs non-method cross-matching filter.
+                // Prevents t.Errorf() (method call) from matching standalone func Errorf,
+                // and cli.Run() (package call, isMethod:false) from matching DeploymentController.Run.
+                // Rust path calls (module::func(), Type::new()) bypass this filter — they're
+                // scoped_identifier calls that can target both standalone functions and impl methods.
+                if (!bindingId && !resolvedBySameClass && !call.isPathCall &&
+                    (fileEntry.language === 'go' || fileEntry.language === 'java' || fileEntry.language === 'rust')) {
+                    const targetHasClass = targetDefs.some(d => d.className);
+                    if (call.isMethod && !targetHasClass) {
+                        // Method call but target is a standalone function — skip
+                        continue;
+                    }
+                    if (!call.isMethod && targetHasClass) {
+                        // Non-method call but target is a class method — skip
+                        continue;
+                    }
+                }
+
                 // Java/Go/Rust receiver-class disambiguation:
-                // When targetDefinitions narrows to specific class(es) and the call has a
-                // receiver (e.g. javascriptFileService.createDataFile()), check if the
-                // receiver name better matches a non-target class definition.
-                // This prevents false positives like reporting obj.save() as a caller of
-                // TargetClass.save() when obj is clearly a different type.
+                // When the target definition has a class/receiver type, filter callers
+                // whose receiverType is known to be a different type.
+                // Go uses inferred receiverType; Java/Rust fall back to variable name matching.
                 if (call.isMethod && call.receiver && !resolvedBySameClass && !bindingId &&
-                    options.targetDefinitions && definitions.length > 1 &&
                     (fileEntry.language === 'java' || fileEntry.language === 'go' || fileEntry.language === 'rust')) {
-                    const targetClassNames = new Set(targetDefs.map(d => d.className).filter(Boolean));
-                    if (targetClassNames.size > 0) {
-                        const receiverLower = call.receiver.toLowerCase();
-                        // Check if receiver matches any target class (camelCase convention)
-                        const matchesTarget = [...targetClassNames].some(cn => cn.toLowerCase() === receiverLower);
-                        if (!matchesTarget) {
-                            // Check if receiver matches a non-target class instead
-                            const nonTargetClasses = definitions
-                                .filter(d => d.className && !targetClassNames.has(d.className))
-                                .map(d => d.className);
-                            const matchesOther = nonTargetClasses.some(cn => cn.toLowerCase() === receiverLower);
-                            if (matchesOther) {
-                                // Receiver clearly belongs to a different class
+                    // Build target type set from both className (Java) and receiver (Go/Rust)
+                    const targetTypes = new Set();
+                    for (const td of targetDefs) {
+                        if (td.className) targetTypes.add(td.className);
+                        if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
+                    }
+                    if (targetTypes.size > 0) {
+                        // Use inferred receiverType when available (Go/Java/Rust parameter type tracking)
+                        const knownType = call.receiverType;
+                        if (knownType) {
+                            const matchesTarget = targetTypes.has(knownType);
+                            if (!matchesTarget) {
+                                // Known type doesn't match target — skip directly
                                 isUncertain = true;
                                 if (!options.includeUncertain) {
                                     if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                                     continue;
                                 }
                             }
+                        } else if (options.targetDefinitions && definitions.length > 1) {
+                            // No inferred type — fall back to receiver variable name matching
+                            // only when we have multiple definitions to disambiguate
+                            const receiverLower = call.receiver.toLowerCase();
+                            const matchesTarget = [...targetTypes].some(cn => cn.toLowerCase() === receiverLower);
+                            if (!matchesTarget) {
+                                const nonTargetClasses = new Set();
+                                for (const d of definitions) {
+                                    const t = d.className || (d.receiver && d.receiver.replace(/^\*/, ''));
+                                    if (t && !targetTypes.has(t)) nonTargetClasses.add(t);
+                                }
+                                const matchesOther = [...nonTargetClasses].some(cn => cn.toLowerCase() === receiverLower);
+                                if (matchesOther) {
+                                    isUncertain = true;
+                                    if (!options.includeUncertain) {
+                                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                        continue;
+                                    }
+                                }
+                            }
                         }
                     }
                 }
@@ -341,22 +474,43 @@ function findCallers(index, name, options = {}) {
                 // Find the enclosing function (get full symbol info)
                 const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
 
+                if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
+                pendingByFile.get(filePath).push({
+                    call, fileEntry, callerSymbol,
+                    isMethod: call.isMethod || false, isFunctionReference: false,
+                    receiver: call.receiver,
+                    receiverType: call.receiverType
+                });
+                pendingCount++;
+            }
+        } catch (e) {
+            // Expected: minified files exceed tree-sitter buffer, binary files fail to parse.
+            // These are not actionable errors — silently skip.
+        }
+    }
+
+    // Phase 2: Read content only for files with matching calls (eliminates ~98% of file reads)
+    for (const [filePath, pending] of pendingByFile) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver, receiverType } of pending) {
                 callers.push({
                     file: filePath,
                     relativePath: fileEntry.relativePath,
                     line: call.line,
-                    content: lines[call.line - 1] || '',
+                    content: getLine(content, call.line),
                     callerName: callerSymbol ? callerSymbol.name : null,
                     callerFile: callerSymbol ? filePath : null,
                     callerStartLine: callerSymbol ? callerSymbol.startLine : null,
                     callerEndLine: callerSymbol ? callerSymbol.endLine : null,
-                    isMethod: call.isMethod || false,
-                    receiver: call.receiver
+                    isMethod,
+                    ...(isFunctionReference && { isFunctionReference: true }),
+                    ...(receiver !== undefined && { receiver }),
+                    ...(receiverType && { receiverType })
                 });
             }
         } catch (e) {
-            // Expected: minified files exceed tree-sitter buffer, binary files fail to parse.
-            // These are not actionable errors — silently skip.
+            // File may have been deleted between Phase 1 and Phase 2
         }
     }
 
@@ -374,6 +528,9 @@ function findCallers(index, name, options = {}) {
 function findCallees(index, def, options = {}) {
     index._beginOp();
     try {
+    // Lazy-load callsCache from disk if not already populated
+    if (index.loadCallsCache) index.loadCallsCache();
+
     try {
         // Get all calls from the file's cache (now includes enclosingFunction)
         const calls = getCachedCalls(index, def.file);
@@ -403,6 +560,8 @@ function findCallees(index, def, options = {}) {
         let localTypes = null;
         if (language === 'python' || language === 'javascript') {
             localTypes = _buildLocalTypeMap(index, def, calls);
+        } else if (language === 'go' || language === 'java' || language === 'rust') {
+            localTypes = _buildTypedLocalTypeMap(index, def, calls);
         }
 
         for (const call of calls) {
@@ -434,11 +593,17 @@ function findCallees(index, def, options = {}) {
                 } else if (localTypes && localTypes.has(call.receiver)) {
                     // Resolve method calls on locally-constructed objects:
                     // bt = Backtester(...); bt.run_backtest() → Backtester.run_backtest
-                    const className = localTypes.get(call.receiver);
+                    // Go: f.Run() where f is *Framework → Framework.Run (receiver match)
+                    const typeName = localTypes.get(call.receiver);
                     const symbols = index.symbols.get(call.name);
-                    const match = symbols?.find(s => s.className === className);
+                    const isCallable = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
+                        (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
+                    const match = symbols?.find(s =>
+                        isCallable(s) && (
+                        s.className === typeName ||
+                        (s.receiver && s.receiver.replace(/^\*/, '') === typeName)));
                     if (match) {
-                        const key = match.bindingId || `${className}.${call.name}`;
+                        const key = match.bindingId || `${typeName}.${call.name}`;
                         const existing = callees.get(key);
                         if (existing) {
                             existing.count += 1;
@@ -447,6 +612,64 @@ function findCallees(index, def, options = {}) {
                         }
                     }
                     continue;
+                } else if (call.receiverType && (language === 'go' || language === 'java' || language === 'rust')) {
+                    // Use parser-inferred receiverType for method resolution
+                    // e.g., f.RunFilter() where f is *Framework → resolve to Framework.RunFilter
+                    const typeName = call.receiverType;
+                    const symbols = index.symbols.get(call.name);
+                    const isCallableRT = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
+                        (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
+                    const match = symbols?.find(s =>
+                        isCallableRT(s) && (
+                        (s.receiver && s.receiver.replace(/^\*/, '') === typeName) ||
+                        s.className === typeName));
+                    if (match) {
+                        const key = match.bindingId || `${typeName}.${call.name}`;
+                        const existing = callees.get(key);
+                        if (existing) {
+                            existing.count += 1;
+                        } else {
+                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                        }
+                        continue;
+                    }
+                    // No match found with inferred type — fall through to include as unresolved
+                } else if (language === 'go' && call.receiver) {
+                    // Go package-qualified calls: klog.Infof(), wait.UntilWithContext()
+                    // Check if receiver is an import alias and resolve to correct package
+                    const goImports = fileEntry?.imports || [];
+                    // Find import whose package name matches the receiver
+                    const importModule = goImports.find(mod => {
+                        const pkgName = mod.split('/').pop();
+                        return pkgName === call.receiver;
+                    });
+                    if (importModule) {
+                        // Receiver is an import alias — resolve to definitions from that package
+                        const symbols = index.symbols.get(call.name);
+                        if (symbols) {
+                            // Match by checking if the definition's directory path matches the import path suffix
+                            const importParts = importModule.split('/');
+                            const match = symbols.find(s => {
+                                const sDir = path.dirname(s.relativePath || path.relative(index.root, s.file));
+                                // Try matching progressively shorter suffixes of the import path
+                                for (let i = importParts.length - 1; i >= 0; i--) {
+                                    const suffix = importParts.slice(i).join('/');
+                                    if (sDir === suffix || sDir.endsWith('/' + suffix)) return true;
+                                }
+                                return false;
+                            });
+                            if (match) {
+                                const key = match.bindingId || `${call.receiver}.${call.name}`;
+                                const existing = callees.get(key);
+                                if (existing) {
+                                    existing.count += 1;
+                                } else {
+                                    callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                                }
+                                continue;
+                            }
+                        }
+                    }
                 } else if (language !== 'go' && language !== 'java' && language !== 'rust' && !options.includeMethods) {
                     continue;
                 }
@@ -544,7 +767,23 @@ function findCallees(index, def, options = {}) {
                         // (cross-type ambiguity, e.g. TypeA.Length vs TypeB.Length).
                         const defs = index.symbols.get(call.name);
                         if (defs && defs.length > 1) {
-                            isUncertain = true;
+                            // Go: if receiverType is known, check if it matches exactly one def
+                            // This resolves ambiguity like Framework.Run vs Scheduler.Run
+                            const rType = call.receiverType || localTypes?.get(call.receiver);
+                            if (rType && (language === 'go' || language === 'java' || language === 'rust')) {
+                                const matchingDef = defs.find(d =>
+                                    d.className === rType ||
+                                    (d.receiver && d.receiver.replace(/^\*/, '') === rType));
+                                if (matchingDef) {
+                                    // Resolved to specific type — not uncertain
+                                    calleeKey = matchingDef.bindingId || `${rType}.${call.name}`;
+                                    bindingResolved = matchingDef.bindingId;
+                                } else {
+                                    isUncertain = true;
+                                }
+                            } else {
+                                isUncertain = true;
+                            }
                         }
                     }
                 }
@@ -769,10 +1008,10 @@ function findCallees(index, def, options = {}) {
                             callee = sameDir;
                         } else {
                             // Priority 2.5: Imported file — check if the caller's file imports
-                            // from any of the candidate callee files
-                            const callerImports = fileEntry?.imports || [];
-                            const importedFiles = new Set(callerImports.map(imp => imp.resolvedPath).filter(Boolean));
-                            const importedCallee = symbols.find(s => importedFiles.has(s.file));
+                            // from any of the candidate callee files (using importGraph)
+                            const callerImportedFiles = index.importGraph.get(def.file) || [];
+                            const importedFileSet = new Set(callerImportedFiles);
+                            const importedCallee = symbols.find(s => importedFileSet.has(s.file));
                             if (importedCallee) {
                                 callee = importedCallee;
                             } else if (defReceiver) {
@@ -835,6 +1074,18 @@ function findCallees(index, def, options = {}) {
                     }
                 }
 
+                // Skip non-callable types (interface, struct, type) as callees.
+                // These appear when local variables shadow symbol names
+                // (e.g., `for _, handler := range handlers { handler(r) }` —
+                // handler is a local var, not the handler interface type).
+                // Exception: function-typed fields (e.g., syncHandler func(...))
+                // are callable via Go dependency injection patterns.
+                if (!bindingId && NON_CALLABLE_TYPES.has(callee.type)) {
+                    const isFuncField = callee.type === 'field' && callee.fieldType &&
+                        /^func\b/.test(callee.fieldType);
+                    if (!isFuncField) continue;
+                }
+
                 // Skip test-file callees when caller is production code and
                 // there's no binding (import) evidence linking them
                 if (!callerIsTest && !bindingId) {
@@ -950,6 +1201,53 @@ function _buildLocalTypeMap(index, def, calls) {
     return localTypes.size > 0 ? localTypes : null;
 }
 
+/**
+ * Build a local variable type map for typed languages (Go, Java, Rust)
+ * using parser-inferred receiverType from call objects.
+ * Go also resolves New*() constructor patterns.
+ * @param {object} index - ProjectIndex instance
+ * @param {object} def - Function definition with file, startLine, endLine
+ * @param {Array} calls - Cached call sites for the file
+ */
+function _buildTypedLocalTypeMap(index, def, calls) {
+    const localTypes = new Map();
+
+    for (const call of calls) {
+        if (call.line < def.startLine || call.line > def.endLine) continue;
+
+        // Collect receiverType from method calls (inferred by parser from params/receivers)
+        if (call.isMethod && call.receiver && call.receiverType) {
+            localTypes.set(call.receiver, call.receiverType);
+        }
+
+        // Collect types from constructor calls: x := NewFoo() → x maps to Foo
+        // 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) {
+            let content;
+            try {
+                content = index._readFile(def.file);
+            } catch { continue; }
+            const lines = content.split('\n');
+            const sourceLine = lines[call.line - 1];
+            if (!sourceLine) continue;
+            // Match: x := [pkg.]NewFoo( or x, err := [pkg.]NewFoo( or x, _ := [pkg.]NewFoo(
+            const assignMatch = sourceLine.match(
+                /(\w+)(?:\s*,\s*\w+)?\s*:=\s*(?:\w+\.)?(\w+)\s*\(/
+            );
+            if (assignMatch && /^New[A-Z]/.test(assignMatch[2])) {
+                // NewFoo → Foo, NewFooBar → FooBar
+                const typeName = assignMatch[2].slice(3);
+                if (typeName && /^[A-Z]/.test(typeName)) {
+                    localTypes.set(assignMatch[1], typeName);
+                }
+            }
+        }
+    }
+
+    return localTypes.size > 0 ? localTypes : null;
+}
+
 /**
  * Check if a function is used as a callback anywhere in the codebase
  * @param {object} index - ProjectIndex instance