ucn 4.0.1 → 4.1.0

package/core/tracing.js

@@ -20,7 +20,7 @@
 'use strict';
 
 const path = require('path');
-const { escapeRegExp } = require('./shared');
+const { escapeRegExp, codeUnitCompare, inlineTestRanges, lineInRanges, classDispatchNames } = require('./shared');
 const { isTestFile } = require('./discovery');
 const { getCachedCalls } = require('./callers');
 const { detectLanguage, getLanguageModule } = require('../languages');
@@ -61,9 +61,9 @@ function _contractCallers(index, funcDef, { includeMethods, callerCache, pin })
 function _sortFrontier(frontier) {
     frontier.sort((a, b) =>
         (a.hop - b.hop) ||
-        (a.atNode.file || '').localeCompare(b.atNode.file || '') ||
+        codeUnitCompare((a.atNode.file || ''), b.atNode.file || '') ||
         ((a.atNode.line || 0) - (b.atNode.line || 0)) ||
-        (a.relativePath || '').localeCompare(b.relativePath || '') ||
+        codeUnitCompare((a.relativePath || ''), b.relativePath || '') ||
         ((a.line || 0) - (b.line || 0)));
     return frontier;
 }
@@ -126,7 +126,7 @@ function _resolveCallerEntries(index, callers, exclude) {
 
     // Stable sort by file + line
     callerEntries.sort((a, b) =>
-        a.def.file.localeCompare(b.def.file) || a.def.startLine - b.def.startLine
+        codeUnitCompare(a.def.file, b.def.file) || a.def.startLine - b.def.startLine
     );
     return callerEntries;
 }
