ucn 5.5.1 → 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({
@@ -344,18 +366,31 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
         // Cheap pass: calls cache + symbol table (only records bearing the
         // name on unclaimed lines are read below).
         if (!getCachedCallsBearing) getCachedCallsBearing = require('./callers').getCachedCallsBearing;
-        const cachedCalls = getCachedCallsBearing(index, filePath, name, new Set(unclaimed));
+        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);
@@ -364,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 {
@@ -377,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)) {
@@ -433,9 +473,13 @@ 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 || [];
+    // 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
@@ -562,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,