ucn 5.5.0 → 5.5.2

package/core/account.js

@@ -36,7 +36,7 @@
  * Ground-set semantics are grep `-n -w`: unit is the (file, line) pair, each
  * line with >= 1 word-boundary match counts once, case-sensitive.
  *
- * Performance: the first ground scan is one `includes()`-gated read per project
+ * Performance: the first ground scan is one literal-name-gated read per project
  * file — the same I/O profile as the existing `search`/`usages` commands.
  * Exact results are retained in a small LRU for the lifetime of one built index
  * so context/about/impact projections of the same symbol do not rescan the
@@ -53,6 +53,7 @@
 const fs = require('fs');
 const path = require('path');
 const { codeUnitCompare, literalNameRegex } = require('./shared');
+const { compareNames } = require('./discovery');
 
 // Unsupported-language site listings are capped so a Rails-sized repo cannot
 // flood the account object; the counts always cover the full set.
@@ -84,7 +85,7 @@ function computeGroundSet(index, name) {
         index._groundSetCache.set(name, cached);
         return cached.result;
     }
-    const wordRe = literalNameRegex(name);
+    const wordRe = literalNameRegex(name, name ? 'y' : '');
     const perFile = new Map();
     let total = 0;
     let fileCount = 0;
@@ -96,14 +97,7 @@ function computeGroundSet(index, name) {
         } catch (e) {
             continue; // deleted since indexing; not part of the universe anymore
         }