@@ -330,6 +330,10 @@ function blast(index, name, options = {}) {
         const includeMethods = options.includeMethods ?? true;
         const exclude = options.exclude || [];
         const expandUnverified = !!options.expandUnverified;
+        // Internal (affectedTests): observe which names had their callers
+        // searched and where the confirmed trunk edges sit, without changing
+        // the blast result shape (fix #246).
+        const collect = options._collect || null;
 
         const { def, definitions, warnings } = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
         if (!def) return null;
@@ -393,6 +397,7 @@ function blast(index, name, options = {}) {
                 treeAccount.nodesExpanded++;
                 _aggregateExcluded(treeAccount, raw);
                 if (currentDepth === 0) rootRaw = raw;
+                if (collect && !chainUnverified) collect.onExpand?.(funcDef);
 
                 // Confirmed-tier call sites form the trunk
                 let callers = confirmed;
@@ -403,6 +408,9 @@ function blast(index, name, options = {}) {
                     if (currentDepth === 0) rootFiltered += before - callers.length;
                 }
                 treeAccount.confirmedEdges += callers.length;
+                if (collect && !chainUnverified) {
+                    for (const c of callers) collect.onConfirmed?.(funcDef, c);
+                }
 
                 // Unverified-tier candidates: visible frontier entries,
                 // expanded only under expandUnverified.
@@ -787,7 +795,15 @@ function affectedTests(index, name, options = {}) {
     index._beginOp();
     try {
         const maxDepth = Math.max(0, options.depth ?? 3);
-        // Step 1: confirmed closure via blast (contract mode, no truncation)
+        // Step 1: confirmed closure via blast (contract mode, no truncation).
+        // The collector records, per trunk name, (a) whether the engine
+        // searched its callers and (b) where the confirmed edges sit — the
+        // coverage bands below must agree with that answer instead of
+        // re-deciding it with a text scan (fix #246: the scan credited call
+        // sites the same payload's account excluded, and missed confirmed
+        // edges text can't see — renamed destructure aliases, callback refs).
+        const expandedNames = new Set();
+        const confirmedSitesByName = new Map(); // name → Map(relPath → Set(line))
         const blastResult = index.blast(name, {
             depth: maxDepth,
             file: options.file,
@@ -795,17 +811,37 @@ function affectedTests(index, name, options = {}) {
             all: true,
             exclude: options.exclude,
             includeMethods: options.includeMethods,
+            _collect: {
+                onExpand: (funcDef) => expandedNames.add(funcDef.name),
+                onConfirmed: (funcDef, c) => {
+                    let byFile = confirmedSitesByName.get(funcDef.name);
+                    if (!byFile) { byFile = new Map(); confirmedSitesByName.set(funcDef.name, byFile); }
+                    let lines = byFile.get(c.relativePath);
+                    if (!lines) { lines = new Set(); byFile.set(c.relativePath, lines); }
+                    lines.add(c.line);
+                },
+            },
         });
         if (!blastResult) return null;
 
-        // Step 2: Collect confirmed-affected function names (and node keys)
+        // Step 2: Collect confirmed-affected function names (and node keys).
+        // Also record each name's CLASS identity from the tree — interior
+        // names were scanned bare (post-#239), so a test of a DIFFERENT
+        // class's same-named method got credited as coverage (fix #244:
+        // `asyncio.run(...)` credited as covering Mgr.run).
         const affectedNames = new Set();
         const confirmedKeys = new Set();
+        const nameToClasses = new Map(); // name → Set(className|null)
         affectedNames.add(name);
         const collectNames = (node) => {
             if (!node) return;
             affectedNames.add(node.name);
             confirmedKeys.add(`${node.file}:${node.line}`);
+            const defs = index.symbols.get(node.name);
+            const d = defs?.find(x => x.relativePath === node.file && x.startLine === node.line);
+            let set = nameToClasses.get(node.name);
+            if (!set) { set = new Set(); nameToClasses.set(node.name, set); }
+            set.add(d?.className || null);
             for (const child of node.children || []) collectNames(child);
         };
         collectNames(blastResult.tree);
@@ -817,6 +853,10 @@ function affectedTests(index, name, options = {}) {
         const excludeArr = exclude ? (Array.isArray(exclude) ? exclude : [exclude]) : [];
         const includeMethods = options.includeMethods ?? true;
         const possiblyNames = new Set();
+        // Test FILES containing an unverified call site of an affected name
+        // (relativePath → funcName → Set(lines)) — merged into
+        // possiblyAffectedTests after the scan (fix #244).
+        const frontierTestHits = new Map();
         {
             const callerCache = new Map();
             const possibleVisited = new Set();
@@ -840,6 +880,47 @@ function affectedTests(index, name, options = {}) {
             };
             for (const fe of blastResult.unverifiedFrontier || []) {
                 enqueueCaller(fe, fe.hop);
+                // A frontier caller that is ITSELF a test function landed in
+                // neither band (fix #244, the unittest setUp idiom):
+                // isProductionName filters it from possiblyAffected, and the
+                // test scan greps for calls OF it — tests are never called.
+                // Route its FILE into possiblyAffectedTests directly.
+                // Anonymous test callbacks (`it('...', () => { x.save() })`)
+                // have no enclosing NAMED caller at all — the site's file is
+                // still test evidence, so route by the site file whenever it
+                // is a test file (fix #246; the caller-file and site file are
+                // the same file by construction when both exist).
+                const siteFile = fe.callerFile || fe.file;
+                if (siteFile) {
+                    const cfe = index.files.get(siteFile);
+                    if (cfe) {
+                        let isTestCaller = isTestFile(cfe.relativePath, cfe.language);
+                        if (!isTestCaller && fe.callerName) {
+                            const defs = index.symbols.get(fe.callerName);
+                            const d = defs?.find(x => x.file === fe.callerFile && x.startLine === fe.callerStartLine);
+                            const kindOf = getLanguageModule(cfe.language)?.getEntryPointKind;
+                            if (d && kindOf && kindOf(d) === 'test') isTestCaller = true;
+                        }
+                        if (!isTestCaller && fe.line != null) {
+                            // Inline #[cfg(test)] regions of production files
+                            // are test code too — but only within the ranges.
+                            const ranges = inlineTestRanges(cfe);
+                            if (ranges.length > 0 && lineInRanges(fe.line, ranges)) isTestCaller = true;
+                        }
+                        if (isTestCaller &&
+                            (excludeArr.length === 0 || index.matchesFilters(cfe.relativePath, { exclude: excludeArr }))) {
+                            const affName = fe.atNode?.name || name;
+                            let entry = frontierTestHits.get(siteFile);
+                            if (!entry) {
+                                entry = { rel: cfe.relativePath, byName: new Map() };
+                                frontierTestHits.set(siteFile, entry);
+                            }
+                            let hitLines = entry.byName.get(affName);
+                            if (!hitLines) { hitLines = new Set(); entry.byName.set(affName, hitLines); }
+                            if (fe.line != null) hitLines.add(fe.line);
+                        }
+                    }
+                }
             }
             while (queue.length > 0) {
                 const { def: d, depth } = queue.shift();
@@ -866,14 +947,20 @@ function affectedTests(index, name, options = {}) {
         const results = [];
         const possibleResults = [];
         const scanNames = [...affectedNames, ...possiblyNames];
+        const dispatchNamesCache = new Map(); // `${class}:${name}` → Set(classNames)
         for (const [filePath, fileEntry] of index.files) {
             let isTest = isTestFile(fileEntry.relativePath, fileEntry.language);
             // Rust inline #[cfg(test)] modules: source files with #[test]-marked symbols
-            // or symbols inside a #[cfg(test)] mod block (BUG-CY).
+            // or symbols inside a #[cfg(test)] mod block (BUG-CY). Such files
+            // are test code ONLY within the inline test ranges — production
+            // lines were counted as test matches (fix #244, false coverage).
+            let testRanges = null;
             if (!isTest && fileEntry.language === 'rust') {
-                isTest = fileEntry.symbols?.some(s =>
-                    s.modifiers?.includes('test') || s.modifiers?.includes('cfg_test_module')
-                );
+                const ranges = inlineTestRanges(fileEntry);
+                if (ranges.length > 0) {
+                    isTest = true;
+                    testRanges = ranges;
+                }
             }
             if (!isTest) continue;
             if (excludeArr.length > 0 && !index.matchesFilters(fileEntry.relativePath, { exclude: excludeArr })) continue;
@@ -882,22 +969,90 @@ function affectedTests(index, name, options = {}) {
                 const fileMatches = new Map();
 
                 for (const funcName of scanNames) {
+                    // Confirmed trunk edges of this name in THIS file — the
+                    // engine's answer for the sites the text scan is about
+                    // to re-derive (fix #246).
+                    const engineFileSites = confirmedSitesByName.get(funcName)?.get(fileEntry.relativePath) || null;
+                    // Whether the engine searched this name's callers at all
+                    // (depth-limit nodes were never adjudicated — the text
+                    // scan remains their best-effort fallback).
+                    const engineAdjudicated = expandedNames.has(funcName);
+
                     // Fast pre-check
-                    if (!content.includes(funcName)) continue;
+                    if (!content.includes(funcName) && !engineFileSites) continue;
 
                     // AST-based usage detection
-                    const astUsages = index._getCachedUsages(filePath, funcName);
-                    if (!astUsages || astUsages.length === 0) continue;
+                    const astUsages = index._getCachedUsages(filePath, funcName) || [];
+                    if (astUsages.length === 0 && !engineFileSites) continue;
+
+                    // className scoping: the user's pin applies to the ROOT
+                    // symbol's own name only (fix #239, G3-go-measured) — a
+                    // bare call to a standalone wrapper (SaveAll) can never
+                    // carry the root's class receiver. INTERIOR names with a
+                    // single unambiguous class identity in the blast tree
+                    // scope to it (fix #244): a test of a different class's
+                    // same-named method is not coverage of THIS closure.
+                    // Standalone/mixed-identity names keep the bare scan.
+                    let scopeToClass = null;
+                    if (funcName === name) {
+                        scopeToClass = className || null;
+                    } else {
+                        const classes = nameToClasses.get(funcName);
+                        if (classes && classes.size === 1) {
+                            const only = classes.values().next().value;
+                            if (only) scopeToClass = only;
+                        }
+                    }
 
-                    // Build instance type map for className scoping (if applicable)
+                    // A test file that DEFINES funcName itself owns bare-name
+                    // calls of it (#215/#222(3) scope physics — fix #244: a
+                    // private same-name helper let the coverage band claim
+                    // 100% while the same payload's account excluded the
+                    // site as other-definition). Exception: when the local
+                    // def IS part of the blast closure (Rust inline-test
+                    // files define the symbol AND test it), bare calls bind
+                    // the affected symbol — genuine coverage.
+                    const localDefs = (fileEntry.symbols || []).filter(s => s.name === funcName);
+                    const localShadow = localDefs.length > 0 &&
+                        localDefs.every(s => !confirmedKeys.has(`${fileEntry.relativePath}:${s.startLine}`)) &&
+                        !(fileEntry.importBindings || []).some(b => b.name === funcName);
+
+                    // Build instance type map for className scoping (if applicable).
+                    // Scoping accepts the class plus its non-overriding
+                    // descendants — instances of a subclass that doesn't
+                    // override funcName dispatch to the target (fix #246).
                     let instanceTypeMap = null;
-                    if (className) {
-                        instanceTypeMap = _buildInstanceTypeMapForTracing(index, filePath, content, className);
+                    let dispatchNames = null;
+                    if (scopeToClass) {
+                        const dnKey = `${scopeToClass}:${funcName}`;
+                        dispatchNames = dispatchNamesCache.get(dnKey);
+                        if (!dispatchNames) {
+                            dispatchNames = classDispatchNames(index, scopeToClass, funcName);
+                            dispatchNamesCache.set(dnKey, dispatchNames);
+                        }
+                        instanceTypeMap = new Map();
+                        for (const dn of dispatchNames) {
+                            for (const [recv, cls] of _buildInstanceTypeMapForTracing(index, filePath, content, dn)) {
+                                if (!instanceTypeMap.has(recv)) instanceTypeMap.set(recv, cls);
+                            }
+                        }
                     }
 
                     const seenLines = new Set();
                     for (const usage of astUsages) {
                         if (usage.usageType === 'definition') continue;
+                        // Inline-test-promoted file: only lines inside the
+                        // test ranges are test code (fix #244).
+                        if (testRanges && !lineInRanges(usage.line, testRanges)) continue;
+                        // The engine confirmed this exact site as a caller
+                        // edge — its receiver physics subsume every text
+                        // heuristic below (fix #246: exact-class scoping
+                        // rejected a non-overriding subclass receiver the
+                        // engine had confirmed).
+                        const engineConfirmedHere = engineFileSites ? engineFileSites.has(usage.line) : false;
+                        // Local same-name shadow: bare calls bind the test
+                        // file's OWN definition, never the affected symbol.
+                        if (localShadow && !engineConfirmedHere && !usage.receiver && usage.usageType !== 'import') continue;
                         const lineKey = `${usage.line}:${usage.usageType}`;
                         if (seenLines.has(lineKey)) continue;
                         seenLines.add(lineKey);
@@ -910,18 +1065,34 @@ function affectedTests(index, name, options = {}) {
                         } else {
                             matchType = 'reference';
                         }
+                        // A confirmed usage-style edge (callback reference,
+                        // method value — fix #221) IS coverage: the test
+                        // executes the symbol through the reference.
+                        if (engineConfirmedHere && matchType === 'reference') matchType = 'call';
+
+                        if (matchType === 'call' && !engineConfirmedHere && engineAdjudicated) {
+                            // The engine searched this name's callers and did
+                            // NOT confirm this site — the same payload's
+                            // account holds it excluded-with-reason or
+                            // unverified. Crediting it as confirmed coverage
+                            // would contradict the account (fix #246);
+                            // unverified sites surface in
+                            // possiblyAffectedTests via the frontier.
+                            continue;
+                        }
 
-                        // className scoping for calls: check receiver
-                        if (className && matchType === 'call') {
-                            if (!_receiverMatchesClassTracing(usage, className, instanceTypeMap,
+                        // className scoping for calls (text physics — only
+                        // depth-limit names reach this un-adjudicated)
+                        if (scopeToClass && matchType === 'call' && !engineConfirmedHere) {
+                            if (!_receiverMatchesClassTracing(usage, dispatchNames, instanceTypeMap,
                                 index.getLineContent(filePath, usage.line), funcName)) continue;
                         }
 
                         // className scoping for references: require class-associated receiver
-                        if (className && matchType === 'reference') {
+                        if (scopeToClass && matchType === 'reference') {
                             if (!usage.receiver) continue;
-                            if (usage.receiver !== className &&
-                                !(instanceTypeMap && instanceTypeMap.get(usage.receiver) === className)) {
+                            if (!dispatchNames.has(usage.receiver) &&
+                                !(instanceTypeMap && dispatchNames.has(instanceTypeMap.get(usage.receiver)))) {
                                 continue;
                             }
                         }
@@ -934,6 +1105,26 @@ function affectedTests(index, name, options = {}) {
                         });
                     }
 
+                    // Confirmed engine sites the text scan could not see —
+                    // renamed destructure aliases (`{ save: persist }`),
+                    // beyondText lines — are coverage too (fix #246). The
+                    // dedup map below collapses any line the loop already
+                    // matched (call outranks reference).
+                    if (engineFileSites) {
+                        for (const ln of [...engineFileSites].sort((a, b) => a - b)) {
+                            if (testRanges && !lineInRanges(ln, testRanges)) continue;
+                            const lineKey = `${ln}:call`;
+                            if (seenLines.has(lineKey)) continue;
+                            seenLines.add(lineKey);
+                            if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
+                            fileMatches.get(funcName).push({
+                                line: ln,
+                                content: (index.getLineContent(filePath, ln) || '').trim(),
+                                matchType: 'call', functionName: funcName
+                            });
+                        }
+                    }
+
                     // Language-aware test-case detection
                     _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches);
                 }
@@ -995,9 +1186,55 @@ function affectedTests(index, name, options = {}) {
             } catch (e) { /* skip unreadable */ }
         }
 
+        // Merge frontier test hits: a test file whose own test function IS
+        // the unverified caller never surfaces via the scan (the scan greps
+        // for calls of scanNames; the test's name is not among them) — add
+        // it to the possible band with its unverified call sites (fix #244).
+        // A file already present for OTHER names still gets this name listed
+        // as possibly covered (fix #246 — the file-level dedup silently
+        // dropped per-name possible coverage).
+        for (const [absFile, entry] of frontierTestHits) {
+            const inResults = results.find(r => r.file === entry.rel);
+            const inPossible = possibleResults.find(r => r.file === entry.rel);
+            if (inResults || inPossible) {
+                const existing = inResults || inPossible;
+                const have = new Set([
+                    ...existing.coveredFunctions,
+                    ...(existing.possiblyCovered || []),
+                ]);
+                const extra = [...entry.byName.keys()].filter(n => !have.has(n)).sort(codeUnitCompare);
+                if (extra.length > 0) {
+                    if (inResults) {
+                        existing.possiblyCovered = [...(existing.possiblyCovered || []), ...extra].sort(codeUnitCompare);
+                    } else {
+                        existing.coveredFunctions = [...existing.coveredFunctions, ...extra].sort(codeUnitCompare);
+                    }
+                }
+                continue;
+            }
+            const covered = [...entry.byName.keys()].sort(codeUnitCompare);
+            const matches = [];
+            for (const fn of covered) {
+                for (const ln of [...entry.byName.get(fn)].sort((a, b) => a - b)) {
+                    matches.push({
+                        line: ln,
+                        content: (index.getLineContent(absFile, ln) || '').trim(),
+                        matchType: 'call',
+                        functionName: fn,
+                    });
+                }
+            }
+            possibleResults.push({
+                file: entry.rel,
+                coveredFunctions: covered,
+                matchCount: matches.length,
+                matches,
+            });
+        }
+
         // Sort by coverage breadth then alphabetically
-        results.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || a.file.localeCompare(b.file));
-        possibleResults.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || a.file.localeCompare(b.file));
+        results.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || codeUnitCompare(a.file, b.file));
+        possibleResults.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || codeUnitCompare(a.file, b.file));
 
         // Compute coverage stats.
         // Filter out test function names from affectedNames — they are callers,
@@ -1068,10 +1305,12 @@ function _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches
         const calls = getCachedCalls(index, filePath);
         if (!calls) return;
         const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
+        // Word-boundary match (fix #246): substring matched mid-word titles.
+        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(funcName) + '([^\\w$]|$)');
         for (const call of calls) {
             if (!testFrameworkCalls.has(call.name)) continue;
             const lineContent = index.getLineContent(filePath, call.line);
-            if (lineContent.includes(funcName) && !existingLines.has(call.line)) {
+            if (termPattern.test(lineContent) && !existingLines.has(call.line)) {
                 // Only add test-case if a call match exists in the test body
                 const endLine = _estimateTestBlockEndTracing(index, filePath, call.line);
                 const hasCallMatch = existingMatches.some(m =>
@@ -1159,21 +1398,24 @@ function _buildInstanceTypeMapForTracing(index, filePath, content, targetClassNa
 }
 
 /**
- * Check if a usage's receiver matches the target className (for affectedTests).
+ * Check if a usage's receiver matches any of the target dispatch class names
+ * (the class + its non-overriding descendants — fix #246) for affectedTests.
  * Same logic as _receiverMatchesClass in search.js.
  */
-function _receiverMatchesClassTracing(usage, className, instanceTypeMap, lineContent, searchTerm) {
-    if (usage.receiver === className) return true;
-    if (usage.receiver && instanceTypeMap && instanceTypeMap.get(usage.receiver) === className) return true;
+function _receiverMatchesClassTracing(usage, dispatchNames, instanceTypeMap, lineContent, searchTerm) {
+    if (usage.receiver && dispatchNames.has(usage.receiver)) return true;
+    if (usage.receiver && instanceTypeMap && dispatchNames.has(instanceTypeMap.get(usage.receiver))) return true;
     if (usage.receiver) return false;
     if (lineContent && searchTerm) {
-        const pat = new RegExp(
-            '\\b' + escapeRegExp(className) + '\\s*(?:(?:\\([^)]*\\)|\\{[^}]*\\})\\s*\\.\\s*' +
-            escapeRegExp(searchTerm) + '\\s*\\(|' +
-            'new\\s+' + escapeRegExp(className) + '\\s*\\([^)]*\\)\\s*\\.\\s*' +
-            escapeRegExp(searchTerm) + '\\s*\\()'
-        );
-        if (pat.test(lineContent)) return true;
+        for (const className of dispatchNames) {
+            const pat = new RegExp(
+                '\\b' + escapeRegExp(className) + '\\s*(?:(?:\\([^)]*\\)|\\{[^}]*\\})\\s*\\.\\s*' +
+                escapeRegExp(searchTerm) + '\\s*\\(|' +
+                'new\\s+' + escapeRegExp(className) + '\\s*\\([^)]*\\)\\s*\\.\\s*' +
+                escapeRegExp(searchTerm) + '\\s*\\()'
+            );
+            if (pat.test(lineContent)) return true;
+        }
     }
     return false;
 }