ucn 5.4.2 → 5.5.0

package/core/rust-modules.js

@@ -0,0 +1,185 @@
+/**
+ * core/rust-modules.js - Rust module tree (fix #377).
+ *
+ * Every Rust source file belongs to exactly one module of one crate: crate
+ * roots are the files no `mod` declaration loads, and a declared file's
+ * module path is its parent's path plus the enclosing inline modules plus
+ * the declared name. Inline `mod NAME { ... }` blocks are modules too.
+ *
+ * `rustPathModule` resolves the qualifier of a path call (`crate::a::b`,
+ * `super::super`, `self::inner`, `net::conn`) from the call site's own
+ * module to the module entries (file + inline chain) that hold its items;
+ * `rustModuleItems` lists the definitions of a name declared directly in
+ * those modules. Anything the tree cannot prove (a `use` alias, an extern
+ * crate, a type, a re-export) resolves to null: the caller keeps its other
+ * evidence rules.
+ */
+
+'use strict';
+
+const { rustModDeclarationFiles, rustInlineModules, rustInlineChainAt } = require('./imports');
+
+const FUNCTION_KINDS = new Set(['function', 'method', 'constructor', 'static']);
+
+function isRustEntry(entry) {
+    return entry?.language === 'rust';
+}
+
+function moduleTree(index) {
+    const memo = index._rustScopeMemo || (index._rustScopeMemo = new Map());
+    const cached = memo.get('\x01rustModuleTree');
+    if (cached) return cached;
+    const parents = new Map(); // child file -> { file, chain, name }
+    const inlineByFile = new Map();
+    const exists = candidate => isRustEntry(index.files.get(candidate));
+    for (const [file, entry] of index.files) {
+        if (!isRustEntry(entry)) continue;
+        const inline = rustInlineModules(entry);
+        inlineByFile.set(file, inline);
+        const declared = rustModDeclarationFiles(file, entry, exists, inline);
+        if (declared.size === 0) continue;
+        for (const detail of entry.importDetails || []) {
+            if (detail.type !== 'mod' || !declared.has(detail.module)) continue;
+            const chain = rustInlineChainAt(inline, detail.line);
+            for (const child of declared.get(detail.module)) {
+                if (child === file || parents.has(child)) continue;
+                parents.set(child, { file, chain, name: detail.module });
+            }
+        }
+    }
+    const fileModules = new Map(); // file -> { root, segs }
+    const moduleOf = (file, seen = new Set()) => {
+        const hit = fileModules.get(file);
+        if (hit) return hit;
+        const parent = parents.get(file);
+        let result;
+        if (!parent || seen.has(file)) {
+            result = { root: file, segs: [] };
+        } else {
+            seen.add(file);
+            const up = moduleOf(parent.file, seen);
+            result = { root: up.root, segs: [...up.segs, ...parent.chain, parent.name] };
+        }
+        fileModules.set(file, result);
+        return result;
+    };
+    const entries = new Map(); // root \0 path -> [{ file, chain }]
+    const add = (root, segs, file, chain) => {
+        const key = `${root}\0${segs.join('::')}`;
+        if (!entries.has(key)) entries.set(key, []);
+        entries.get(key).push({ file, chain });
+    };
+    for (const [file, inline] of inlineByFile) {
+        const own = moduleOf(file);
+        add(own.root, own.segs, file, []);
+        for (const mod of inline) {
+            const chain = rustInlineChainAt(inline, mod.startLine);
+            add(own.root, [...own.segs, ...chain], file, chain);
+        }
+    }
+    const tree = { moduleOf, entries, inlineByFile };
+    memo.set('\x01rustModuleTree', tree);
+    return tree;
+}
+
+/**
+ * Module entries a path qualifier names from (filePath, line), or null when
+ * the qualifier is not provably a module path of this crate.
+ * @returns {{ root: string, segs: string[], entries: Array<{file: string, chain: string[]}> }|null}
+ */
+function rustPathModule(index, filePath, line, qualifier) {
+    if (!isRustEntry(index.files.get(filePath)) || !qualifier) return null;
+    const segments = String(qualifier).split('::');
+    if (segments.some(segment => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment))) return null;
+    const tree = moduleTree(index);
+    const own = tree.moduleOf(filePath);
+    const current = [...own.segs, ...rustInlineChainAt(tree.inlineByFile.get(filePath) || [], line)];
+    const has = segs => tree.entries.has(`${own.root}\0${segs.join('::')}`);
+    let segs;
+    let i = 0;
+    if (segments[0] === 'crate') {
+        segs = [];
+        i = 1;
+    } else if (segments[0] === 'self' || segments[0] === 'super') {
+        segs = current;
+        if (segments[0] === 'self') i = 1;
+        while (segments[i] === 'super') {
+            if (segs.length === 0) return null;
+            segs = segs.slice(0, -1);
+            i++;
+        }
+    } else {
+        // A leading plain name is a child module of the current module; a
+        // `use` binding, extern crate, or type is not the tree's to prove.
+        segs = current;
+    }
+    for (; i < segments.length; i++) {
+        const next = [...segs, segments[i]];
+        if (!has(next)) return null;
+        segs = next;
+    }
+    return { root: own.root, segs, entries: tree.entries.get(`${own.root}\0${segs.join('::')}`) || [] };
+}
+
+/**
+ * Definitions of `name` declared as items directly in the resolved module
+ * (not inside an impl, trait, nested inline module, or function body).
+ */
+function rustModuleItems(index, resolved, name) {
+    if (!resolved?.entries?.length) return [];
+    const tree = moduleTree(index);
+    const out = [];
+    for (const def of index.symbols.get(name) || []) {
+        if (def.className || def.receiver || def.type === 'module' || def.type === 'field' ||
+            def.type === 'macro' || def.type === 'impl') continue;
+        const entry = resolved.entries.find(candidate => candidate.file === def.file);
+        if (!entry) continue;
+        const chain = rustInlineChainAt(tree.inlineByFile.get(def.file) || [], def.startLine);
+        if (chain.length !== entry.chain.length || chain.some((part, k) => part !== entry.chain[k])) continue;
+        const fileEntry = index.files.get(def.file);
+        const nested = (fileEntry?.symbols || []).some(symbol => symbol !== def &&
+            FUNCTION_KINDS.has(symbol.type) && symbol.startLine <= def.startLine &&
+            symbol.endLine >= def.endLine && !(symbol.startLine === def.startLine && symbol.name === def.name));
+        if (nested) continue;
+        out.push(def);
+    }
+    return out;
+}
+
+/**
+ * The crate root and module path of a source position (fix #399), or null
+ * for a file that is not Rust.
+ * @returns {{ root: string, segs: string[] }|null}
+ */
+function rustModulePathAt(index, filePath, line) {
+    if (!isRustEntry(index.files.get(filePath))) return null;
+    const tree = moduleTree(index);
+    const own = tree.moduleOf(filePath);
+    return { root: own.root, segs: [...own.segs, ...rustInlineChainAt(tree.inlineByFile.get(filePath) || [], line)] };
+}
+
+/**
+ * Is an item with Rust visibility `modifiers`, declared at (file, line),
+ * accessible at (siteFile, siteLine)? `pub` items are; `pub(crate)` ones
+ * within their crate; private, `pub(self)` and `pub(super)` items within
+ * the module tree under their module (or its parent). `pub(in path)` and
+ * unknown layouts are not provable (false).
+ */
+function rustItemAccessible(index, modifiers, file, line, siteFile, siteLine) {
+    const mods = (modifiers || []).map(m => String(m).replace(/\s+/g, ''));
+    if (mods.includes('pub')) return true;
+    const item = rustModulePathAt(index, file, line);
+    const site = rustModulePathAt(index, siteFile, siteLine);
+    if (!item || !site || item.root !== site.root) return false;
+    if (mods.includes('pub(crate)')) return true;
+    let scope = item.segs;
+    if (mods.includes('pub(super)')) {
+        if (scope.length === 0) return false;
+        scope = scope.slice(0, -1);
+    } else if (mods.some(m => m.startsWith('pub(') && m !== 'pub(self)')) {
+        return false;
+    }
+    return scope.length <= site.segs.length && scope.every((seg, i) => site.segs[i] === seg);
+}
+
+module.exports = { rustPathModule, rustModuleItems, rustModulePathAt, rustItemAccessible };

