ucn 5.4.2 → 5.5.1

package/core/account.js

@@ -69,6 +69,7 @@ const UNSUPPORTED_SITE_TEXT_MAX = 160;
  *   fileCount: number,                  // files (indexed + unparsed + unsupported) with >= 1 matching line
  *   perFile: Map<string, number[]>,     // absPath -> sorted 1-indexed line numbers (indexed files only)
  *   unparsed: { fileCount: number, lines: number, files: string[] },  // relative paths
+ *   recovered: { fileCount, lines, files, sites },  // matched lines inside parse-error recovery regions (subset of perFile)
  *   unsupported: { fileCount: number, lines: number, files: string[],
  *                  languages: Object<string, number>,
  *                  sites: Array<{file: string, line: number, text: string}>,
@@ -125,11 +126,39 @@ function computeGroundSet(index, name) {
         ? index.discoveryIssues.map(issue => ({ ...issue })) : [];
     unreadableFiles.sort();
 
+    // fix #367e: ground lines inside a parser-recovery region of an indexed
+    // file. They are classified like any other line, but from a partially
+    // parsed tree - disclosed, never silently trusted.
+    const recovered = { fileCount: 0, lines: 0, files: [], sites: [] };
+    for (const [filePath, matchedLines] of perFile) {
+        const regions = index.files.get(filePath)?.parseErrorRegions;
+        if (!regions || regions.length === 0) continue;
+        let inFile = 0;
+        let r = 0;
+        for (const line of matchedLines) {
+            while (r < regions.length && regions[r][1] < line) r++;
+            if (r < regions.length && regions[r][0] <= line) {
+                inFile++;
+                if (recovered.sites.length < 10) {
+                    recovered.sites.push({ file: path.relative(index.root, filePath), line });
+                }
+            }
+        }
+        if (inFile > 0) {
+            recovered.fileCount++;
+            recovered.lines += inFile;
+            recovered.files.push(path.relative(index.root, filePath));
+        }
+    }
+    recovered.files.sort(codeUnitCompare);
+    recovered.sites.sort((a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line);
+
     const result = {
         total: total + unparsed.lines + unsupported.lines,
         fileCount: fileCount + unparsed.fileCount + unsupported.fileCount,
         perFile,
         unparsed,
+        recovered,
         unsupported,
         unreadableFiles,
         skippedSources,
@@ -247,6 +276,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.
  *
@@ -260,7 +306,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 },
@@ -282,12 +328,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;
@@ -295,9 +341,10 @@ 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 cachedCalls = getCachedCallsBearing(index, filePath, name, new Set(unclaimed));
         const callLines = new Set();
         if (Array.isArray(cachedCalls)) {
             for (const c of cachedCalls) {
@@ -390,18 +437,21 @@ function buildAccount(index, name, parts) {
     const unverifiedEntries = parts.unverifiedEntries || [];
     const excludedEntries = parts.excludedEntries || [];
 
-    const groundKeys = new Set();
+    // (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).
@@ -425,7 +475,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
@@ -473,6 +523,7 @@ function buildAccount(index, name, parts) {
                     line: e.line, reason: e.reason, provenance: e.provenance })) }),
         },
         unparsed: groundSet.unparsed,
+        ...(groundSet.recovered?.lines > 0 && { recovered: groundSet.recovered }),
         unsupported,
         unreadableFiles: groundSet.unreadableFiles,
         skippedSources: groundSet.skippedSources || [],