ucn 5.6.0 → 5.6.1

package/core/reflection.js

@@ -24,8 +24,9 @@
  * memoized on the index and reset with it.
  */
 
-const { langTraits } = require('../languages');
+const { langTraits, detectLanguage } = require('../languages');
 const { sameNode } = require('../languages/utils');
+const { pythonPossibleIdentities, pythonSourceName } = require('./python-binding-identity');
 
 const WILD = '\u0000*';
 const MODULE_RECEIVER = Object.freeze({ kind: 'module' });
@@ -153,7 +154,13 @@ function _stringLiteral(node) {
 function stringAlternatives(node, ctx, depth = 0) {
     node = _unwrap(node);
     if (!node || depth > 12) return null;
-    if (STRING_NODES.has(node.type)) return _stringLiteral(node);
+    if (STRING_NODES.has(node.type)) {
+        const literal = ctx?.language === 'python'
+            ? require('./runtime-entrypoints').pythonStringLiteral(node)
+            : ['javascript', 'typescript', 'tsx', 'html'].includes(ctx?.language)
+                ? require('../languages/static-js').jsString(node) : null;
+        return literal != null ? [[literal]] : _stringLiteral(node);
+    }
     switch (node.type) {
         case 'concatenated_string': {
             let acc = [[]];
@@ -835,7 +842,7 @@ function reflectionFactsInTree(tree, language, code = null, options = {}) {
     const api = traits.reflectionApi;
     if (!api || !tree) return facts;
     const resolve = makeResolver();
-    const ctx = { formatCalls: api.formatCalls || null, resolve };
+    const ctx = { formatCalls: api.formatCalls || null, resolve, language };
     const sites = facts.sites;
     const push = (node, kind, nameNode, receiverNode, receiverFact) => {
         const cls = classifyNameExpression(nameNode, ctx);
@@ -876,7 +883,10 @@ function reflectionFactsInTree(tree, language, code = null, options = {}) {
         const { literalNameRegex } = require('./shared');
         hintSources.push(...[...qualifiers.keys()].map(name => literalNameRegex(name).source));
     }
-    const useHints = code != null && hintSources.length > 0;
+    // Aliases can call a reflective API without spelling that API at the call.
+    // Resolve the Python call ASTs whenever its binding vocabulary is present.
+    if (api.pythonBindingIdentity && code != null && !api.hintPattern.test(code.normalize('NFKC'))) return facts;
+    const useHints = !api.pythonBindingIdentity && code != null && hintSources.length > 0;
     const callTypes = constructs.length > 0 ? [...CALL_NODE_TYPES, ...NEW_NODE_TYPES] : CALL_NODE_TYPES;
     const types = [];
     if (!useHints) {
@@ -888,7 +898,7 @@ function reflectionFactsInTree(tree, language, code = null, options = {}) {
     // Qualified callees (`Reflect.get`, a package's functions) need the
     // callee text of member-shaped calls; bare vocabularies (`getattr`)
     // never do.
-    const wantQualified = qualifiers.size > 0 ||
+    const wantQualified = api.pythonBindingIdentity || qualifiers.size > 0 ||
         [...(api.functions || []), ...unnamed, ...codeExecution].some(rule => rule.qualified);
     const visitNode = node => {
         if (node.type === 'subscript_expression') {
@@ -897,6 +907,28 @@ function reflectionFactsInTree(tree, language, code = null, options = {}) {
             // counts; opaque keys stay the computed-dispatch disclosure.
             const index = node.childForFieldName('index');
             const inner = _unwrap(index);
+            const { jsStaticKey, jsConstValue } = require('../languages/static-js');
+            const staticName = jsStaticKey(inner);
+            if (staticName != null) {
+                // This is normal member syntax. The call extractor carries
+                // the exact receiver; reflection keeps value-position access live.
+                if (node.parent?.type !== 'call_expression' || !sameNode(node.parent.childForFieldName('function'), node)) {
+                    sites.push({ kind: 'computed', name: staticName, patterns: [staticName], dynamic: false,
+                        line: node.startPosition.row + 1, expression: node.text.slice(0, EXPRESSION_CAP),
+                        receiver: classifyReceiver(node.childForFieldName('object'), language), membersOnly: true });
+                }
+                return;
+            }
+            const object = node.childForFieldName('object');
+            const construction = object?.type === 'new_expression' ? object : jsConstValue(object, true);
+            const type = construction?.type === 'new_expression' ? construction.childForFieldName('constructor') : null;
+            if (type?.type === 'identifier' && node.parent?.type === 'call_expression' &&
+                sameNode(node.parent.childForFieldName('function'), node)) {
+                sites.push({ kind: 'computed', dynamic: true, dynamicMember: true,
+                    receiver: { kind: 'type', name: type.text }, membersOnly: true,
+                    line: node.startPosition.row + 1, expression: node.text.slice(0, EXPRESSION_CAP) });
+                return;
+            }
             // `registry[type](..)` with `type` a parameter of the enclosing
             // callable dispatches by the name its callers pass (fix #428).
             if (inner?.type === 'identifier' && node.parent?.type === 'call_expression' &&
@@ -930,15 +962,61 @@ function reflectionFactsInTree(tree, language, code = null, options = {}) {
         }
         const call = _calleeParts(node, wantMembers, wantQualified);
         if (!call) return;
+        if (api.pythonBindingIdentity) {
+            const fn = _calleeNode(node.childForFieldName('function'));
+            const identities = pythonPossibleIdentities(fn, scopeMemo);
+            const args = _callArgs(node) || [];
+            const keyword = name => args.find(arg => arg.type === 'keyword_argument' &&
+                pythonSourceName(arg.childForFieldName('name')?.text) === name)?.childForFieldName('value');
+            for (const identity of identities) {
+                const isPatch = identity === 'unittest.mock.patch';
+                const isObjectPatch = identity === 'unittest.mock.patch.object';
+                const isMonkeyPatch = identity === 'pytest.MonkeyPatch.instance.setattr';
+                if (isPatch || isObjectPatch || isMonkeyPatch) {
+                    const positional = args.filter(arg => arg.type !== 'keyword_argument');
+                    const nameNode = positional[0] || keyword('target');
+                    const optional = isPatch || isObjectPatch ? keyword('create')?.type === 'true'
+                        : keyword('raising')?.type === 'false';
+                    const memberNode = positional[1] || keyword(isObjectPatch ? 'attribute' : 'name');
+                    const member = classifyNameExpression(memberNode, ctx);
+                    if (!optional && (isObjectPatch || (isMonkeyPatch && !stringAlternatives(nameNode, ctx))) && member.name) {
+                        facts.reflectionUses++;
+                        push(node, 'runtime-member', memberNode, nameNode);
+                        continue;
+                    }
+                    const alternatives = stringAlternatives(nameNode, ctx);
+                    const target = alternatives?.length === 1 && !alternatives[0].includes(WILD)
+                        ? alternatives[0].join('') : null;
+                    if (!optional && target?.includes('.')) {
+                        const name = target.slice(target.lastIndexOf('.') + 1);
+                        facts.reflectionUses++;
+                        const spellings = new Set([name]);
+                        // A private source member is spelled _Owner__member by
+                        // runtime APIs. The final owner-aware matcher decides it;
+                        // this index must first make its source spelling reachable.
+                        for (let offset = 1; offset < name.length - 1; offset++) {
+                            if (name[offset] === '_' && name[offset + 1] === '_') spellings.add(name.slice(offset));
+                        }
+                        sites.push({ kind: 'runtime-target', name, patterns: [...spellings], dynamic: false,
+                            runtimeTarget: target, line: node.startPosition.row + 1,
+                            expression: String(node.text).slice(0, EXPRESSION_CAP) });
+                    }
+                    continue;
+                }
+            }
+            call.possibleCallees = identities.filter(identity => identity.startsWith('builtins.')).map(identity => identity.slice(9));
+            call.calleeText = call.possibleCallees[0] || '';
+        }
         // Match on the callee spelling first; arguments are read only for a
         // vocabulary hit (most calls in a hinted file are unrelated).
         const calleeText = () => (call.calleeText ??= _calleeName(call.fn));
         for (const rule of api.functions || []) {
-            if (!rule.callee.test(calleeText())) continue;
+            const matched = (call.possibleCallees || [calleeText()]).find(name => rule.callee.test(name));
+            if (!matched) continue;
             const args = _callArgs(node);
             if (args && args[rule.nameArg]) {
                 facts.reflectionUses++;
-                push(node, rule.kind || calleeText().split('.').pop(),
+                push(node, rule.kind || matched.split('.').pop(),
                     args[rule.nameArg], args[rule.receiverArg]);
             }
             return;
@@ -1081,10 +1159,16 @@ function reflectionPatternIndex(index) {
     let entryCount = 0;
     const moduleScoped = new Map();
     const keyParameterSites = [];
+    const dynamicMembers = [];
     for (const [file, sites] of byFile) {
         const fe = index.files.get(file);
         if (!fe) continue;
         for (const site of sites) {
+            if (site.dynamicMember) {
+                dynamicMembers.push({ pattern: '*', file, relativePath: fe.relativePath,
+                    language: fe.language, family: _family(fe.language), site });
+                continue;
+            }
             if (site.receiver?.kind === 'module') {
                 // Bounded to this file's top-level names: a fully dynamic
                 // name reaches every one of them.
@@ -1114,7 +1198,7 @@ function reflectionPatternIndex(index) {
         }
     }
     const result = { byFragment, lengths: [...lengths].sort((a, b) => a - b), entryCount, moduleScoped,
-        keyParameterSites, quoted: new Map(), keyNames: new Map() };
+        keyParameterSites, dynamicMembers, quoted: new Map(), keyNames: new Map() };
     index._reflectionPatternIndex = result;
     return result;
 }
@@ -1130,6 +1214,9 @@ function patternEntriesFor(index, name, language, file = null) {
         }
     }
     const family = language ? _family(language) : null;
+    for (const entry of pidx.dynamicMembers) {
+        if (!family || entry.family === family) out.push(entry);
+    }
     for (const entry of pidx.keyParameterSites) {
         if (family && entry.family !== family) continue;
         if (_keyParameterPasses(index, pidx, entry, name)) out.push({ ...entry, pattern: name });
@@ -1190,6 +1277,7 @@ function _reachesKey(index, fromRef, targetKey, targetName) {
  */
 function reflectionEntryReaches(index, entry, def) {
     const site = entry.site;
+    if (site.runtimeTarget) return require('./runtime-entrypoints').runtimeTargetReaches(index, def, site.runtimeTarget);
     if (site.membersOnly && !def.className && !def.receiver) return false;
     const recv = site.receiver;
     if (!recv) return true;
@@ -1228,8 +1316,9 @@ function reflectionEntryReaches(index, entry, def) {
 
 /** Reaching pattern entries for one definition (sorted file, line). */
 function reflectionPatternReferences(index, def) {
-    const lang = index.files.get(def.file)?.language;
-    const entries = patternEntriesFor(index, def.name, lang, def.file)
+    const lang = index.files.get(def.file)?.language || detectLanguage(def.file, index.root);
+    const runtimeName = langTraits(lang)?.reflectionApi?.pythonBindingIdentity ? pythonSourceName(def.name) : def.name;
+    const entries = patternEntriesFor(index, runtimeName, lang, def.file)
         .filter(entry => reflectionEntryReaches(index, entry, def));
     entries.sort((a, b) => (a.relativePath < b.relativePath ? -1 : a.relativePath > b.relativePath ? 1 : 0) ||
         a.site.line - b.site.line || (a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0));

package/core/registry.js

@@ -160,7 +160,7 @@ const PARAMS = {
         text: 'Comma-separated projection. {valueSets}. Omitted: {defaults}.',
     },
     exclude: { type: 'string', cli: ['--exclude', '--not'], repeat: true, text: 'Comma-separated patterns to exclude (e.g. "test,mock,vendor")' },
-    includeTests: { type: 'boolean', text: 'Include test files in results (excluded when omitted)' },
+    includeTests: { type: 'boolean', text: 'Include test files in the requested view. find includes test definitions by default; set false to omit them.' },
     excludeTests: { type: 'boolean', text: 'Exclude test files: the default for entrypoints (include_tests=true lists them); usages and endpoints list test files unless exclude_tests=true.' },
     includeMethods: {
         type: 'boolean',
@@ -927,7 +927,7 @@ function generateCliParamReference() {
         }
         if (spec.defaults) parts.push(`default: ${defaultsText(param, 'cli').join('; ')}`);
         if (parts.length === 0) continue;
-        const head = `  ${cliFlagsForParam(param)[0]}`.padEnd(19);
+        const head = `  ${cliFlagsForParam(param)[0]} `.padEnd(19);
         lines.push(`${head}${parts[0]}`);
         for (const part of parts.slice(1)) lines.push(`${' '.repeat(19)}${part}`);
     }

package/core/runtime-entrypoints.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { pythonPossibleIdentities, pythonBoundValue, pythonSourceName } = require('./python-binding-identity');
+const { entrypointToml } = require('./entrypoint-toml');
+const OP_ENTRIES = new WeakMap();
+
+/** A runtime module/member path names this declaration, including src layouts. */
+function runtimeTargetReaches(index, symbol, target) {
+    const spelling = target.replace(':', '.').split('[')[0].trim();
+    const relative = path.relative(index.root, symbol.file).split(path.sep).join('/');
+    if (!relative.endsWith('.py')) return false;
+    const module = relative.slice(0, -3).replace(/\/__init__$/, '').replaceAll('/', '.');
+    const mangle = (name, owner) => owner && name.startsWith('__') && !name.endsWith('__') && owner.replace(/^_+/, '')
+        ? `_${owner.replace(/^_+/, '')}${name}` : name;
+    let owners = symbol.runtimeOwnerPath;
+    let unknownOwner = false;
+    if (!Array.isArray(owners)) {
+        // Old/external records may omit nesting. Reconstruct only from a unique
+        // owner; when that owner is absent, preserve the possible suffix.
+        const candidates = (index.symbols.get(symbol.className) || []).filter(def => def.file === symbol.file && def.type === 'class');
+        if (symbol.className && candidates.length === 1) owners = [...(candidates[0].runtimeOwnerPath || []), symbol.className];
+        else { owners = symbol.className ? [symbol.className] : []; unknownOwner = !!symbol.className; }
+    }
+    const normalizedOwners = owners.map(pythonSourceName);
+    const member = [...normalizedOwners.map((name, position) => mangle(name, normalizedOwners[position - 1])),
+        mangle(pythonSourceName(symbol.name), normalizedOwners[normalizedOwners.length - 1])].join('.');
+    if (unknownOwner && spelling.endsWith(`.${mangle(pythonSourceName(symbol.name), pythonSourceName(symbol.className))}`)) {
+        const parts = module.split('.');
+        if (parts.some((_, position) => spelling.startsWith(`${parts.slice(position).join('.')}.`))) return true;
+    }
+    if (!spelling.endsWith(`.${member}`)) return false;
+    const namedModule = spelling.slice(0, -(member.length + 1));
+    return module === namedModule || module.endsWith(`.${namedModule}`);
+}
+
+function literal(node) {
+    node = pythonBoundValue(node);
+    if (!node || node.type !== 'string' || node.namedChildren.some(child => child.type === 'interpolation')) return null;
+    const raw = node.text;
+    const match = /^([rub]*)("""|'''|"|')([\s\S]*)\2$/i.exec(raw);
+    if (!match) return null;
+    if (/r/i.test(match[1])) return match[3];
+    let valid = true;
+    const value = match[3].replace(/\\(U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[0-7]{1,3}|[\s\S])/g, (whole, escape) => {
+        if (/^[0-7]+$/.test(escape)) return String.fromCharCode(parseInt(escape, 8));
+        if (/^[uUx]/.test(escape)) {
+            const code = parseInt(escape.slice(1), 16);
+            if (code <= 0x10ffff) return String.fromCodePoint(code);
+            valid = false; return '';
+        }
+        const simple = { n: '\n', r: '\r', t: '\t', '"': '"', "'": "'", '\\': '\\', '\n': '' };
+        if (Object.hasOwn(simple, escape)) return simple[escape];
+        valid = false; return whole;
+    });
+    return valid ? value : null;
+}
+
+function targetOf(value) {
+    const candidate = value.includes('=') ? value.slice(value.lastIndexOf('=') + 1).trim() : value.trim();
+    return /^[\p{L}_][\p{L}\p{N}_.]*\s*:\s*[\p{L}_][\p{L}\p{N}_.]*(?:\s*\[[^\]]*\])?$/u.test(candidate)
+        ? candidate.replace(/\s/g, '') : null;
+}
+
+/** Static packaging declarations, read as data; setup.py is never executed. */
+function runtimeEntrypoints(index) {
+    const operation = index._opTreeCache;
+    if (operation && OP_ENTRIES.has(operation)) return OP_ENTRIES.get(operation);
+    const dirs = new Set();
+    for (const [file, entry] of index.files) {
+        if (entry.language !== 'python') continue;
+        for (let dir = path.dirname(file); dir === index.root || dir.startsWith(`${index.root}${path.sep}`); dir = path.dirname(dir)) {
+            dirs.add(dir);
+            if (dir === index.root) break;
+        }
+    }
+    const entries = [];
+    const add = (value, file, line) => {
+        const target = targetOf(value);
+        entries.push(target ? { target, file, line } : { unknown: true, file, line });
+    };
+    for (const dir of [...dirs].sort()) {
+        for (const basename of ['pyproject.toml', 'setup.cfg']) {
+            const file = path.join(dir, basename);
+            let source;
+            try { source = fs.readFileSync(file, 'utf8'); } catch { continue; }
+            if (basename === 'pyproject.toml') {
+                for (const row of entrypointToml(source)) {
+                    if (row.unknown) entries.push({ unknown: true, file, line: row.line });
+                    else add(row.value, file, row.line);
+                }
+                continue;
+            }
+            let section = '';
+            const lines = source.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i].trim();
+                const header = /^\[([^\]]+)\]/.exec(line);
+                if (header) { section = header[1]; continue; }
+                if (section === 'options.entry_points' && line && !line.startsWith('#') && !line.startsWith(';') &&
+                    !/^[\w.-]+\s*=\s*$/.test(line)) add(line, file, i + 1);
+            }
+        }
+        const setup = path.join(dir, 'setup.py');
+        if (!index.files.has(setup)) continue;
+        let tree;
+        try { tree = index._getParsedTree(setup, index._readFile(setup), 'python'); } catch { continue; }
+        for (const call of tree.rootNode.descendantsOfType('call')) {
+            if (!pythonPossibleIdentities(call.childForFieldName('function')).some(name => ['setuptools.setup', 'distutils.core.setup'].includes(name))) continue;
+            const unknown = () => entries.push({ unknown: true, file: setup, line: call.startPosition.row + 1 });
+            const values = [];
+            const expanded = (node, depth = 0) => {
+                const value = pythonBoundValue(node);
+                if (depth > 8 || value?.type !== 'dictionary') { unknown(); return; }
+                for (const pair of value.namedChildren) {
+                    if (pair.type === 'dictionary_splat') { expanded(pair.namedChild(0), depth + 1); continue; }
+                    if (pair.type !== 'pair') { unknown(); continue; }
+                    const key = literal(pair.childForFieldName('key'));
+                    if (key == null) unknown();
+                    else if (key === 'entry_points') values.push(pair.childForFieldName('value'));
+                }
+            };
+            for (const argument of call.childForFieldName('arguments')?.namedChildren || []) {
+                if (argument.type === 'keyword_argument' && pythonSourceName(argument.childForFieldName('name')?.text) === 'entry_points') values.push(argument.childForFieldName('value'));
+                else if (argument.type === 'dictionary_splat') expanded(argument.namedChild(0));
+            }
+            for (const expression of values) {
+                const value = pythonBoundValue(expression);
+                if (value?.type === 'none') continue;
+                // setuptools also accepts an INI string as entry_points.
+                const ini = literal(value);
+                if (ini != null) {
+                    for (const line of ini.split('\n')) {
+                        const row = line.trim();
+                        if (row && !row.startsWith('[') && !row.startsWith('#')) add(row, setup, call.startPosition.row + 1);
+                    }
+                    continue;
+                }
+                if (value?.type !== 'dictionary') { unknown(); continue; }
+                for (const pair of value.namedChildren) {
+                    if (pair.type !== 'pair' || literal(pair.childForFieldName('key')) == null) { unknown(); continue; }
+                    const group = pythonBoundValue(pair.childForFieldName('value'));
+                    const rows = ['list', 'tuple'].includes(group?.type) ? group.namedChildren : [group];
+                    for (const row of rows) {
+                        const text = literal(row);
+                        if (text != null) {
+                            for (const line of text.split('\n').filter(line => line.trim())) add(line, setup, row.startPosition.row + 1);
+                        } else unknown();
+                    }
+                }
+            }
+        }
+    }
+    if (operation) OP_ENTRIES.set(operation, entries);
+    return entries;
+}
+
+module.exports = { runtimeEntrypoints, runtimeTargetReaches, pythonStringLiteral: literal };

package/core/search.js

@@ -18,7 +18,7 @@ const isSafeRegex = require('safe-regex2');
 const { RE2JS } = require('re2js');
 const { UcnError } = require('./errors');
 const { paramValues } = require('./registry');
-const { createTestModel, addTestCaseRows, linkFiles } = require('./test-units');
+const { createTestModel, addTestCaseRows, linkFiles, testSite, testSiteKey } = require('./test-units');
 
 // Keep the established search-input contract for the canonical catastrophic
 // nested-single-atom family even though the RE2-compatible engine could run it
@@ -208,14 +208,18 @@ function _applyFindFilters(index, matches, options) {
 
     // Rank cheaply before adjudicating callers. A broad inventory must never
     // pay for pinned caller resolution on rows the caller will not receive.
+    const definitionOrder = (a, b) =>
+        (b._fuzzyScore || 0) - (a._fuzzyScore || 0) ||
+        Number(isTestFile(a.relativePath || '', a.language)) -
+            Number(isTestFile(b.relativePath || '', b.language)) ||
+        codeUnitCompare(a.relativePath || '', b.relativePath || '') ||
+        a.startLine - b.startLine || codeUnitCompare(a.name, b.name);
     const ranked = filtered.map(symbol => ({
         symbol, counts: index.countSymbolUsages(symbol),
     }));
     if (options.limit > 0 && ranked.length > options.limit) {
         ranked.sort((a, b) => b.counts.total - a.counts.total ||
-            codeUnitCompare(a.symbol.relativePath || '', b.symbol.relativePath || '') ||
-            a.symbol.startLine - b.symbol.startLine ||
-            codeUnitCompare(a.symbol.name, b.symbol.name));
+            definitionOrder(a.symbol, b.symbol));
     }
     const survivors = options.limit > 0 ? ranked.slice(0, options.limit) : ranked;
     const withCounts = survivors.map(({ symbol: m, counts }) => {
@@ -257,7 +261,7 @@ function _applyFindFilters(index, matches, options) {
     });
 
     // Sort by usage count (most-used first)
-    withCounts.sort((a, b) => b.usageCount - a.usageCount);
+    withCounts.sort((a, b) => b.usageCount - a.usageCount || definitionOrder(a, b));
 
     return withCounts;
 }
@@ -1328,7 +1332,7 @@ function tests(index, nameOrFile, options = {}) {
     let sourceFileFilter = null;
     let targetDefs = [];
     if (options.file && !isFilePath) {
-        targetDefs = index.find(nameOrFile, { exact: true, file: options.file, className: options.className });
+        targetDefs = index.find(nameOrFile, { exact: true, file: options.file, className: options.className, skipCounts: true });
         if (targetDefs.length > 0) {
             sourceFileFilter = _buildSourceFileImporters(index, targetDefs);
         }
@@ -1336,12 +1340,11 @@ function tests(index, nameOrFile, options = {}) {
         // The execute handler validates before calling, so this path means
         // the file matched but no exact symbol — fall through gracefully.
     } else if (!isFilePath) {
-        targetDefs = index.find(nameOrFile, { exact: true, className: options.className });
+        targetDefs = index.find(nameOrFile, { exact: true, className: options.className, skipCounts: true });
     }
     // A pinned definition among same-name ones (an overload, a constructor
     // beside its class and siblings, fix #430): calls are this definition's
     // only when the caller engine attributes them to it.
-    const pinnedFamily = !isFilePath && options.definition && targetDefs.length > 1;
     if (!isFilePath && options.definition) targetDefs = [options.definition];
 
     // Find all test files
@@ -1381,6 +1384,30 @@ function tests(index, nameOrFile, options = {}) {
     const searchTerm = isFilePath
         ? path.basename(nameOrFile, path.extname(nameOrFile))
         : nameOrFile;
+    const callerSites = [];
+    const excludedCallableLines = new Map();
+    const globallyUniqueTarget = !isFilePath && targetDefs.length === 1;
+    if (!isFilePath) for (const def of targetDefs) {
+        const raw = index.findCallers(searchTerm, {
+            targetDefinitions: [def], collectAccount: true, unverifiedEnrichLimit: Infinity,
+        });
+        callerSites.push(
+            ...raw.map(site => ({ ...site, _testEvidenceTier: 'confirmed' })),
+            ...(globallyUniqueTarget ? (raw.unverifiedEntries || []).map(site => ({
+                ...site, _testEvidenceTier: 'unverified',
+            })) : []),
+        );
+        const counted = new Set();
+        for (const site of raw.accountRaw?.excludedEntries || []) {
+            const key = `${site.file}:${site.line}`;
+            if (counted.has(key)) continue;
+            counted.add(key);
+            let lines = excludedCallableLines.get(site.file);
+            if (!lines) { lines = new Map(); excludedCallableLines.set(site.file, lines); }
+            lines.set(site.line, (lines.get(site.line) || 0) + 1);
+        }
+    }
+    const acceptedCallableLines = new Set(callerSites.map(site => `${site.file}:${site.line}`));
 
     // File-path target: module specifiers are string literals, so the
     // basename usage scan is blind to import-linked tests in JS/TS
@@ -1420,7 +1447,7 @@ function tests(index, nameOrFile, options = {}) {
                 targetDefinitions: [def],
                 collectAccount: true,
             });
-            const globallyUnique = index.find(def.name, { exact: true }).length === 1;
+            const globallyUnique = index.symbols.get(def.name)?.length === 1;
             const sites = [
                 ...raw.map(site => ({ ...site, _testEvidenceTier: 'confirmed' })),
                 ...(globallyUnique ? (raw.unverifiedEntries || []).map(site => ({
@@ -1558,7 +1585,18 @@ function tests(index, nameOrFile, options = {}) {
                 // own definition (fix #246).
                 if (localShadow && !usage.receiver && usage.usageType !== 'import') continue;
 
-                if (pinnedFamily && usage.usageType === 'call') continue;
+                // File eligibility only discovers candidates. A call's
+                // spelling does not establish which declaration it reaches;
+                // exact-target caller evidence below owns every call row.
+                if (targetDefs.length > 0 && usage.usageType === 'call') continue;
+                const classBodyProof = !usage.receiver && usage.usageType === 'reference' &&
+                    classBodyReferenceTargets(index, testPath, entry.language, usage, targetDefs);
+                // Method/function values are caller candidates too. A file
+                // importing any sibling cannot resurrect a reference the
+                // engine attributed to another declaration.
+                if (usage.usageType !== 'import' &&
+                    excludedCallableLines.get(testPath)?.get(usage.line) === targetDefs.length &&
+                    !acceptedCallableLines.has(`${testPath}:${usage.line}`) && !classBodyProof) continue;
                 // A line is claimed only by a usage that is recorded: two
                 // same-kind tokens on one line (`a.m = b.m`) are judged
                 // separately, so a rejected first token never hides a
@@ -1644,6 +1682,7 @@ function tests(index, nameOrFile, options = {}) {
                         const nmUsages = index._getCachedUsages(testPath, nm) || [];
                         for (const u of nmUsages) {
                             if (u.usageType === 'definition' || u.usageType === 'import') continue;
+                            if (u.usageType === 'call') continue; // exact file-target evidence below
                             if (testRanges && !lineInRanges(u.line, testRanges)) continue;
                             const lineKey = `${u.line}:${u.usageType}:${nm}`;
                             if (seenLines.has(lineKey)) continue;
@@ -1667,9 +1706,9 @@ function tests(index, nameOrFile, options = {}) {
                 const matchType = site._testEvidenceTier === 'confirmed'
                     ? 'call'
                     : 'unverified-call';
-                if (matches.some(m => m.line === site.line && m.matchType === matchType)) continue;
+                if (matches.some(m => testSiteKey(m) === testSiteKey(site) && m.matchType === matchType)) continue;
                 matches.push({
-                    line: site.line,
+                    ...testSite(site),
                     content: (site.content || index.getLineContent(testPath, site.line) || '').trim(),
                     matchType,
                     evidenceTier: site._testEvidenceTier,
@@ -1712,35 +1751,18 @@ function tests(index, nameOrFile, options = {}) {
         }
     }
 
-    // Compiler-shaped caller supplement (trust command arm): the literal
-    // usage scan above is excellent for imports/type/string references, but
-    // receiver aliases and re-exported module calls are owned by the caller
-    // engine. Merge its CONFIRMED exact-target test sites so `tests` cannot
-    // miss calls that `about`/`impact` already know about. For a globally
+    // Callable test links use the caller engine's exact-target decisions,
+    // including aliases and function values that do not spell the target's
+    // name. The literal scan contributes imports/type/string references,
+    // never an independent call identity. For a globally
     // unique callable name, also retain account-unverified sites under the
     // explicit `unverified-call` label: independent compiler/LSP evaluation
     // shows these contain real interface/trait dispatch that a test-discovery
     // command must not silently drop. Repeated names never receive that broad
     // supplement because it would leak sibling classes/files.
     if (!isFilePath && targetDefs.length > 0) {
-        const callerSites = [];
         // A pinned definition's unverified sites were adjudicated against it
         // alone, like a globally unique name's (fix #430).
-        const globallyUniqueTarget = !!options.definition || index.find(searchTerm, { exact: true }).length === 1;
-        for (const def of targetDefs) {
-            const raw = index.findCallers(searchTerm, {
-                targetDefinitions: [def],
-                collectAccount: true,
-            });
-            callerSites.push(
-                ...raw.map(c => ({ ...c, _testEvidenceTier: 'confirmed' })),
-                ...(globallyUniqueTarget ? (raw.unverifiedEntries || []).map(c => ({
-                    ...c,
-                    _testEvidenceTier: 'unverified',
-                })) : []),
-            );
-        }
-
         for (const site of callerSites) {
             const info = testInfoOf(site.file);
             if (!info) continue;
@@ -1771,12 +1793,12 @@ function tests(index, nameOrFile, options = {}) {
                 fileResult = { file: info.entry.relativePath, matches: [] };
                 results.push(fileResult);
             }
-            if (fileResult.matches.some(m => m.line === site.line &&
+            if (fileResult.matches.some(m => testSiteKey(m) === testSiteKey(site) &&
                 ['call', 'unverified-call'].includes(m.matchType))) continue;
             fileResult.matches = fileResult.matches.filter(m =>
                 !(m.line === site.line && m.matchType === 'test-case'));
             fileResult.matches.push({
-                line: site.line,
+                ...testSite(site),
                 content: (site.content || index.getLineContent(site.file, site.line) || '').trim(),
                 matchType: site._testEvidenceTier === 'confirmed' ? 'call' : 'unverified-call',
                 evidenceTier: site._testEvidenceTier,
@@ -1871,7 +1893,7 @@ function tests(index, nameOrFile, options = {}) {
             titleNeedsMatch: !!className,
         });
         linesByFile.set(testPath,
-            fileResult.matches.filter(match => match.matchType !== 'import').map(match => match.line));
+            fileResult.matches.filter(match => match.matchType !== 'import'));
     }
     // A test a class inherits runs where the class is: the file of a class
     // that inherits a linked test is a result of its own, with the test.
@@ -2261,9 +2283,10 @@ function _deduplicateMatches(matches) {
     const byLine = new Map();
     const priority = { 'test-case': 5, 'call': 4, 'import': 3, 'string-ref': 2, 'reference': 1 };
     for (const m of matches) {
-        const existing = byLine.get(m.line);
+        const key = testSiteKey(m);
+        const existing = byLine.get(key);
         if (!existing || (priority[m.matchType] || 0) > (priority[existing.matchType] || 0)) {
-            byLine.set(m.line, m);
+            byLine.set(key, m);
         }
     }
     return [...byLine.values()].sort((a, b) => a.line - b.line);