ucn 3.8.18 → 3.8.19

package/core/tracing.js

@@ -10,6 +10,8 @@
 const path = require('path');
 const { escapeRegExp } = require('./shared');
 const { isTestFile } = require('./discovery');
+const { getCachedCalls } = require('./callers');
+const { detectLanguage, getLanguageModule } = require('../languages');
 
 /**
  * Trace execution flow — build a tree of callees (down), callers (up), or both.
@@ -541,19 +543,11 @@ function affectedTests(index, name, options = {}) {
         };
         collectNames(blastResult.tree);
 
-        // Step 3: Build regex patterns for all names
-        const namePatterns = new Map();
-        for (const n of affectedNames) {
-            const escaped = escapeRegExp(n);
-            namePatterns.set(n, {
-                regex: new RegExp('\\b' + escaped + '\\b'),
-                callPattern: new RegExp(escaped + '\\s*\\('),
-            });
-        }
-
-        // Step 4: Scan test files once for all affected names
+        // Step 3: Scan test files for all affected names using AST
+        // Only count call and test-case matches as real coverage — not imports or bare references.
         const exclude = options.exclude;
         const excludeArr = exclude ? (Array.isArray(exclude) ? exclude : [exclude]) : [];
+        const className = options.className || null;
         const results = [];
         for (const [filePath, fileEntry] of index.files) {
             let isTest = isTestFile(fileEntry.relativePath, fileEntry.language);
@@ -565,40 +559,100 @@ function affectedTests(index, name, options = {}) {
             if (excludeArr.length > 0 && !index.matchesFilters(fileEntry.relativePath, { exclude: excludeArr })) continue;
             try {
                 const content = index._readFile(filePath);
-                const lines = content.split('\n');
                 const fileMatches = new Map();
 
-                lines.forEach((line, idx) => {
-                    for (const [funcName, patterns] of namePatterns) {
-                        if (patterns.regex.test(line)) {
-                            let matchType = 'reference';
-                            if (/\b(describe|it|test|spec)\s*\(/.test(line)) {
-                                matchType = 'test-case';
-                            } else if (/\b(import|require|from)\b/.test(line)) {
-                                matchType = 'import';
-                            } else if (patterns.callPattern.test(line)) {
-                                matchType = 'call';
+                for (const funcName of affectedNames) {
+                    // Fast pre-check
+                    if (!content.includes(funcName)) continue;
+
+                    // AST-based usage detection
+                    const astUsages = index._getCachedUsages(filePath, funcName);
+                    if (!astUsages || astUsages.length === 0) continue;
+
+                    // Build instance type map for className scoping (if applicable)
+                    let instanceTypeMap = null;
+                    if (className) {
+                        instanceTypeMap = _buildInstanceTypeMapForTracing(index, filePath, content, className);
+                    }
+
+                    const seenLines = new Set();
+                    for (const usage of astUsages) {
+                        if (usage.usageType === 'definition') continue;
+                        const lineKey = `${usage.line}:${usage.usageType}`;
+                        if (seenLines.has(lineKey)) continue;
+                        seenLines.add(lineKey);
+
+                        let matchType;
+                        if (usage.usageType === 'import') {
+                            matchType = 'import';
+                        } else if (usage.usageType === 'call') {
+                            matchType = 'call';
+                        } else {
+                            matchType = 'reference';
+                        }
+
+                        // className scoping for calls: check receiver
+                        if (className && matchType === 'call') {
+                            if (!_receiverMatchesClassTracing(usage, className, instanceTypeMap,
+                                index.getLineContent(filePath, usage.line), funcName)) continue;
+                        }
+
+                        // className scoping for references: require class-associated receiver
+                        if (className && matchType === 'reference') {
+                            if (!usage.receiver) continue;
+                            if (usage.receiver !== className &&
+                                !(instanceTypeMap && instanceTypeMap.get(usage.receiver) === className)) {
+                                continue;
                             }
-                            if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
-                            fileMatches.get(funcName).push({
-                                line: idx + 1, content: line.trim(),
-                                matchType, functionName: funcName
-                            });
                         }
+
+                        const lineContent = index.getLineContent(filePath, usage.line);
+                        if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
+                        fileMatches.get(funcName).push({
+                            line: usage.line, content: lineContent.trim(),
+                            matchType, functionName: funcName
+                        });
                     }
-                });
+
+                    // Language-aware test-case detection
+                    _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches);
+                }
 
                 if (fileMatches.size > 0) {
                     const coveredFunctions = [...fileMatches.keys()];
                     const allMatches = [];
                     for (const matches of fileMatches.values()) allMatches.push(...matches);
-                    allMatches.sort((a, b) => a.line - b.line);
-                    results.push({
-                        file: fileEntry.relativePath,
-                        coveredFunctions,
-                        matchCount: allMatches.length,
-                        matches: allMatches
+                    // Deduplicate same line+function (test-case line might overlap with call line)
+                    const dedupMap = new Map();
+                    for (const m of allMatches) {
+                        const key = `${m.line}:${m.functionName}`;
+                        const existing = dedupMap.get(key);
+                        if (!existing || _matchPriority(m.matchType) > _matchPriority(existing.matchType)) {
+                            dedupMap.set(key, m);
+                        }
+                    }
+                    const deduped = [...dedupMap.values()].sort((a, b) => a.line - b.line);
+
+                    // Only count functions with call or test-case matches as covered.
+                    // Import-only or reference-only functions are not real coverage.
+                    const realCoveredFunctions = coveredFunctions.filter(fn => {
+                        const fnMatches = deduped.filter(m => m.functionName === fn);
+                        return fnMatches.some(m => m.matchType === 'call' || m.matchType === 'test-case');
                     });
+
+                    // Only include file if it has real coverage
+                    const realMatches = deduped.filter(m =>
+                        m.matchType === 'call' || m.matchType === 'test-case' ||
+                        realCoveredFunctions.includes(m.functionName)
+                    );
+                    if (realCoveredFunctions.length > 0) {
+                        results.push({
+                            file: fileEntry.relativePath,
+                            coveredFunctions: realCoveredFunctions,
+                            matchCount: realMatches.length,
+                            matches: realMatches
+                        });
+                    }
                 }
             } catch (e) { /* skip unreadable */ }
         }