package/core/search.js

@@ -13,8 +13,10 @@ const { isTestFile } = require('./discovery');
 const { detectLanguage, getParser, getLanguageAdapter, langTraits } = require('../languages');
 const { getCachedCalls } = require('./callers');
 const { extractImports } = require('./imports');
+const { isAccessorDefinition, findAccessorReferences } = require('./accessors');
 const isSafeRegex = require('safe-regex2');
 const { RE2JS } = require('re2js');
+const { UcnError } = require('./errors');
 
 // Keep the established search-input contract for the canonical catastrophic
 // nested-single-atom family even though the RE2-compatible engine could run it
@@ -331,7 +333,10 @@ function usages(index, name, options = {}) {
             const lines = content.split('\n');
 
             // Try AST-based detection first (with per-operation cache)
-            const astUsages = index._getCachedUsages(filePath, name);
+            // Refactoring internals also read each bare reference's lexical
+            // scope verdict (fix #392).
+            const astUsages = index._getCachedUsages(filePath, name,
+                options.internalEvidence ? { lexicalScopes: true } : undefined);
             if (astUsages !== null) {
                 for (const u of astUsages) {
                     // Skip if this is a definition line (already added above)
@@ -372,6 +377,11 @@ function usages(index, name, options = {}) {
                             ...(Number.isInteger(u.column) && { column: u.column }),
                             ...(u.receiverIsModule && { receiverIsModule: true }),
                             ...(u.receiverLocalBinding && { receiverLocalBinding: true }),
+                            ...(u.namespace && { namespace: u.namespace }),
+                            ...(u.scopeBinding && { scopeBinding: u.scopeBinding }),
+                            ...(u.scopeDefLines && { scopeDefLines: u.scopeDefLines }),
+                            ...(u.shorthandProperty && { shorthandProperty: true }),
+                            ...(u.importAlias && { importAlias: true }),
                         }),
                         ...(callerSym && {
                             callerName: callerSym.name,
@@ -476,13 +486,23 @@ function usages(index, name, options = {}) {
 
     // Deduplicate same-file, same-line, same-usageType entries
     // (e.g., `detectLanguage: parser.detectLanguage` has the name twice on one line)
-    const seen = new Set();
+    // Refactoring internals keep the other same-line records on the kept
+    // one (`sameLine`): every token of a line is decided (fix #392).
+    const seen = new Map();
     const deduped = [];
     for (const u of usagesList) {
         const key = `${u.file}:${u.line}:${u.usageType}:${u.isDefinition}`;
         if (!seen.has(key)) {
-            seen.add(key);
+            seen.set(key, u);
             deduped.push(u);
+        } else if (options.internalEvidence && !u.isDefinition) {
+            const kept = seen.get(key);
+            if (!kept.sameLine) {
+                Object.defineProperty(kept, 'sameLine', {
+                    value: [], enumerable: false, writable: true, configurable: true,
+                });
+            }
+            kept.sameLine.push(u);
         }
     }
     return deduped;
@@ -510,14 +530,14 @@ function search(index, term, options = {}) {
     let linearRegex = null;
     if (useRegex) {
         if (NESTED_SINGLE_ATOM_REPEAT.test(term)) {
-            throw new Error(
+            throw new UcnError(
                 `Unsafe regular expression "${term}": nested repetition is not accepted. Simplify it or use ripgrep.`,
             );
         }
         try {
             regex = new RegExp(term, regexFlags);
         } catch (e) {
-            throw new Error(
+            throw new UcnError(
                 `Invalid regular expression "${term}": ${e.message}`,
                 { cause: e },
             );
@@ -533,7 +553,7 @@ function search(index, term, options = {}) {
             linearRegex = RE2JS.compile(term, re2Flags);
         } catch (re2Error) {
             if (!isSafeRegex(term)) {
-                throw new Error(
+                throw new UcnError(
                     `Unsafe regular expression "${term}": this JavaScript-only pattern cannot run in UCN's linear-time engine and its repetition shape may backtrack catastrophically. Simplify it or use ripgrep.`,
                     { cause: re2Error },
                 );
@@ -1423,7 +1443,10 @@ function tests(index, nameOrFile, options = {}) {
             // Fast pre-check: skip if searchTerm doesn't appear in file
             if (!isFilePath && !content.includes(searchTerm) && !linkedRecords) continue;
             if (isFilePath && !linkedRecords && provenFileSites.length === 0) continue;
-            const sourceFileLinked = !sourceFileFilter || sourceFileFilter.has(testPath);
+            // A test importing the name through any chain of re-exports and
+            // renames the caller engine follows is linked too (fix #400).
+            const sourceFileLinked = !sourceFileFilter || sourceFileFilter.has(testPath) ||
+                _importBindingReachesTargets(index, entry, searchTerm, targetDefs);
             // A class-qualified query can still identify a possible test link
             // in source layouts that have no modeled module edge (notably
             // Rust macro/test fixtures). Keep it visibly unverified when the
@@ -1499,9 +1522,12 @@ function tests(index, nameOrFile, options = {}) {
                 // own definition (fix #246).
                 if (localShadow && !usage.receiver && usage.usageType !== 'import') 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
+                // matching second one.
                 const lineKey = `${usage.line}:${usage.usageType}`;
                 if (seenLines.has(lineKey)) continue;
-                seenLines.add(lineKey);
 
                 const lineContent = index.getLineContent(testPath, usage.line);
 
@@ -1529,6 +1555,7 @@ function tests(index, nameOrFile, options = {}) {
                     // where the receiver matches the target class.
                     if (!usage.receiver && matchType !== 'unverified-reference') continue;
                     if (!usage.receiver && matchType === 'unverified-reference') {
+                        seenLines.add(lineKey);
                         matches.push({
                             line: usage.line,
                             content: lineContent.trim(),
@@ -1544,6 +1571,7 @@ function tests(index, nameOrFile, options = {}) {
                     }
                 }
 
+                seenLines.add(lineKey);
                 matches.push({
                     line: usage.line,
                     content: lineContent.trim(),
@@ -1676,28 +1704,26 @@ function tests(index, nameOrFile, options = {}) {
             const info = testInfo.get(site.file);
             if (!info) continue;
             if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
-            // For a repeated name, the source-import scope is an additional
-            // identity guard. For a globally unique name, exact-target caller
-            // evidence is stronger than filesystem layout: workspace-level
-            // Rust tests, Go black-box packages, and generated test trees may
-            // exercise a crate/package without importing the defining file.
-            // Unverified sites remain visibly tiered; they are not promoted.
-            if (sourceFileFilter && !globallyUniqueTarget && !sourceFileFilter.has(site.file)) continue;
-            // A bare callback/reference/call can bind a standalone function
-            // with the same name, but it cannot identify a class method
-            // target. Use the parser's call-kind bit rather than requiring a
-            // textual receiver: fluent chains such as `.addStaticBlock(...)`
-            // have a call receiver but no simple receiver identifier. Rust
-            // proc-macro attribute references are handled by the AST usage
-            // branch above as explicitly unverified references.
-            if (className && !site.isMethod) continue;
+            // Every site here was adjudicated against the exact target
+            // definition by the caller engine (fix #402), so neither the file
+            // layout nor the call shape is a second identity test: a test
+            // reaches the target through a fixture-injected or inherited
+            // receiver without importing the defining file, and a
+            // receiver-less call reaches a method through implicit `this`, a
+            // static import, a destructured member or a macro-generated test
+            // body, exactly when the engine says so and in the tier it says.
+            // Unverified sites stay visibly tiered; they are not promoted.
             if (excludeArr.length > 0 &&
                 !index.matchesFilters(info.entry.relativePath, { exclude: excludeArr })) continue;
-            const localSameName = (info.entry.symbols || []).some(s => s.name === searchTerm);
-            const importsTargetName = (info.entry.importBindings || []).some(b => b.name === searchTerm);
-            const explicitlyScopedToLocal = !!options.file && targetDefs.some(d => d.file === site.file);
-            if (localSameName && !importsTargetName && !explicitlyScopedToLocal &&
-                !site.receiver && !site.isMethod) continue;
+            if (site._testEvidenceTier !== 'confirmed') {
+                // An unverified bare call in a test file that defines the
+                // name itself most likely binds that local definition.
+                const localSameName = (info.entry.symbols || []).some(s => s.name === searchTerm);
+                const importsTargetName = (info.entry.importBindings || []).some(b => b.name === searchTerm);
+                const explicitlyScopedToLocal = !!options.file && targetDefs.some(d => d.file === site.file);
+                if (localSameName && !importsTargetName && !explicitlyScopedToLocal &&
+                    !site.receiver && !site.isMethod) continue;
+            }
 
             let fileResult = results.find(r => r.file === info.entry.relativePath);
             if (!fileResult) {
@@ -1718,6 +1744,50 @@ function tests(index, nameOrFile, options = {}) {
             });
         }
 
+        // Accessor targets (fix #398F): a property is consumed by reads and
+        // writes, never call syntax, so the caller supplement above sees
+        // none of `result.stdout`. Test-file accessor references whose
+        // receiver identity the accessor engine proves are test links; the
+        // unverified ones join only for a globally unique name, as above.
+        const accessorDefs = targetDefs.filter(isAccessorDefinition);
+        if (accessorDefs.length > 0) {
+            const testPaths = new Set(testFiles.map(t => t.path));
+            const globallyUnique = index.find(searchTerm, { exact: true }).length === 1;
+            for (const def of accessorDefs) {
+                const refs = findAccessorReferences(index, searchTerm, def, { files: testPaths });
+                if (!refs) continue;
+                const rows = [
+                    ...refs.confirmed.map(r => ({ ...r, tierName: 'confirmed' })),
+                    ...(globallyUnique ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
+                ];
+                for (const ref of rows) {
+                    const info = testInfo.get(ref.absoluteFile);
+                    if (!info) continue;
+                    if (info.testRanges && !lineInRanges(ref.line, info.testRanges)) continue;
+                    if (excludeArr.length > 0 &&
+                        !index.matchesFilters(info.entry.relativePath, { exclude: excludeArr })) continue;
+                    let fileResult = results.find(r => r.file === info.entry.relativePath);
+                    if (!fileResult) {
+                        fileResult = { file: info.entry.relativePath, matches: [] };
+                        results.push(fileResult);
+                    }
+                    const matchType = ref.tierName === 'confirmed' ? 'reference' : 'unverified-reference';
+                    if (fileResult.matches.some(m => m.line === ref.line &&
+                        ['reference', 'unverified-reference', 'call', 'unverified-call'].includes(m.matchType))) continue;
+                    fileResult.matches = fileResult.matches.filter(m =>
+                        !(m.line === ref.line && m.matchType === 'test-case'));
+                    fileResult.matches.push({
+                        line: ref.line,
+                        content: ref.expression,
+                        matchType,
+                        evidenceTier: ref.tierName,
+                        ...(ref.resolution && { resolution: ref.resolution }),
+                        ...(ref.reason && { reason: ref.reason }),
+                    });
+                }
+            }
+        }
+
         for (const fileResult of results) {
             fileResult.matches.sort((a, b) => (a.line || 0) - (b.line || 0) ||
                 codeUnitCompare(a.matchType || '', b.matchType || ''));
@@ -1903,6 +1973,23 @@ function _buildSourceFileImporters(index, defs) {
     return importers;
 }
 
+/** Does an import binding of `name` in this file reach a target
+ * definition's file under that name (fix #400)? The caller engine's
+ * name-level export chase. */
+function _importBindingReachesTargets(index, fileEntry, name, targetDefs) {
+    if (!targetDefs || targetDefs.length === 0) return false;
+    const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
+    const { _nameBindingReaches } = require('./callers');
+    for (const binding of fileEntry.importBindings || []) {
+        if ((binding.alias || binding.name) !== name || binding.module == null) continue;
+        const rel = fileEntry.moduleResolved?.[binding.module];
+        if (!rel) continue;
+        const abs = path.isAbsolute(rel) ? rel : path.join(index.root, rel);
+        if (_nameBindingReaches(index, abs, binding.name, targetFiles, 8, { exactName: true }) === 'yes') return true;
+    }
+    return false;
+}
+
 /**
  * Check if a file re-exports a symbol from a source file.
  * Handles: named re-exports, `module.exports = require(...)` blanket re-exports,
@@ -1933,7 +2020,12 @@ function _fileReExportsSymbol(index, fileEntry, symbolName, sourceAbsPath) {
         !exp.name || exp.type === 'module.exports' || exp.type === 're-export' || exp.type === 'export-all'
     );
     if (hasBlanketExport) return true;
-    return false;
+    // `export * from './m'` re-exports every name of the module it names
+    // (fix #400): it carries the symbol on when that module is the file the
+    // chain came from.
+    return details.some(exp => exp.type === 're-export-all' && exp.source &&
+        fileEntry.moduleResolved?.[exp.source] &&
+        path.join(index.root, fileEntry.moduleResolved[exp.source]) === sourceAbsPath);
 }
 
 /**

package/core/shared.js

@@ -59,7 +59,10 @@ function codeUnitCompare(a, b) {
  */
 function isTestPath(rp) {
     if (!rp) return false;
-    const language = detectLanguage(rp);
+    // A `.h` header tests the same under the C and C++ conventions (neither
+    // has a `.spec` form, only C's patterns name `.h`): no header-language
+    // detection, which walks the project directory (fix #396).
+    const language = path.extname(rp).toLowerCase() === '.h' ? 'c' : detectLanguage(rp);
     const { langTraits } = require('../languages');
     const specConvention = langTraits(language)?.testFileCandidates?.('sample', '')
         .some(candidate => candidate.includes('.spec'));
@@ -484,6 +487,20 @@ function maskBlockComments(content, language) {
     return out.join('');
 }
 
+/**
+ * Is a definition invoked through the macro namespace (fix #377)? A Rust
+ * `macro_rules!` macro, or a procedural macro function (`#[proc_macro]`,
+ * `#[proc_macro_attribute]`, `#[proc_macro_derive]`). C/C++ preprocessor
+ * macros are type 'macro' too; their invocations are ordinary call syntax.
+ */
+function isMacroNamespaceDefinition(def) {
+    if (!def) return false;
+    if (def.type === 'macro') return true;
+    const modifiers = def.modifiers || [];
+    return modifiers.includes('proc_macro') || modifiers.includes('proc_macro_attribute') ||
+        modifiers.includes('proc_macro_derive');
+}
+
 module.exports = { literalNameRegex,
     pickBestDefinition,
     addTestExclusions,
@@ -503,4 +520,5 @@ module.exports = { literalNameRegex,
     hasTextBlindspots,
     countTextBlindspots,
     isPathInsideRoot,
+    isMacroNamespaceDefinition,
 };