ucn 5.5.3 → 5.6.0

package/core/bridge.js

@@ -522,6 +522,19 @@ const GO_ROUTER_MODULES = [
     [/^github\.com\/julienschmidt\/httprouter$/, 'httprouter'],
 ];
 
+// The framework labels a route or a request can carry. A label is known to
+// the `framework` filter when it is listed here or appears in the answer it
+// filters, so a label the answer prints is always one the filter takes.
+const ENDPOINT_FRAMEWORKS = Object.freeze([...new Set([
+    ...Object.values(SERVER_RECEIVER_PATTERNS).flat().map(pattern => pattern.framework),
+    ...Object.values(CLIENT_PATTERNS).flatMap(patterns => patterns.receivers).map(pattern => pattern.framework),
+    ...JS_ROUTER_MODULES.map(([, framework]) => framework),
+    ...GO_ROUTER_MODULES.map(([, framework]) => framework),
+    'actix', 'aiohttp', 'aspnet', 'django', 'fastapi', 'fetch', 'flask', 'go-inprocess',
+    'inject', 'jax-rs', 'nestjs', 'nextjs', 'request-helper', 'route-config', 'spring',
+    'starlette', 'supertest', 'unknown-python',
+])].sort());
+
 function frameworkOfModule(table, spec) {
     for (const [re, framework] of table) if (re.test(spec)) return framework;
     return null;
@@ -3138,6 +3151,7 @@ function endpoints(index, options = {}) {
 }
 
 module.exports = {
+    ENDPOINT_FRAMEWORKS,
     endpoints,
     extractServerRoutes,
     extractClientRequests,

package/core/cache.js

@@ -10,8 +10,8 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const {
-    expandGlob, detectProjectPattern, parseGitignore, gitTrackedPaths, gitListing, DEFAULT_IGNORES,
-    classifyUnsupportedSourceFile,
+    expandGlob, detectProjectPattern, parseGitignore, gitTrackedPaths, gitListing,
+    classifyUnsupportedSourceFile, projectDiscoveryOptions,
 } = require('./discovery');
 const { codeUnitCompare } = require('./shared');
 const { syntaxWeightKind } = require('./source-memo');
@@ -998,7 +998,24 @@ function clearAllCaches() {
 // v326: C++ files retain raw base-clause positions and their syntactic scopes.
 // v327: Python explicit-argument super calls retain a producer, not a lexical parent receiver.
 // v328: ambiguous C++ direct initializers retain empty template-call records.
-const CACHE_FORMAT_VERSION = 330;
+// v331: source paths excluded by .ucn.json are recorded one issue per source
+// file (searched as text per name), with `outside-project` and
+// `text-scan-budget` reasons; parse-failed files keep their size and mtime.
+// v332: members a subtype or a structural satisfier must supply carry
+// `requiredMember` (interface and object-type signatures that are not
+// optional, abstract members, bodiless trait methods, Go interface method
+// elements, Python abstract and Protocol members, C++ pure virtuals); a
+// Python protocol class carries `protocolClass`.
+// v333: a JS/TS file's `moduleAssignedNames` leaves out writes to a name a
+// function or block declares itself (they never reach the module's binding);
+// a Python call whose only argument is a bare generator counts one argument.
+// v334: file entries carry `reflectionUses` and `evalUses`, call sites of the
+// language's reflection and code-execution vocabulary counted in the tree at
+// index time (`repo` and the completeness footer counted them by reading
+// every file's text on each query).
+// v335: reflection/eval facts follow commented and parenthesized callees;
+// package reflection qualifiers retain Unicode names and lexical ownership.
+const CACHE_FORMAT_VERSION = 335;
 const USAGE_CACHE_FILE = 'usage-results.json';
 
 function usageResultKey(index, filePath, name, mode) {
@@ -1141,6 +1158,12 @@ function saveCache(index, cachePath) {
 
     const cacheFile = cachePath || path.join(cacheDir, 'index.json');
 
+    // HOT rankings stored for the generation in memory describe the state
+    // this save writes: read them before the generation is replaced, and
+    // store them again under the new one below.
+    const hotSummary = require('./hot-summary');
+    hotSummary.ensure(index);
+
     // A partially loaded (per-file) calls cache must be complete before it
     // is rewritten: the shard directory is replaced wholesale below.
     if (index._callsCachePrepared && !index._callsCacheLoaded) {
@@ -1270,6 +1293,9 @@ function saveCache(index, cachePath) {
         failedFiles: index.failedFiles
             ? Array.from(index.failedFiles).map(f => path.relative(root, f))
             : [],
+        // A parse failure is retried when its file changes: keep what the
+        // file looked like when it failed.
+        failedFileStats: failedFileStats(index, root),
         unsupportedFiles: Array.isArray(index.unsupportedFiles)
             ? index.unsupportedFiles
             : [],
@@ -1314,6 +1340,7 @@ function saveCache(index, cachePath) {
     const tmpFile = cacheFile + '.tmp';
     fs.writeFileSync(tmpFile, JSON.stringify(cacheData));
     fs.renameSync(tmpFile, cacheFile);
+    index._cacheDir = path.dirname(cacheFile);
 
     // MED-1 (Round 5): clear the reachabilityDirty flag now that the set is
     // safely persisted. The cli/index.js cache-save guard checks this flag
@@ -1384,6 +1411,11 @@ function saveCache(index, cachePath) {
         }
     }
 
+    // A failed save must not authorize a summary for a state that was never
+    // completely written. In particular, direct indexFile mutations cannot
+    // publish against the old calls generation while only in memory.
+    hotSummary.adoptSavedGeneration(index);
+    try { hotSummary.save(index, cacheFile); } catch (_) { /* the ranking is computed again */ }
     if (!cachePath) pruneUserCache();
     return cacheFile;
 }
@@ -1453,6 +1485,7 @@ function loadCache(index, cachePath) {
         index._clearParsedTreeCache?.();
         index._groundSetCache = new Map();
         index._groundSetCacheLines = 0;
+        index._sourceUniverse = null;
         index._nameBindingReachCache = new Map();
         index._returnTypeFlowCache = new Map();
         index._classIdentity = null;
@@ -1533,6 +1566,9 @@ function loadCache(index, cachePath) {
             ? cacheData.callsGeneration : null;
         index._callNameCache = null;
         index._callNameCacheReadGeneration = null;
+        // HOT rankings stored beside this file are read when one is asked.
+        index._cacheDir = path.dirname(cacheFile);
+        require('./hot-summary').forget(index);
 
         // Prepare lazy calls cache loading — load manifest but defer shard parsing.
         // Shards are loaded on first getCachedCalls access via ensureCallsCacheLoaded().
@@ -1551,6 +1587,8 @@ function loadCache(index, cachePath) {
                 cacheData.failedFiles.map(f => path.isAbsolute(f) ? f : toAbs(f))
             );
         }
+        index._failedFileStats = new Map(Object.entries(cacheData.failedFileStats || {})
+            .map(([relative, stat]) => [toAbs(relative), { size: stat[0], mtimeMs: stat[1] }]));
         index.unsupportedFiles = Array.isArray(cacheData.unsupportedFiles)
             ? cacheData.unsupportedFiles
             : [];
@@ -1651,6 +1689,17 @@ function loadCache(index, cachePath) {
  * @param {object} index - ProjectIndex instance
  * @returns {boolean} - True if cache needs rebuilding
  */
+function failedFileStats(index, root) {
+    const stats = {};
+    // Only what the build recorded at the failure: a stat taken now could
+    // describe a file that was repaired since.
+    for (const failedPath of index.failedFiles || []) {
+        const known = index._failedFileStats && index._failedFileStats.get(failedPath);
+        if (known) stats[path.relative(root, failedPath)] = [known.size, known.mtimeMs];
+    }
+    return stats;
+}
+
 function isCacheStale(index) {
     const currentConfigHash = crypto.createHash('md5')
         .update(JSON.stringify(index.config || {})).digest('hex');
@@ -1706,6 +1755,38 @@ function isCacheStale(index) {
         }
     }
 
+    // A file that failed to parse is a source file: when it changes, a
+    // build must try it again (it is in no other sweep, so a repaired file
+    // used to stay "failed" until something else forced a rebuild).
+    if (index.failedFiles && index.failedFiles.size > 0) {
+        for (const failedPath of index.failedFiles) {
+            if (index.files.has(failedPath)) continue;
+            let stat;
+            try { stat = fs.statSync(failedPath); } catch (_) { return true; }
+            // The build records what the file looked like when it failed
+            // (ProjectIndex._noteFailedFile). Without that record nothing
+            // shows the file is unchanged, so it is tried again: reading the
+            // stat here instead would call a repaired file "unchanged".
+            const known = index._failedFileStats && index._failedFileStats.get(failedPath);
+            if (!known || known.size !== stat.size || known.mtimeMs !== stat.mtimeMs) return true;
+        }
+    }
+
+    // Text-only source (core/source-universe.js) is searched per name, never
+    // indexed. An edit that leaves a file text-only changes no symbol: the
+    // classification is refreshed and name scans are dropped, with no
+    // rebuild. An edit that can change WHAT is indexed (a file gone, an
+    // oversized file back under the limit) is a rebuild.
+    const discovery = projectDiscoveryOptions(index.root, index.config || {},
+        { includeBundled: index.includeBundled === true });
+    const refreshed = require('./source-universe').refreshTextOnly(index,
+        { maxFileSize: discovery.maxFileSize ?? (8 * 1024 * 1024) });
+    if (refreshed === 'reindex') return true;
+    if (refreshed === 'refreshed') {
+        index._groundSetCache = new Map();
+        index._groundSetCacheLines = 0;
+    }
+
     // Cargo manifests steer Rust import resolution (fix #372).
     if (index.cargoManifests &&
         !require('./imports').workspaceManifestsCurrent(index.root, index.cargoManifests)) {
@@ -1723,13 +1804,14 @@ function isCacheStale(index) {
     // Only reached when all cached files are unchanged.
     const pattern = detectProjectPattern(index.root);
     const currentUnsupported = [];
-    const currentBundled = [];
+    const currentIssues = [];
     const currentManifests = [];
+    // The same options the build used (shared with project.js): a walk that
+    // reads the configuration differently sees a different file set.
     const globOpts = {
-        root: index.root,
-        includeBundled: index.includeBundled === true,
+        ...discovery,
         onDiscoveryIssue: issue => {
-            if (issue.reason === 'bundled') currentBundled.push(path.relative(index.root, issue.path));
+            currentIssues.push(`${issue.reason}\0${path.relative(index.root, issue.path || index.root) || '.'}`);
         },
         onSkippedFile: (filePath) => {
             if (path.basename(filePath) === 'Cargo.toml') {
@@ -1746,16 +1828,19 @@ function isCacheStale(index) {
     if (!gitignoreRules) gitignoreRules = parseGitignore(index.root, gitListingOnce());
     globOpts.gitignoreRules = gitignoreRules;
     globOpts.trackedPaths = gitTrackedPaths(index.root, gitListingOnce());
-    const configExclude = index.config.exclude || [];
-    if (configExclude.length > 0) {
-        globOpts.ignores = [...DEFAULT_IGNORES, ...configExclude];
-    }
     const currentFiles = expandGlob(pattern, globOpts);
-    const cachedBundled = (index.discoveryIssues || [])
-        .filter(issue => issue.reason === 'bundled').map(issue => issue.relativePath).sort();
-    currentBundled.sort();
-    if (cachedBundled.length !== currentBundled.length ||
-        cachedBundled.some((value, i) => value !== currentBundled[i])) return true;
+    // Every path the walk reports as not indexed, with its reason: a file
+    // that became a bundle, crossed the size limit, entered or left an
+    // excluded path changes what a claim ranges over. Issues the build
+    // records about itself (an unusable config, a failed git listing) are
+    // not the walk's to compare.
+    const BUILD_ISSUES = new Set(['invalid-config', 'git-listing-failed']);
+    const cachedIssues = [...new Set((index.discoveryIssues || [])
+        .filter(issue => !BUILD_ISSUES.has(issue.reason))
+        .map(issue => `${issue.reason}\0${issue.relativePath || '.'}`))].sort();
+    const walkedIssues = [...new Set(currentIssues)].sort();
+    if (cachedIssues.length !== walkedIssues.length ||
+        cachedIssues.some((value, i) => value !== walkedIssues[i])) return true;
     const cachedPaths = new Set(index.files.keys());
     const currentPaths = new Set(currentFiles);