@@ -606,18 +660,35 @@ function affectedTests(index, name, options = {}) {
         // Sort by coverage breadth then alphabetically
         results.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || a.file.localeCompare(b.file));
 
-        // Compute coverage stats
+        // Compute coverage stats.
+        // Filter out test function names from affectedNames — they are callers,
+        // not production symbols that need test coverage.
+        const productionNames = new Set();
+        for (const n of affectedNames) {
+            // Check if this name is only found in test files
+            let foundInSource = false;
+            for (const [fp, fe] of index.files) {
+                if (isTestFile(fe.relativePath, fe.language)) continue;
+                if (fe.symbols?.some(s => s.name === n)) { foundInSource = true; break; }
+            }
+            if (foundInSource) productionNames.add(n);
+        }
+        // Fall back to full set if filtering removed everything (e.g., test-only project)
+        const namesForCoverage = productionNames.size > 0 ? productionNames : affectedNames;
+
         const coveredSet = new Set();
-        for (const r of results) for (const f of r.coveredFunctions) coveredSet.add(f);
-        const uncovered = [...affectedNames].filter(n => !coveredSet.has(n));
+        for (const r of results) for (const f of r.coveredFunctions) {
+            if (namesForCoverage.has(f)) coveredSet.add(f);
+        }
+        const uncovered = [...namesForCoverage].filter(n => !coveredSet.has(n));
 
         return {
             root: blastResult.root, file: blastResult.file, line: blastResult.line,
             depth: blastResult.maxDepth,
-            affectedFunctions: [...affectedNames],
+            affectedFunctions: [...namesForCoverage],
             testFiles: results,
             summary: {
-                totalAffected: affectedNames.size,
+                totalAffected: namesForCoverage.size,
                 totalTestFiles: results.length,
                 coveredFunctions: coveredSet.size,
                 uncoveredCount: uncovered.length,
@@ -628,4 +699,145 @@ function affectedTests(index, name, options = {}) {
     } finally { index._endOp(); }
 }
 
+/**
+ * Add test-case matches for a function name in a test file (language-aware).
+ * Only adds test-case when the test body has a call match (not just import/reference).
+ */
+function _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches) {
+    const lang = fileEntry.language;
+    const existingMatches = fileMatches.get(funcName) || [];
+    const existingLines = new Set(existingMatches.map(m => m.line));
+
+    if (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') {
+        const calls = getCachedCalls(index, filePath);
+        if (!calls) return;
+        const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
+        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)) {
+                // 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 =>
+                    m.line >= call.line && m.line <= endLine &&
+                    m.matchType === 'call'
+                );
+                if (!hasCallMatch) continue;
+                if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
+                fileMatches.get(funcName).push({
+                    line: call.line, content: lineContent.trim(),
+                    matchType: 'test-case', functionName: funcName
+                });
+                existingLines.add(call.line);
+            }
+        }
+    } else {
+        if (!fileEntry.symbols) return;
+        try {
+            const langModule = getLanguageModule(lang);
+            if (!langModule || !langModule.isEntryPoint) return;
+            for (const symbol of fileEntry.symbols) {
+                if (!langModule.isEntryPoint(symbol)) continue;
+                // Only add test-case if a call match exists in the test body
+                const hasCallInRange = existingMatches.some(m =>
+                    m.line >= symbol.startLine && m.line <= symbol.endLine &&
+                    m.matchType === 'call'
+                );
+                if (hasCallInRange && !existingLines.has(symbol.startLine)) {
+                    const lineContent = index.getLineContent(filePath, symbol.startLine);
+                    if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
+                    fileMatches.get(funcName).push({
+                        line: symbol.startLine, content: lineContent.trim(),
+                        matchType: 'test-case', functionName: funcName
+                    });
+                    existingLines.add(symbol.startLine);
+                }
+            }
+        } catch (e) { /* skip */ }
+    }
+}
+
+/**
+ * Build instance type map for className scoping in affectedTests.
+ * Same logic as _buildInstanceTypeMap in search.js.
+ */
+function _buildInstanceTypeMapForTracing(index, filePath, content, targetClassName) {
+    const typeMap = new Map();
+    const calls = getCachedCalls(index, filePath);
+    if (calls) {
+        for (const call of calls) {
+            if (call.isMethod && call.receiver && call.receiverType === targetClassName) {
+                typeMap.set(call.receiver, targetClassName);
+            }
+            if (call.name === targetClassName && !call.isMethod) {
+                const lineContent = index.getLineContent(filePath, call.line);
+                const assignMatch = lineContent.match(/(?:const|let|var|)\s*(\w+)\s*:?=\s/);
+                if (assignMatch) typeMap.set(assignMatch[1], targetClassName);
+            }
+            if (call.isMethod && call.receiver === targetClassName) {
+                const lineContent = index.getLineContent(filePath, call.line);
+                const assignMatch = lineContent.match(/(?:const|let|var|)\s*(\w+)\s*:?=\s/);
+                if (assignMatch) typeMap.set(assignMatch[1], targetClassName);
+            }
+        }
+    }
+    const classUsages = index._getCachedUsages(filePath, targetClassName);
+    if (classUsages) {
+        for (const u of classUsages) {
+            if (u.usageType === 'import' || u.usageType === 'definition') continue;
+            const lineContent = index.getLineContent(filePath, u.line);
+            const assignMatch = lineContent.match(/(?:const|let|var|)\s*(\w+)\s*:?=\s/);
+            if (assignMatch && assignMatch[1] !== targetClassName) {
+                typeMap.set(assignMatch[1], targetClassName);
+            }
+        }
+    }
+    return typeMap;
+}
+
+/**
+ * Check if a usage's receiver matches the target className (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;
+    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;
+    }
+    return false;
+}
+
+/**
+ * Estimate the end line of a test block by tracking brace/paren nesting.
+ */
+function _estimateTestBlockEndTracing(index, filePath, startLine) {
+    const content = index._readFile(filePath);
+    if (!content) return startLine + 5;
+    const lines = content.split('\n');
+    let depth = 0;
+    let started = false;
+    for (let i = startLine - 1; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+            if (ch === '{' || ch === '(') { depth++; started = true; }
+            else if (ch === '}' || ch === ')') { depth--; }
+        }
+        if (started && depth <= 0) return i + 1;
+    }
+    return Math.min(startLine + 10, lines.length);
+}
+
+function _matchPriority(matchType) {
+    const p = { 'test-case': 5, 'call': 4, 'import': 3, 'string-ref': 2, 'reference': 1 };
+    return p[matchType] || 0;
+}
+
 module.exports = { trace, blast, reverseTrace, affectedTests };

