ucn 5.5.2 → 5.6.0

package/core/search.js

@@ -17,6 +17,8 @@ const { isAccessorDefinition, findAccessorReferences } = require('./accessors');
 const isSafeRegex = require('safe-regex2');
 const { RE2JS } = require('re2js');
 const { UcnError } = require('./errors');
+const { paramValues } = require('./registry');
+const { createTestModel, addTestCaseRows, linkFiles } = 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
@@ -36,11 +38,8 @@ function buildGlobMatcher(pattern, caseSensitive) {
     return (name) => regex.test(name);
 }
 
-const STRUCTURAL_TYPES = new Set([
-    'function', 'class', 'call', 'method', 'type', 'constructor',
-    'state', 'field', 'constant', 'macro', 'variable',
-    'interface', 'enum', 'struct', 'trait', 'record', 'namespace',
-]);
+// The kinds a structural search takes: the parameter table's set.
+const STRUCTURAL_TYPES = new Set(paramValues('type', 'search'));
 
 /**
  * Substring match. Case-insensitive by default.
@@ -1313,6 +1312,10 @@ function tests(index, nameOrFile, options = {}) {
     index._beginOp();
     try {
     const results = [];
+    const model = createTestModel(index);
+    // Files where a title that names the term is a link (the term on a test
+    // line is the project's symbol, not the file's own helper).
+    const titled = new Set();
 
     // Check if it's a file path
     const isFilePath = nameOrFile.includes('/') || nameOrFile.includes('\\') ||
@@ -1358,6 +1361,23 @@ function tests(index, nameOrFile, options = {}) {
         }
     }
 
+    // A file's name does not decide what a test executes: the body of a
+    // test a class inherits stands where its base class is, and a runner
+    // takes tests from files of any name. A call site the caller engine
+    // finds in such a file is a test's where the test model says a test
+    // executes that line (core/test-units.js): the file joins the test
+    // files, test code within those lines.
+    const testInfoByPath = new Map(testFiles.map(info => [info.path, info]));
+    const testInfoOf = filePath => {
+        if (testInfoByPath.has(filePath)) return testInfoByPath.get(filePath);
+        const entry = index.files.get(filePath);
+        const ranges = entry ? model.testRangesOf(filePath) : [];
+        const info = ranges.length > 0 ? { path: filePath, entry, testRanges: ranges } : null;
+        testInfoByPath.set(filePath, info);
+        if (info) testFiles.push(info);
+        return info;
+    };
+
     const searchTerm = isFilePath
         ? path.basename(nameOrFile, path.extname(nameOrFile))
         : nameOrFile;
@@ -1388,7 +1408,6 @@ function tests(index, nameOrFile, options = {}) {
     // module-level coverage remain visible.
     const fileTargetCallerSites = new Map(); // absolute test file → tiered sites
     if (isFilePath && targetRels) {
-        const testFileInfo = new Map(testFiles.map(info => [info.path, info]));
         const fileTargetDefs = [];
         for (const [, fe] of index.files) {
             if (!targetRels.has(fe.relativePath)) continue;
@@ -1410,7 +1429,7 @@ function tests(index, nameOrFile, options = {}) {
                 })) : []),
             ];
             for (const site of sites) {
-                const info = testFileInfo.get(site.file);
+                const info = testInfoOf(site.file);
                 if (!info) continue;
                 if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
                 let rows = fileTargetCallerSites.get(site.file);
@@ -1659,12 +1678,11 @@ function tests(index, nameOrFile, options = {}) {
                 });
             }
 
-            // Language-aware test-case detection. Under a local same-name
-            // shadow the term on a test line is the file's OWN helper —
-            // only anchor test cases to matches that survived the shadow.
+            // Under a local same-name shadow the term in a test's title is
+            // the file's OWN helper: titles link only where a match survived.
             if (!isFilePath && sourceFileLinked &&
                 (!localShadow || matches.some(m => m.matchType !== 'import'))) {
-                _addTestCaseMatches(index, testPath, entry, searchTerm, className, instanceTypeMap, matches);
+                titled.add(entry.relativePath);
             }
 
             // Deduplicate: if a line already has a 'call' or 'import', don't also add 'test-case'
@@ -1705,7 +1723,6 @@ function tests(index, nameOrFile, options = {}) {
     // 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 testInfo = new Map(testFiles.map(t => [t.path, t]));
         const callerSites = [];
         // A pinned definition's unverified sites were adjudicated against it
         // alone, like a globally unique name's (fix #430).
@@ -1725,7 +1742,7 @@ function tests(index, nameOrFile, options = {}) {
         }
 
         for (const site of callerSites) {
-            const info = testInfo.get(site.file);
+            const info = testInfoOf(site.file);
             if (!info) continue;
             if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
             // Every site here was adjudicated against the exact target
@@ -1780,16 +1797,22 @@ function tests(index, nameOrFile, options = {}) {
         const nestedTypeDefs = targetDefs.filter(def => def.enclosingType &&
             ['class', 'struct', 'interface', 'type', 'enum', 'trait', 'record', 'union'].includes(def.type));
         if (accessorDefs.length > 0 || nestedTypeDefs.length > 0) {
-            const testPaths = new Set(testFiles.map(t => t.path));
+            // Reference-only tests have no call site to add their file to
+            // testFiles above. Let the reference engines find their sites
+            // first, then ask the same model which lines a test executes.
+            // The index-only gate spares files that cannot hold test code;
+            // filenames alone never remove a candidate.
+            const referencePaths = new Set([...index.files.keys()].filter(filePath =>
+                testInfoByPath.get(filePath) || model.mayHoldTests(filePath)));
             const globallyUnique = index.find(searchTerm, { exact: true }).length === 1;
             for (const def of [...accessorDefs, ...nestedTypeDefs]) {
                 const types = nestedTypeDefs.includes(def)
-                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: testPaths }) : null;
+                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: referencePaths }) : null;
                 const typeSite = site => ({ ...site, absoluteFile: path.join(index.root, site.file) });
                 const refs = types ? {
                     confirmed: types.byFile.flatMap(group => group.sites).map(typeSite),
                     unverified: types.unverifiedSites.map(typeSite),
-                } : findAccessorReferences(index, searchTerm, def, { files: testPaths });
+                } : findAccessorReferences(index, searchTerm, def, { files: referencePaths });
                 if (!refs) continue;
                 const rows = [
                     ...refs.confirmed.map(r => ({ ...r, tierName: 'confirmed' })),
@@ -1797,7 +1820,7 @@ function tests(index, nameOrFile, options = {}) {
                         ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
                 ];
                 for (const ref of rows) {
-                    const info = testInfo.get(ref.absoluteFile);
+                    const info = testInfoOf(ref.absoluteFile);
                     if (!info) continue;
                     if (info.testRanges && !lineInRanges(ref.line, info.testRanges)) continue;
                     if (excludeArr.length > 0 &&
@@ -1835,6 +1858,55 @@ function tests(index, nameOrFile, options = {}) {
         results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
     }
 
+    // The tests that hold the matches (core/test-units.js): one row per
+    // test, then what the file is to its runner and how to run it.
+    const absolute = new Map(testFiles.map(info => [info.entry.relativePath, info.path]));
+    const linesByFile = new Map();
+    for (const fileResult of results) {
+        const testPath = absolute.get(fileResult.file);
+        if (!testPath) continue;
+        addTestCaseRows(model, index, testPath, isFilePath ? null : searchTerm, fileResult.matches, {
+            counts: match => match.matchType !== 'import',
+            titles: titled.has(fileResult.file),
+            titleNeedsMatch: !!className,
+        });
+        linesByFile.set(testPath,
+            fileResult.matches.filter(match => match.matchType !== 'import').map(match => match.line));
+    }
+    // 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.
+    const byFile = new Map(results.map(fileResult => [fileResult.file, fileResult]));
+    for (const [testPath, linked] of linkFiles(model, index, linesByFile)) {
+        const relativePath = index.files.get(testPath).relativePath;
+        let fileResult = byFile.get(relativePath);
+        if (!fileResult) {
+            fileResult = { file: relativePath, matches: [] };
+            byFile.set(relativePath, fileResult);
+            results.push(fileResult);
+        }
+        for (const unit of linked.units) {
+            if (!unit.inheritedFrom) continue;
+            fileResult.matches.push({
+                line: unit.line,
+                content: (index.getLineContent(testPath, unit.line) || '').trim(),
+                matchType: 'inherited-test',
+                name: unit.name,
+                from: unit.inheritedFrom,
+            });
+        }
+        fileResult.matches.sort((a, b) => (a.line || 0) - (b.line || 0) ||
+            codeUnitCompare(a.matchType || '', b.matchType || '') || codeUnitCompare(a.name || '', b.name || ''));
+        fileResult.role = linked.role;
+        if (linked.runner) fileResult.runner = linked.runner;
+        fileResult.tests = linked.tests;
+        if (linked.moreTests) fileResult.moreTests = true;
+        if (linked.conditionalTests) fileResult.conditionalTests = linked.conditionalTests;
+        if (linked.units.length > 0) fileResult.units = linked.units;
+        if (linked.run) fileResult.run = linked.run;
+        else if (linked.runWithheld) fileResult.runWithheld = linked.runWithheld;
+    }
+    results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
+
     return results;
     } finally { index._endOp(); }
 }
@@ -2181,117 +2253,6 @@ function _receiverMatchesClass(usage, dispatchNames, instanceTypeMap, lineConten
     return false;
 }
 
-/**
- * Language-aware test-case detection.
- *
- * JS/TS: describe, it, test, spec calls with searchTerm in the description.
- * Go: TestXxx, BenchmarkXxx, ExampleXxx functions containing a usage of searchTerm.
- * Python: test_ functions or TestCase methods containing a usage of searchTerm.
- * Java: @Test-annotated methods containing a usage of searchTerm.
- * Rust: #[test]-attributed functions containing a usage of searchTerm.
- */
-function _addTestCaseMatches(index, filePath, fileEntry, searchTerm, className, instanceTypeMap, matches) {
-    const matchLines = new Set(matches.map(m => m.line));
-    const lang = fileEntry.language;
-
-    if (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') {
-        // JS/TS: find describe/it/test/spec calls from getCachedCalls
-        const calls = getCachedCalls(index, filePath);
-        if (!calls) return;
-        const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
-        // Word-boundary match: `describe("untargeted zone")` is not a test
-        // case for `target` (fix #246 — raw substring matched mid-word).
-        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(searchTerm) + '([^\\w$]|$)');
-        for (const call of calls) {
-            if (!testFrameworkCalls.has(call.name)) continue;
-            const lineContent = index.getLineContent(filePath, call.line);
-            // Check if searchTerm appears in the description string on this line
-            if (termPattern.test(lineContent) && !matchLines.has(call.line)) {
-                // className scoping: only add test-case if the test body has a
-                // class-scoped match (call or class-receiver reference) — not just
-                // any mention of className.
-                if (className) {
-                    const endLine = _estimateTestBlockEnd(index, filePath, call.line);
-                    const hasClassScopedMatch = matches.some(m =>
-                        m.line >= call.line && m.line <= endLine &&
-                        m.matchType !== 'import'
-                    );
-                    if (!hasClassScopedMatch) continue;
-                }
-                matches.push({
-                    line: call.line,
-                    content: lineContent.trim(),
-                    matchType: 'test-case'
-                });
-                matchLines.add(call.line);
-            }
-        }
-    } else {
-        // Go/Python/Java/Rust: check if any AST usage falls within a test function's range
-        if (!fileEntry.symbols) return;
-        try {
-            const langModule = getLanguageAdapter(lang);
-            if (!langModule) return;
-            // Prefer kinded predicate so fn main() and fn init() aren't classified
-            // as test cases (BUG-CX). Fall back to isEntryPoint for compat.
-            const classify = langModule.getEntryPointKind
-                ? (s) => langModule.getEntryPointKind(s) === 'test'
-                : langModule.isEntryPoint;
-            if (!classify) return;
-
-            // Find test symbols
-            for (const symbol of fileEntry.symbols) {
-                if (!classify(symbol)) continue;
-                // Check if any non-import usage of searchTerm falls within this test function
-                const usageInRange = matches.some(m =>
-                    m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                    m.matchType !== 'import'
-                );
-                if (usageInRange && !matchLines.has(symbol.startLine)) {
-                    // className scoping: verify the test body has class-scoped matches
-                    if (className) {
-                        const hasClassScopedMatch = matches.some(m =>
-                            m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                            m.matchType !== 'import'
-                        );
-                        if (!hasClassScopedMatch) continue;
-                    }
-                    const lineContent = index.getLineContent(filePath, symbol.startLine);
-                    matches.push({
-                        line: symbol.startLine,
-                        content: lineContent.trim(),
-                        matchType: 'test-case'
-                    });
-                    matchLines.add(symbol.startLine);
-                }
-            }
-        } catch (e) {
-            // Skip if language module unavailable
-        }
-    }
-}
-
-/**
- * Estimate the end line of a test block (it/test/describe callback) by tracking
- * brace nesting from the start line.
- */
-function _estimateTestBlockEnd(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; // 1-based
-    }
-    return Math.min(startLine + 10, lines.length);
-}
-
 /**
  * Deduplicate matches: prefer more specific matchTypes on the same line.
  * Priority: test-case > call > import > string-ref > reference

package/core/shared.js

@@ -260,49 +260,6 @@ function isOverrideMarked(def) {
     return false;
 }
 
-// Per-language text patterns for the "blind spots" UCN's AST can't follow:
-// eval/exec-style code execution and reflection (dynamic attribute access /
-// dynamic dispatch). ONE source of truth so doctor's trust scan and
-// detectCompleteness's about-footer warning count identically (field-report #2:
-// they used to diverge — doctor 497 reflection vs footer 194, eval 3 vs 2 —
-// because each kept its own regex set). Dynamic imports are NOT here: those are
-// structural (fileEntry.dynamicImports), the AST-accurate count both paths share.
-// `new Function(...)` is categorized as eval (code execution), not reflection.
-const BLINDSPOT_TEXT_PATTERNS = {
-    reflection: {
-        python:     /\b(getattr|hasattr|setattr|__import__|importlib\.import_module)\s*\(/g,
-        javascript: /\bReflect\.\w+\s*\(/g,
-        typescript: /\bReflect\.\w+\s*\(/g,
-        go:         /\breflect\.\w+\s*\(/g,
-        java:       /\.getDeclaredMethod\b|\.getMethod\b|\.getDeclaredField\b|Class\.forName\b/g,
-        rust:       /\bAny::downcast/g,
-    },
-    eval: {
-        python:     /\b(eval|exec)\s*\(/g,
-        javascript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-        typescript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-    },
-};
-
-/** True when a language has any text-blind-spot pattern (so callers can skip the file read otherwise). */
-function hasTextBlindspots(language) {
-    return !!(BLINDSPOT_TEXT_PATTERNS.reflection[language] || BLINDSPOT_TEXT_PATTERNS.eval[language]);
-}
-
-/**
- * Count text-detected blind spots (eval/exec, reflection) in one file's source.
- * Returns { eval, reflection } OCCURRENCE counts (global match). Shared by doctor
- * and detectCompleteness so both report the same numbers (field-report #2).
- */
-function countTextBlindspots(content, language) {
-    const reRe = BLINDSPOT_TEXT_PATTERNS.reflection[language];
-    const evRe = BLINDSPOT_TEXT_PATTERNS.eval[language];
-    return {
-        eval: evRe ? (content.match(evRe) || []).length : 0,
-        reflection: reRe ? (content.match(reRe) || []).length : 0,
-    };
-}
-
 /**
  * Line ranges of INLINE test symbols in a source file — Rust #[test] fns and
  * #[cfg(test)] module members. A production file promoted to "test file"
@@ -614,8 +571,6 @@ module.exports = { literalNameRegex,
     looksLikeHandle,
     isTestPath,
     isOverrideMarked,
-    hasTextBlindspots,
-    countTextBlindspots,
     isPathInsideRoot,
     isMacroNamespaceDefinition,
 };