ucn 5.5.2 → 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;
@@ -2279,53 +2292,6 @@ function extractNextjsRoutes(index) {
  * Detect HTTP client requests across the project.
  * Cached on `index._endpointsCache.clientRequests`.
  */
-// Python HTTP client types whose instances are receivers of request calls.
-// A receiver typed to one of these (with-binding, constructor assignment) or
-// bound to a pytest fixture that constructs one is a client by evidence, not
-// by name (fix #349: 145 of 625 real `tc.get("/api/...")` sites on one repo
-// were invisible because the receiver was not literally named `client`).
-const PY_CLIENT_TYPES = new Set([
-    'TestClient', 'Client', 'AsyncClient', 'Session', 'FlaskClient',
-    'ClientSession', 'AsyncSession', 'HTTPConnection', 'HTTPSConnection',
-]);
-const PY_CLIENT_FACTORIES = new Set(['test_client', 'Session', 'Client', 'AsyncClient']);
-const PY_REQUEST_METHODS = /^(get|post|put|delete|patch|options|head|request)$/;
-
-function _pythonClientFixtures(index) {
-    if (index._endpointsCache?.pyClientFixtures) return index._endpointsCache.pyClientFixtures;
-    const fixtures = new Set();
-    for (const [filePath, fileEntry] of index.files) {
-        if (fileEntry.language !== 'python') continue;
-        const fixtureDefs = (fileEntry.symbols || []).filter(s =>
-            (s.decorators || []).some(d => /(^|\.)fixture$/.test(String(d))));
-        if (fixtureDefs.length === 0) continue;
-        const calls = getCachedCalls(index, filePath) || [];
-        for (const def of fixtureDefs) {
-            const constructsClient = calls.some(c =>
-                c.enclosingFunction?.name === def.name &&
-                c.enclosingFunction?.startLine === def.startLine &&
-                (PY_CLIENT_TYPES.has(c.name) || (c.isMethod && PY_CLIENT_FACTORIES.has(c.name))));
-            if (constructsClient) fixtures.add(def.name);
-        }
-    }
-    if (!index._endpointsCache) index._endpointsCache = {};
-    index._endpointsCache.pyClientFixtures = fixtures;
-    return fixtures;
-}
-
-function _pythonClientReceiver(index, fileEntry, call, fixtures) {
-    if (!call.isMethod || !call.receiver || !PY_REQUEST_METHODS.test(call.name)) return null;
-    if (call.receiverType && PY_CLIENT_TYPES.has(String(call.receiverType).split('.').pop())) {
-        return 'python-client';
-    }
-    if (fixtures.size === 0 || !fixtures.has(call.receiver)) return null;
-    const fn = call.enclosingFunction;
-    if (!fn) return null;
-    const sym = (fileEntry.symbols || []).find(s => s.name === fn.name && s.startLine === fn.startLine);
-    const params = String(sym?.params || '').split(',').map(p => p.trim().split(/[:=]/)[0].trim());
-    return params.includes(call.receiver) ? 'pytest-client-fixture' : null;
-}
-
 // `fastify().route({...})` - a route declared on a freshly built server.
 const JS_SERVER_FACTORY_CALL = /^(fastify|Fastify|express|Hono|Koa)$/;
 
@@ -2347,7 +2313,7 @@ function extractClientRequests(index) {
     }
     const requests = [];
     const uncertain = [];
-    const pyFixtures = _pythonClientFixtures(index);
+    const clientProof = new (require('./client-receivers').ClientReceiverProof)(index, endpointsSession(index));
     let helperProof = null;
 
     for (const [filePath, fileEntry] of index.files) {
@@ -2431,7 +2397,9 @@ function extractClientRequests(index) {
                     continue;
                 }
                 if (!helperProof) helperProof = new RequestHelperProof(index, endpointsSession(index));
-                const proof = helperProof.classify(filePath, call);
+                const proof = call.isMethod
+                    ? { proven: !!clientProof.classify(filePath, call), reason: 'receiver-unproven' }
+                    : helperProof.classify(filePath, call);
                 const verb = call.isMethod && /^(get|post|put|delete|patch|options|head)$/i.test(call.name)
                     ? call.name.toUpperCase() : null;
                 const method = cfg.method || verb || 'ALL';
@@ -2462,7 +2430,7 @@ function extractClientRequests(index) {
             // fix #383: Go request constructors read their method and URL
             // from their own argument positions.
             if (call.requestTarget && lang === 'go' && call.receiver && !call.isPathCall &&
-                matchClientRequest({ ...call, firstStringArg: call.requestTarget.url }, lang, calls)) {
+                matchClientRequest({ ...call, firstStringArg: call.requestTarget.url }, lang, clientProof.classify(filePath, call))) {
                 const target = call.requestTarget;
                 if (isPathShaped(target.url)) {
                     // A request with a path but no scheme and host cannot be
@@ -2496,26 +2464,22 @@ function extractClientRequests(index) {
                 continue;
             }
             if (!call.firstStringArg) continue;
-            let r = matchClientRequest(call, lang, calls);
-            if (!r && lang === 'python') {
-                const framework = _pythonClientReceiver(index, fileEntry, call, pyFixtures);
-                if (framework) {
-                    r = { method: call.name.toUpperCase() === 'REQUEST' ? 'ALL' : call.name.toUpperCase(),
-                        framework, methodInferred: call.name === 'request' };
-                }
-            }
+            const conf = CLIENT_PATTERNS[lang];
+            const candidate = conf && (conf.bareCalls.has(call.name) ||
+                conf.receivers.some(p => p.methodPattern.test(call.name)));
+            const r = matchClientRequest(call, lang, candidate ? clientProof.classify(filePath, call) : null);
             if (!r) {
                 // Visible uncertainty: request-shaped call on an unrecognized
                 // receiver with a path-shaped literal. Listed, never counted.
-                const conf = CLIENT_PATTERNS[lang];
                 const pathShaped = call.firstStringArg.startsWith('/') || call.firstStringArg.includes('://');
-                if (conf && call.isMethod && call.receiver && pathShaped &&
+                if (conf && call.receiver && pathShaped &&
                     conf.receivers.some(p => p.methodPattern.test(call.name))) {
                     uncertain.push({
                         receiver: call.receiver, method: call.name, path: call.firstStringArg,
                         file: fileEntry.relativePath || filePath, absoluteFile: filePath, line: call.line,
                         callerName: call.enclosingFunction?.name || '<top-level>',
-                        reason: 'receiver-unrecognized',
+                        reason: conf.receivers.some(p => p.receiverPattern.test(call.receiver))
+                            ? 'receiver-name-only' : 'receiver-unrecognized',
                     });
                 }
                 continue;
@@ -2640,9 +2604,9 @@ function supertestProducerOf(call, calls, producers, locals) {
  * Match a call against client request patterns.
  * Returns { method, framework, methodInferred } or null.
  */
-function matchClientRequest(call, lang, allCallsInFile) {
+function matchClientRequest(call, lang, origin) {
     const conf = CLIENT_PATTERNS[lang];
-    if (!conf) return null;
+    if (!conf || !origin) return null;
 
     // 1) Bare-call patterns: fetch('/path') or fetch('/path', { method: 'POST' })
     if (!call.isMethod && conf.bareCalls.has(call.name)) {
@@ -2662,7 +2626,6 @@ function matchClientRequest(call, lang, allCallsInFile) {
     const isMethodLike = call.isMethod || (lang === 'go' && !!call.receiver && !call.isPathCall);
     if (isMethodLike && call.receiver) {
         for (const p of conf.receivers) {
-            if (!p.receiverPattern.test(call.receiver)) continue;
             if (!p.methodPattern.test(call.name)) continue;
 
             // Determine method
@@ -2697,7 +2660,7 @@ function matchClientRequest(call, lang, allCallsInFile) {
             } else {
                 method = methodName.toUpperCase();
             }
-            return { method, framework: p.framework, methodInferred: inferred };
+            return { method, framework: origin, methodInferred: inferred };
         }
     }
 
@@ -3188,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);