ucn 3.8.13 → 3.8.15

package/core/callers.js

@@ -8,7 +8,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { detectLanguage, getParser, getLanguageModule } = require('../languages');
+const { detectLanguage, getParser, getLanguageModule, langTraits } = require('../languages');
 const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES } = require('./shared');
 const { scoreEdge } = require('./confidence');
@@ -83,7 +83,7 @@ function getCachedCalls(index, filePath, options = {}) {
         // 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') {
+        if (langTraits(language)?.hasReceiverPackageCalls) {
             const fileEntry = index.files.get(filePath);
             if (fileEntry?.importNames) {
                 callOpts.imports = fileEntry.importNames;
@@ -136,6 +136,7 @@ function findCallers(index, name, options = {}) {
     const pendingByFile = new Map(); // filePath -> [{ call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver }]
     let pendingCount = 0;
     const maxResults = options.maxResults;
+    const localTypeCache = new Map(); // `${filePath}:${startLine}` -> localTypes Map or null
 
     // Use inverted callee index to skip files that don't contain calls to this name
     const calleeFiles = index.getCalleeFiles(name);
@@ -163,7 +164,7 @@ function findCallers(index, name, options = {}) {
 
                     // Go unexported visibility: lowercase functions are package-private.
                     // Only allow callers from the same package directory.
-                    if (fileEntry.language === 'go' && /^[a-z]/.test(name)) {
+                    if (langTraits(fileEntry.language)?.exportVisibility === 'capitalization' && /^[a-z]/.test(name)) {
                         const targetDefs = options.targetDefinitions || definitions;
                         const targetPkgDirs = new Set(
                             targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
@@ -173,9 +174,9 @@ function findCallers(index, name, options = {}) {
                         }
                     }
 
-                    // Go/Java/Rust receiver disambiguation for callbacks (e.g. dc.worker)
+                    // Nominal type receiver disambiguation for callbacks (e.g. dc.worker)
                     if (call.isMethod && call.receiver &&
-                        (fileEntry.language === 'go' || fileEntry.language === 'java' || fileEntry.language === 'rust')) {
+                        langTraits(fileEntry.language)?.typeSystem === 'nominal') {
                         const targetDefs = options.targetDefinitions || definitions;
                         const targetTypes = new Set();
                         for (const td of targetDefs) {
@@ -211,12 +212,16 @@ function findCallers(index, name, options = {}) {
                 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)
-                    if (bindings.length === 0 && fileEntry.language === 'go') {
+                    if (bindings.length === 0 && langTraits(fileEntry.language)?.packageScope === 'directory') {
                         const dir = path.dirname(filePath);
-                        for (const [fp, fe] of index.files) {
-                            if (fp !== filePath && path.dirname(fp) === dir) {
-                                const sibling = (fe.bindings || []).filter(b => b.name === call.name);
-                                bindings = bindings.concat(sibling);
+                        const siblings = index.dirToFiles?.get(dir) || [];
+                        for (const fp of siblings) {
+                            if (fp !== filePath) {
+                                const fe = index.files.get(fp);
+                                if (fe) {
+                                    const sibling = (fe.bindings || []).filter(b => b.name === call.name);
+                                    bindings = bindings.concat(sibling);
+                                }
                             }
                         }
                     }
@@ -278,7 +283,7 @@ function findCallers(index, name, options = {}) {
                     // over-reporting is preferred to losing callers. These languages' nominal
                     // type systems also make method links more reliable.
                     if (bindings.length === 0 && call.isMethod &&
-                        fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
+                        langTraits(fileEntry.language)?.typeSystem === 'structural') {
                         const hasReceiverEvidence = call.receiver &&
                             (fileEntry.bindings || []).some(b => b.name === call.receiver);
                         if (!hasReceiverEvidence) {
@@ -348,7 +353,7 @@ function findCallers(index, name, options = {}) {
                         // Java method calls are always obj.method() - include by default
                         // Rust Type::method() calls - include by default (associated functions)
                         // For other languages, skip method calls unless explicitly requested
-                        if (fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust' && !options.includeMethods) continue;
+                        if (langTraits(fileEntry.language)?.methodCallInclusion === 'explicit' && !options.includeMethods) continue;
                     }
                 }
 
@@ -375,7 +380,7 @@ function findCallers(index, name, options = {}) {
                 // 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') {
+                    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) || [];
@@ -397,7 +402,7 @@ function findCallers(index, name, options = {}) {
 
                 // Go unexported visibility: lowercase functions are package-private.
                 // Only allow callers from the same package directory.
-                if (fileEntry.language === 'go' && /^[a-z]/.test(name)) {
+                if (langTraits(fileEntry.language)?.exportVisibility === 'capitalization' && /^[a-z]/.test(name)) {
                     const targetPkgDirs = new Set(
                         targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
                     );
@@ -412,7 +417,7 @@ function findCallers(index, name, options = {}) {
                 // 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')) {
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal') {
                     const targetHasClass = targetDefs.some(d => d.className);
                     if (call.isMethod && !targetHasClass) {
                         // Method call but target is a standalone function — skip
@@ -424,19 +429,65 @@ function findCallers(index, name, options = {}) {
                     }
                 }
 
+                // Go package-qualified call filter: when a non-method call has a receiver
+                // that is an import alias (e.g., fmt.Errorf()), verify the caller imports
+                // a project file containing the target. Catches stdlib (single-segment imports
+                // like "fmt", "os") and third-party calls (import graph has no edge to target).
+                if (!call.isMethod && call.receiver && !bindingId &&
+                    langTraits(fileEntry.language)?.hasReceiverPackageCalls) {
+                    const callerFileImports = fileEntry.imports || [];
+                    const importModule = callerFileImports.find(mod => {
+                        const parts = mod.split('/');
+                        const last = parts[parts.length - 1];
+                        const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+                        return pkgName === call.receiver;
+                    });
+                    if (importModule) {
+                        if (!importModule.includes('/')) {
+                            // Single-segment import — Go stdlib, always external
+                            continue;
+                        }
+                        // Multi-segment import — verify via import graph
+                        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));
+                            if (!hasImportEdge) {
+                                // No import edge — allow same-package (same directory) calls
+                                const callerDir = path.dirname(filePath);
+                                const samePackage = targetDefs.some(d => d.file && path.dirname(d.file) === callerDir);
+                                if (!samePackage) continue;
+                            }
+                        }
+                    }
+                }
+
                 // Receiver-class disambiguation:
                 // When the target definition has a class/receiver type, filter callers
                 // whose receiverType is known to be a different type.
                 // All languages use receiverType when available (constructor/annotation inference).
                 // Go/Java/Rust additionally fall back to variable name matching.
                 if (call.isMethod && call.receiver && !resolvedBySameClass && !bindingId &&
-                    (call.receiverType || fileEntry.language === 'java' || fileEntry.language === 'go' || fileEntry.language === 'rust')) {
+                    (call.receiverType || langTraits(fileEntry.language)?.typeSystem === 'nominal')) {
                     // 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(/^\*/, ''));
                     }
+                    // Expand targetTypes with types that embed the target (Go/Java/Rust)
+                    // e.g., if target is Base.Start() and Child embeds Base, accept Child.Start() callers
+                    if (targetTypes.size > 0 && langTraits(fileEntry.language)?.typeSystem === 'nominal') {
+                        for (const tt of [...targetTypes]) {
+                            const children = index.extendedByGraph?.get(tt);
+                            if (children) {
+                                for (const child of children) {
+                                    const cName = typeof child === 'string' ? child : child.name;
+                                    if (cName) targetTypes.add(cName);
+                                }
+                            }
+                        }
+                    }
                     if (targetTypes.size > 0) {
                         // Use inferred receiverType when available (Go/Java/Rust parameter type tracking)
                         const knownType = call.receiverType;
@@ -450,32 +501,68 @@ function findCallers(index, name, options = {}) {
                                     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) {
-                                // Rust/Go path calls (Type::method() / pkg.Method()): receiver IS the type name
-                                // If it doesn't match target, it's definitely a different type — filter it
-                                if (call.isPathCall && /^[A-Z]/.test(call.receiver)) {
-                                    isUncertain = true;
-                                    if (!options.includeUncertain) {
-                                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
-                                        continue;
+                        } else {
+                            // No parser-inferred type — try local type inference
+                            // for Go/Java/Rust (nominal type systems)
+                            let inferredMatch = false;
+                            let inferredMismatch = false;
+                            if (langTraits(fileEntry.language)?.typeSystem === 'nominal') {
+                                const callerSym = index.findEnclosingFunction(filePath, call.line, true);
+                                if (callerSym && callerSym.startLine != null && callerSym.endLine != null) {
+                                    const cacheKey = `${filePath}:${callerSym.startLine}`;
+                                    let localTypes = localTypeCache.get(cacheKey);
+                                    if (localTypes === undefined) {
+                                        const callsForFile = getCachedCalls(index, filePath);
+                                        localTypes = callsForFile ? _buildTypedLocalTypeMap(index,
+                                            { file: filePath, startLine: callerSym.startLine, endLine: callerSym.endLine },
+                                            callsForFile) : null;
+                                        localTypeCache.set(cacheKey, localTypes);
+                                    }
+                                    if (localTypes) {
+                                        const inferredType = localTypes.get(call.receiver);
+                                        if (inferredType) {
+                                            if (targetTypes.has(inferredType)) {
+                                                inferredMatch = true;
+                                            } else {
+                                                inferredMismatch = true;
+                                            }
+                                        }
                                     }
                                 }
-                                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);
+                            }
+                            if (inferredMismatch) {
+                                isUncertain = true;
+                                if (!options.includeUncertain) {
+                                    if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                    continue;
                                 }
-                                const matchesOther = [...nonTargetClasses].some(cn => cn.toLowerCase() === receiverLower);
-                                if (matchesOther) {
-                                    isUncertain = true;
-                                    if (!options.includeUncertain) {
-                                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
-                                        continue;
+                            }
+                            // Still no type — fall back to receiver name matching when multiple defs exist
+                            if (!inferredMatch && !inferredMismatch && definitions.length > 1) {
+                                const receiverLower = call.receiver.toLowerCase();
+                                const matchesTarget = [...targetTypes].some(cn => cn.toLowerCase() === receiverLower);
+                                if (!matchesTarget) {
+                                    // Rust/Go path calls (Type::method() / pkg.Method()): receiver IS the type name
+                                    // If it doesn't match target, it's definitely a different type — filter it
+                                    if (call.isPathCall && /^[A-Z]/.test(call.receiver)) {
+                                        isUncertain = true;
+                                        if (!options.includeUncertain) {
+                                            if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                            continue;
+                                        }
+                                    }
+                                    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;
+                                        }
                                     }
                                 }
                             }
@@ -515,7 +602,7 @@ function findCallers(index, name, options = {}) {
                             // Method calls where binding resolution was skipped (non-self receiver)
                             // and the receiver has no binding evidence → uncertain (JS/TS/Python only)
                             skipLocalBinding && call.isMethod && !resolvedBySameClass &&
-                            fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust' &&
+                            langTraits(fileEntry.language)?.typeSystem === 'structural' &&
                             !(call.receiver && (fileEntry.bindings || []).some(b => b.name === call.receiver))
                         ),
                         hasReceiverType: !!call.receiverType,
@@ -604,9 +691,9 @@ function findCallees(index, def, options = {}) {
         // Build local variable type map for receiver resolution
         // Scans for patterns like: bt = Backtester(...) → bt maps to Backtester
         let localTypes = null;
-        if (language === 'python' || language === 'javascript') {
+        if (langTraits(language)?.typeSystem === 'structural') {
             localTypes = _buildLocalTypeMap(index, def, calls);
-        } else if (language === 'go' || language === 'java' || language === 'rust') {
+        } else if (langTraits(language)?.typeSystem === 'nominal') {
             localTypes = _buildTypedLocalTypeMap(index, def, calls);
         }
 
@@ -644,10 +731,23 @@ function findCallees(index, def, options = {}) {
                     const symbols = index.symbols.get(call.name);
                     const isCallable = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
                         (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
-                    const match = symbols?.find(s =>
+                    let match = symbols?.find(s =>
                         isCallable(s) && (
                         s.className === typeName ||
                         (s.receiver && s.receiver.replace(/^\*/, '') === typeName)));
+                    // Walk embedding/inheritance chain if no direct match (nominal type systems)
+                    if (!match && langTraits(language)?.typeSystem === 'nominal') {
+                        const parentNames = index._getInheritanceParents?.(typeName, def.file);
+                        if (parentNames) {
+                            for (const pName of parentNames) {
+                                match = symbols?.find(s =>
+                                    isCallable(s) && (
+                                    s.className === pName ||
+                                    (s.receiver && s.receiver.replace(/^\*/, '') === pName)));
+                                if (match) break;
+                            }
+                        }
+                    }
                     if (match) {
                         const key = match.bindingId || `${typeName}.${call.name}`;
                         const existing = callees.get(key);
@@ -667,10 +767,23 @@ function findCallees(index, def, options = {}) {
                     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 =>
+                    let match = symbols?.find(s =>
                         isCallableRT(s) && (
                         (s.receiver && s.receiver.replace(/^\*/, '') === typeName) ||
                         s.className === typeName));
+                    // Walk embedding/inheritance chain if no direct match (nominal type systems)
+                    if (!match && langTraits(language)?.typeSystem === 'nominal') {
+                        const parentNames = index._getInheritanceParents?.(typeName, def.file);
+                        if (parentNames) {
+                            for (const pName of parentNames) {
+                                match = symbols?.find(s =>
+                                    isCallableRT(s) && (
+                                    (s.receiver && s.receiver.replace(/^\*/, '') === pName) ||
+                                    s.className === pName));
+                                if (match) break;
+                            }
+                        }
+                    }
                     if (match) {
                         const key = match.bindingId || `${typeName}.${call.name}`;
                         const existing = callees.get(key);
@@ -682,30 +795,44 @@ function findCallees(index, def, options = {}) {
                         continue;
                     }
                     // No match found with inferred type — fall through to include as unresolved
-                } else if (language === 'go' && call.receiver) {
+                } else if (langTraits(language)?.hasReceiverPackageCalls && 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
+                    // Handle Go version suffixes: k8s.io/klog/v2 → klog, not v2
                     const importModule = goImports.find(mod => {
-                        const pkgName = mod.split('/').pop();
+                        const parts = mod.split('/');
+                        const last = parts[parts.length - 1];
+                        const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
                         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
+                            // Match by checking if the definition's directory path matches the import path suffix.
+                            // Pick the symbol with the LONGEST suffix match to avoid false positives
+                            // (e.g., import "k8s.io/client-go/kubernetes/scheme" should prefer a definition
+                            // in .../client-go/kubernetes/scheme/ over one in .../kubeadm/scheme/).
                             const importParts = importModule.split('/');
-                            const match = symbols.find(s => {
+                            let bestMatch = null;
+                            let bestMatchLen = 0;
+                            for (const s of symbols) {
                                 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--) {
+                                for (let i = 0; i < importParts.length; i++) {
                                     const suffix = importParts.slice(i).join('/');
-                                    if (sDir === suffix || sDir.endsWith('/' + suffix)) return true;
+                                    if (sDir === suffix || sDir.endsWith('/' + suffix)) {
+                                        const matchLen = importParts.length - i;
+                                        if (matchLen > bestMatchLen) {
+                                            bestMatchLen = matchLen;
+                                            bestMatch = s;
+                                        }
+                                        break; // this symbol's best suffix found, try next
+                                    }
                                 }
-                                return false;
-                            });
+                            }
+                            const match = bestMatch;
                             if (match) {
                                 const key = match.bindingId || `${call.receiver}.${call.name}`;
                                 const existing = callees.get(key);
@@ -717,8 +844,10 @@ function findCallees(index, def, options = {}) {
                                 continue;
                             }
                         }
+                        // Import resolved but no project definition matches — external call, skip
+                        continue;
                     }
-                } else if (language !== 'go' && language !== 'java' && language !== 'rust' && !options.includeMethods) {
+                } else if (langTraits(language)?.methodCallInclusion === 'explicit' && !options.includeMethods) {
                     continue;
                 }
             }
@@ -781,7 +910,7 @@ function findCallees(index, def, options = {}) {
             if (!call.bindingId && fileEntry?.bindings) {
                 let bindings = fileEntry.bindings.filter(b => b.name === call.name);
                 // For Go, also check sibling files in same directory (same package scope)
-                if (bindings.length === 0 && language === 'go') {
+                if (bindings.length === 0 && langTraits(language)?.packageScope === 'directory') {
                     const dir = path.dirname(def.file);
                     for (const [fp, fe] of index.files) {
                         if (fp !== def.file && path.dirname(fp) === dir) {
@@ -793,7 +922,7 @@ function findCallees(index, def, options = {}) {
                 // Method call with no binding for the method name:
                 // Different strategies by language family:
                 if (bindings.length === 0 && call.isMethod) {
-                    if (language !== 'go' && language !== 'java' && language !== 'rust') {
+                    if (langTraits(language)?.typeSystem === 'structural') {
                         // JS/TS/Python: mark uncertain unless receiver has import/binding
                         // evidence in file scope AND that binding can plausibly have this method.
                         // Prevents false positives like m.get() → repository.get() when m is
@@ -818,7 +947,7 @@ function findCallees(index, def, options = {}) {
                             // 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')) {
+                            if (rType && langTraits(language)?.typeSystem === 'nominal') {
                                 const matchingDef = defs.find(d =>
                                     d.className === rType ||
                                     (d.receiver && d.receiver.replace(/^\*/, '') === rType));
@@ -840,7 +969,7 @@ function findCallees(index, def, options = {}) {
                     // matches the binding's class. Prevents plt.close() → ReportGenerator.close()
                     // when close is defined in the same file as a class method.
                     if (call.isMethod && call.receiver && bindings[0].type === 'method' &&
-                        language !== 'go' && language !== 'java' && language !== 'rust') {
+                        langTraits(language)?.typeSystem === 'structural') {
                         // The binding is a class method — check if the receiver could be an instance
                         const bindingSym = index.symbols.get(call.name)?.find(
                             s => s.bindingId === bindings[0].id);
@@ -1269,6 +1398,7 @@ function _buildLocalTypeMap(index, def, calls) {
  */
 function _buildTypedLocalTypeMap(index, def, calls) {
     const localTypes = new Map();
+    let _cachedLines = null;
 
     for (const call of calls) {
         if (call.line < def.startLine || call.line > def.endLine) continue;
@@ -1282,12 +1412,12 @@ 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) {
-            let content;
-            try {
-                content = index._readFile(def.file);
-            } catch { continue; }
-            const lines = content.split('\n');
-            const sourceLine = lines[call.line - 1];
+            if (!_cachedLines) {
+                try {
+                    _cachedLines = index._readFile(def.file).split('\n');
+                } catch { continue; }
+            }
+            const sourceLine = _cachedLines[call.line - 1];
             if (!sourceLine) continue;
             // Match: x := [pkg.]NewFoo( or x, err := [pkg.]NewFoo( or x, _ := [pkg.]NewFoo(
             const assignMatch = sourceLine.match(

package/core/deadcode.js

@@ -5,9 +5,8 @@
  * as the first argument instead of using `this`.
  */
 
-const { detectLanguage, getParser, getLanguageModule, safeParse } = require('../languages');
+const { detectLanguage, getParser, getLanguageModule, safeParse, langTraits } = require('../languages');
 const { isTestFile } = require('./discovery');
-const { escapeRegExp } = require('./shared');
 const { isFrameworkEntrypoint } = require('./entrypoints');
 
 /** Check if a position in a line is inside a string literal (quotes/backticks) */
@@ -206,13 +205,27 @@ function deadcode(index, options = {}) {
     }
 
     // Pre-filter: names in the callee index have call sites → definitely used → not dead.
-    const potentiallyDeadNames = new Set();
+    let potentiallyDeadNames = new Set();
     for (const name of callableNames) {
         if (!index.calleeIndex.has(name)) {
             potentiallyDeadNames.add(name);
         }
     }
 
+    // When --file is provided, pre-filter to only names of symbols in the target scope.
+    // The text scan below is O(potentiallyDeadNames × files) — narrowing the name set
+    // avoids scanning all files for names that will be filtered out at the result stage.
+    if (options.file) {
+        const filteredNames = new Set();
+        for (const name of potentiallyDeadNames) {
+            const syms = index.symbols.get(name) || [];
+            if (syms.some(s => s.relativePath && s.relativePath.includes(options.file))) {
+                filteredNames.add(name);
+            }
+        }
+        potentiallyDeadNames = filteredNames;
+    }
+
     // Build usage index for potentially dead names using text scan (no tree-sitter reparsing).
     // The callee index already covers all call-based usages. For remaining names, a word-boundary
     // text scan catches imports, exports, shorthand properties, type refs, and variable refs.
@@ -267,7 +280,7 @@ function deadcode(index, options = {}) {
                         }
                     }
                 }
-            } catch {}
+            } catch { /* skip unreadable files */ }
         }
     }
 
@@ -305,67 +318,10 @@ function deadcode(index, options = {}) {
 
             const mods = symbol.modifiers || [];
 
-            // Language-specific entry points (called by runtime, no AST-visible callers)
-            // Go: main() and init() are called by runtime
-            const isGoEntryPoint = lang === 'go' && (name === 'main' || name === 'init');
-
-            // Java: public static void main(String[] args) is the entry point
-            const isJavaEntryPoint = lang === 'java' && name === 'main' &&
-                mods.includes('public') && mods.includes('static');
-
-            // Python: Magic/dunder methods are called by the interpreter, not user code
-            // test_* functions/methods are called by pytest/unittest via reflection
-            // setUp/tearDown are unittest.TestCase framework methods called by test runner
-            // pytest_* are pytest plugin hooks called by the framework
-            const isPythonEntryPoint = lang === 'python' &&
-                (/^__\w+__$/.test(name) || /^test_/.test(name) ||
-                 /^(setUp|tearDown)(Class|Module)?$/.test(name) ||
-                 /^pytest_/.test(name));
-
-            // Rust: main() is entry point, #[test] and #[bench] functions are called by test/bench runner
-            const isRustEntryPoint = lang === 'rust' &&
-                (name === 'main' || mods.includes('test') || mods.includes('bench'));
-
-            // Rust: trait impl methods are invoked via trait dispatch, not direct calls
-            // They can never be "dead" - the trait contract requires them to exist
-            const isRustTraitImpl = lang === 'rust' && symbol.isMethod &&
-                symbol.className && symbol.traitImpl;
-
-            // Go: Test*, Benchmark*, Example* functions are called by go test
-            const isGoTestFunc = lang === 'go' &&
-                /^(Test|Benchmark|Example)[A-Z]/.test(name);
-
-            // Java: @Test annotated methods are called by JUnit
-            const isJavaTestMethod = lang === 'java' && mods.includes('test');
-
-            // Java: @Override methods are invoked via polymorphic dispatch
-            // They implement interface/superclass contracts and can't be dead
-            const isJavaOverride = lang === 'java' && mods.includes('override');
-
-            // Skip trait impl / @Override methods entirely - they're required by the type system
-            if (isRustTraitImpl || isJavaOverride) {
-                continue;
-            }
-
-            // JavaScript/TypeScript: framework lifecycle methods called by runtime
-            // React class components, Web Components, Angular, Vue
-            const jsLifecycleMethods = new Set([
-                // React class component lifecycle
-                'render', 'componentDidMount', 'componentDidUpdate', 'componentWillUnmount',
-                'getDerivedStateFromProps', 'getDerivedStateFromError', 'componentDidCatch',
-                'getSnapshotBeforeUpdate', 'shouldComponentUpdate',
-                // Web Components lifecycle
-                'connectedCallback', 'disconnectedCallback', 'attributeChangedCallback', 'adoptedCallback'
-            ]);
-            const isJsEntryPoint = (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') &&
-                symbol.isMethod && jsLifecycleMethods.has(name);
-
-            const isEntryPoint = isGoEntryPoint || isGoTestFunc ||
-                isJavaEntryPoint || isJavaTestMethod ||
-                isPythonEntryPoint || isRustEntryPoint || isJsEntryPoint;
-
-            // Entry points are always excluded — they're invoked by the runtime, not user code
-            if (isEntryPoint) {
+            // Language-specific entry points (called by runtime/test runner, not user code)
+            // Each language module declares its own isEntryPoint() rules.
+            const langModule = getLanguageModule(lang);
+            if (langModule.isEntryPoint?.(symbol)) {
                 continue;
             }
 
@@ -384,7 +340,7 @@ function deadcode(index, options = {}) {
                 fileEntry.exports.includes(name) ||
                 mods.includes('export') ||
                 mods.includes('public') ||
-                (lang === 'go' && /^[A-Z]/.test(name))
+                (langTraits(lang)?.exportVisibility === 'capitalization' && /^[A-Z]/.test(name))
             );
 
             // Skip exported unless requested