package/languages/javascript.js

@@ -2033,8 +2033,10 @@ function findUsagesInCode(code, name, parser) {
 
     traverseTreeCached(tree.rootNode, (node) => {
         // Look for identifier, property_identifier (method names in obj.method() calls),
-        // and type_identifier (TypeScript type annotations like `params: MyType`)
-        const isIdentifier = node.type === 'identifier' || node.type === 'property_identifier' || node.type === 'type_identifier';
+        // type_identifier (TypeScript type annotations), and shorthand_property_identifier_pattern
+        // (destructured names in `const { name } = require(...)`)
+        const isIdentifier = node.type === 'identifier' || node.type === 'property_identifier' ||
+            node.type === 'type_identifier' || node.type === 'shorthand_property_identifier_pattern';
         if (!isIdentifier || node.text !== name) {
             return true;
         }
@@ -2101,6 +2103,21 @@ function findUsagesInCode(code, name, parser) {
                     }
                 }
             }
+            // Destructured require: const { name } = require('...')
+            else if (node.type === 'shorthand_property_identifier_pattern' &&
+                     parent.type === 'object_pattern') {
+                // Check if the object_pattern is part of a variable_declarator with require()
+                const declarator = parent.parent;
+                if (declarator && declarator.type === 'variable_declarator') {
+                    const value = declarator.childForFieldName('value');
+                    if (value && value.type === 'call_expression') {
+                        const func = value.childForFieldName('function');
+                        if (func && func.text === 'require') {
+                            usageType = 'import';
+                        }
+                    }
+                }
+            }
             // Property access (method call): a.name() - the name after dot
             else if (parent.type === 'member_expression' &&
                      parent.childForFieldName('property') === node) {

package/languages/rust.js

@@ -1319,6 +1319,13 @@ function findExportsInCode(code, parser) {
  * @param {object} parser - Tree-sitter parser instance
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
+function _indexInParent(node, parent) {
+    for (let i = 0; i < parent.childCount; i++) {
+        if (parent.child(i) === node) return i;
+    }
+    return -1;
+}
+
 function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
@@ -1433,6 +1440,39 @@ function findUsagesInCode(code, name, parser) {
                     return true;
                 }
             }
+            // Macro body: tree-sitter parses macro arguments as flat token_tree
+            // nodes, so `svc.save()` inside `assert_eq!(svc.save(), 1)` appears
+            // as sibling identifiers: [svc] [.] [save] [()] rather than a
+            // field_expression. Detect the `obj.name(` pattern via siblings.
+            else if (parent.type === 'token_tree') {
+                const idx = _indexInParent(node, parent);
+                // Method call pattern: [obj] [.] [name] [()] inside macro
+                if (idx >= 2) {
+                    const dot = parent.child(idx - 1);
+                    const obj = parent.child(idx - 2);
+                    const next = parent.child(idx + 1);
+                    if (dot && dot.text === '.' && obj &&
+                        (obj.type === 'identifier' || obj.type === 'self')) {
+                        if (next && next.type === 'token_tree' &&
+                            next.childCount > 0 && next.child(0).text === '(') {
+                            usageType = 'call';
+                        }
+                        usages.push({ line, column, usageType, receiver: obj.text });
+                        return true;
+                    }
+                }
+                // Bare function call pattern: [name] [()] inside macro
+                if (idx >= 0) {
+                    const next = parent.child(idx + 1);
+                    // Check no preceding dot (would be method call handled above)
+                    const prev = idx > 0 ? parent.child(idx - 1) : null;
+                    if ((!prev || prev.text !== '.') &&
+                        next && next.type === 'token_tree' &&
+                        next.childCount > 0 && next.child(0).text === '(') {
+                        usageType = 'call';
+                    }
+                }
+            }
         }
 
         // Filter out enum variant references: Boundary::Grid is NOT a usage of Grid struct