-        if (!content.includes(name)) continue;
-        // Shared read-only lines array — split once per file per operation,
-        // reused across the symbols of a multi-symbol command (diff-impact).
-        const lines = index._getFileLines(filePath);
-        const matched = [];
-        for (let i = 0; i < lines.length; i++) {
-            if (wordRe.test(lines[i])) matched.push(i + 1);
-        }
+        const matched = matchingGroundLines(content, name, wordRe);
         if (matched.length > 0) {
             perFile.set(filePath, matched);
             total += matched.length;
@@ -180,6 +174,34 @@ function computeGroundSet(index, name) {
     return result;
 }
 
+// Find literal candidates natively, checking the same Unicode boundaries
+// at their exact offsets. Count line breaks only up to matching positions;
+// once a line matches, its remaining occurrences cannot change the account.
+function matchingGroundLines(content, name, wordRe) {
+    if (name.includes('\n')) return [];
+    if (!name) return content.split('\n').flatMap((line, i) => wordRe.test(line) ? [i + 1] : []);
+    const matched = [];
+    let at = content.indexOf(name);
+    if (at === -1) return matched;
+    let line = 1, end = content.indexOf('\n');
+    while (at !== -1) {
+        wordRe.lastIndex = at;
+        if (wordRe.test(content)) {
+            while (end !== -1 && end < at) {
+                line++;
+                end = content.indexOf('\n', end + 1);
+            }
+            matched.push(line);
+            if (end === -1) break;
+            at = content.indexOf(name, end + 1);
+        } else {
+            // A rejected candidate can overlap a later valid occurrence.
+            at = content.indexOf(name, at + 1);
+        }
+    }
+    return matched;
+}
+
 /** Scan only files the parser/index could not ingest. */
 function scanFailedFiles(index, name) {
     const unparsed = { fileCount: 0, lines: 0, files: [] };
@@ -200,7 +222,7 @@ function scanFailedFiles(index, name) {
         if (!content.includes(name)) continue;
         let matched = 0;
         for (const line of content.split('\n')) {
-            if (wordRe.test(line)) matched++;
+            if (line.includes(name) && wordRe.test(line)) matched++;
         }
         if (matched > 0) {
             unparsed.fileCount++;
@@ -248,7 +270,7 @@ function scanUnsupportedFiles(index, name, opts = {}) {
         const lines = content.split('\n');
         let matched = 0;
         for (let i = 0; i < lines.length; i++) {
-            if (!wordRe.test(lines[i])) continue;
+            if (!lines[i].includes(name) || !wordRe.test(lines[i])) continue;
             matched++;
             if (unsupported.sites.length < UNSUPPORTED_SITE_CAP) {
                 unsupported.sites.push({
@@ -276,6 +298,23 @@ function scanUnsupportedFiles(index, name, opts = {}) {
     return unsupported;
 }
 
+/**
+ * A set of (file, line) keys held per file: `key(file, line)` names one,
+ * and `add`/`has` take a key or a (file, line) pair. Lines compare by their
+ * text, as `${file}:${line}` strings do.
+ */
+class LineKeys {
+    constructor() { this.byFile = new Map(); }
+    key(file, line) { return { file: String(file), line: String(line) }; }
+    add(file, line) {
+        const key = line === undefined ? file : this.key(file, line);
+        let lines = this.byFile.get(key.file);
+        if (!lines) this.byFile.set(key.file, lines = new Set());
+        lines.add(key.line);
+    }
+    has(key) { return this.byFile.get(key.file)?.has(key.line) === true; }
+}
+
 /**
  * Classify ground lines not claimed by engine results.
  *
@@ -289,7 +328,7 @@ function scanUnsupportedFiles(index, name, opts = {}) {
  * @param {object} index - ProjectIndex
  * @param {string} name - Symbol name
  * @param {object} groundSet - from computeGroundSet
- * @param {Set<string>} claimedKeys - `${absPath}:${line}` keys already claimed
+ * @param {LineKeys} claimedKeys - (absPath, line) keys already claimed
  *   (confirmed + unverified + excluded engine lines)
  * @returns {{
  *   nonCall: { imports: number, definitions: number, references: number, unclassifiedText: number, total: number },
@@ -311,12 +350,12 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
         if (!defLinesByFile.has(def.file)) defLinesByFile.set(def.file, new Set());
         defLinesByFile.get(def.file).add(def.startLine);
     }
-    let getCachedCalls = null; // lazy require to avoid cycle at module load
+    let getCachedCallsBearing = null; // lazy require to avoid cycle at module load
 
     for (const [filePath, lineNumbers] of groundSet.perFile) {
         let unclaimed = null;
         for (const line of lineNumbers) {
-            if (claimedKeys.has(`${filePath}:${line}`)) continue;
+            if (claimedKeys.has(claimedKeys.key(filePath, line))) continue;
             (unclaimed || (unclaimed = [])).push(line);
         }
         if (!unclaimed) continue;
@@ -324,20 +363,34 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
         const fileEntry = index.files.get(filePath);
         const relativePath = fileEntry ? fileEntry.relativePath : path.relative(index.root, filePath);
 
-        // Cheap pass: calls cache + symbol table
-        if (!getCachedCalls) getCachedCalls = require('./callers').getCachedCalls;
-        const cachedCalls = getCachedCalls(index, filePath);
+        // Cheap pass: calls cache + symbol table (only records bearing the
+        // name on unclaimed lines are read below).
+        if (!getCachedCallsBearing) getCachedCallsBearing = require('./callers').getCachedCallsBearing;
+        const unclaimedLines = new Set(unclaimed);
+        const cachedCalls = getCachedCallsBearing(index, filePath, name, unclaimedLines);
+        const recordIsNoCall = require('./callers')._recordIsNoCall;
         const callLines = new Set();
+        // `(T)(x)` casts: uses of the type, not calls (fix #427).
+        let castLines = null;
         if (Array.isArray(cachedCalls)) {
             for (const c of cachedCalls) {
+                // The ordinary cache can return the whole file. Only these
+                // name-bearing, unclaimed lines can affect this account.
+                if (!(c.name === name || c.resolvedName === name ||
+                    (c.resolvedNames && c.resolvedNames.includes(name))) || !unclaimedLines.has(c.line)) continue;
                 // Unclaimed callback/type references have no invocation
                 // syntax. Let the usage AST classify them as references;
                 // merely entering the candidate cache is not a call fact.
-                if (c.isFunctionReference || c.isTypeReference) continue;
-                if (c.name === name || c.resolvedName === name ||
-                    (c.resolvedNames && c.resolvedNames.includes(name))) {
-                    callLines.add(c.line);
+                // An implicit initializer has no written invocation either.
+                if (c.isFunctionReference || c.isTypeReference || c.constructorSyntax === 'implicit') continue;
+                // Nor a data member's mem-initializer or a default
+                // initialization of no class (fix #421).
+                if ((c.memberInitializer || c.constructorSyntax === 'default') && recordIsNoCall(index, filePath, c)) continue;
+                if (c.parenthesizedCallee && c.name === name && recordIsNoCall(index, filePath, c)) {
+                    (castLines ||= new Set()).add(c.line);
+                    continue;
                 }
+                callLines.add(c.line);
             }
         }
         const defLines = defLinesByFile.get(filePath);
@@ -346,6 +399,8 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
         for (const line of unclaimed) {
             if (callLines.has(line)) {
                 callNotResolved.push({ file: filePath, relativePath, line });
+            } else if (castLines?.has(line)) {
+                nonCall.references++;
             } else if (defLines && defLines.has(line)) {
                 nonCall.definitions++;
             } else {
@@ -359,8 +414,11 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
         // Call lines were classified from the complete calls cache above.
         // Language adapters may skip usage-only call recovery here; notably,
         // C/C++ avoids reparsing every matching macro replacement list.
+        // Only occurrence kinds are consumed below, so receiver ownership
+        // is optional on this path too.
         const usages = index._getCachedUsages(filePath, name, {
             skipCallRecovery: true,
+            usageKindsOnly: true,
         });
         const byLine = new Map();
         if (Array.isArray(usages)) {
@@ -415,22 +473,29 @@ const RANK = { call: 0, import: 1, definition: 2, reference: 3 };
  */
 function buildAccount(index, name, parts) {
     const { groundSet } = parts;
-    const confirmedEntries = parts.confirmedEntries || [];
-    const unverifiedEntries = parts.unverifiedEntries || [];
-    const excludedEntries = parts.excludedEntries || [];
-
-    const groundKeys = new Set();
+    // Entries in (file, line) order, stable (fix #407): samples, the evidence
+    // list and the reason of a line excluded twice must not follow the order
+    // the engine visited files in, which a warm session's derivation history
+    // changes.
+    const confirmedEntries = sortedSites(parts.confirmedEntries || []);
+    const unverifiedEntries = sortedSites(parts.unverifiedEntries || []);
+    const excludedEntries = sortedSites(parts.excludedEntries || []);
+
+    // (file, line) keys, kept per file (fix #405b: one composed string per
+    // ground line and per entry); a line is keyed by its text, as the
+    // composed `${file}:${line}` keys were.
+    const groundKeys = new LineKeys();
     for (const [filePath, lineNumbers] of groundSet.perFile) {
-        for (const line of lineNumbers) groundKeys.add(`${filePath}:${line}`);
+        for (const line of lineNumbers) groundKeys.add(filePath, line);
     }
 
-    const claimedKeys = new Set();
+    const claimedKeys = new LineKeys();
     const beyondText = { count: 0, sample: [] };
     let confirmed = 0;
     let unverified = 0;
 
     const claim = (entry, bucket) => {
-        const key = `${entry.file}:${entry.line}`;
+        const key = claimedKeys.key(entry.file, entry.line);
         if (claimedKeys.has(key)) return; // one bucket per line; first claim wins
         if (!groundKeys.has(key)) {
             // Engine found a call site grep would miss (alias / indirect name).
@@ -454,7 +519,7 @@ function buildAccount(index, name, parts) {
     const excludedByReason = {};
     let excludedTotal = 0;
     for (const e of excludedEntries) {
-        const key = `${e.file}:${e.line}`;
+        const key = claimedKeys.key(e.file, e.line);
         if (claimedKeys.has(key)) continue;
         claimedKeys.add(key);
         if (!groundKeys.has(key)) continue; // excluded non-ground line: irrelevant to both grep and display
@@ -541,6 +606,16 @@ function relPath(index, filePath) {
     return fileEntry ? fileEntry.relativePath : path.relative(index.root, filePath);
 }
 
+/** Sites by (file in the index's canonical order, line), stable; the input
+ * itself when already in that order, else a sorted copy (fix #407). */
+function sortedSites(entries) {
+    const before = (a, b) => compareNames(String(a.file), String(b.file)) || ((a.line || 0) - (b.line || 0));
+    for (let i = 1; i < entries.length; i++) {
+        if (before(entries[i - 1], entries[i]) > 0) return [...entries].sort(before);
+    }
+    return entries;
+}
+
 module.exports = {
     computeGroundSet,
     classifyGroundLines,