ucn 5.5.3 → 5.6.1

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,26 @@ 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.
+// v336 (fixes #501/#503): binding-resolved Python registration/reflection,
+// nested runtime owner paths, JS computed calls, and owned Rust attributes.
+const CACHE_FORMAT_VERSION = 336;
 const USAGE_CACHE_FILE = 'usage-results.json';
 
 function usageResultKey(index, filePath, name, mode) {
@@ -1141,6 +1160,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 +1295,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 +1342,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 +1413,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 +1487,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 +1568,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 +1589,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 +1691,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 +1757,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 +1806,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 +1830,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);
 

package/core/call-fit.js

@@ -0,0 +1,130 @@
+/** Positive, deliberately bounded argument-fit proofs for changed calls. */
+'use strict';
+
+const { langTraits } = require('../languages');
+const { argumentProvablyConverts, cppArgumentProvablyConverts } = require('./callers');
+
+function literalKind(argument) {
+    if (argument?.kind === 'number_literal' && /^\d+$/.test(argument.text || '') &&
+        Number(argument.text) <= 127) return 'smallInteger';
+    // Prefixes can change the type (Python bytes, C++ encoded strings).
+    // Only plain quoted strings belong to this bounded proof domain.
+    if (argument?.kind === 'string_literal' && ['"', "'"].includes(argument.text?.[0])) return 'string';
+    if (['true', 'false', 'boolean_literal'].includes(argument?.nodeType)) return 'boolean';
+    return null;
+}
+
+/** A written builtin type cannot borrow a project or imported namesake. */
+function unshadowed(index, definition, type) {
+    const simple = String(type || '').replace(/^&/, '').trim();
+    if ((index.symbols.get(simple) || []).length) return false;
+    const entry = index.files.get(definition.file);
+    if ((entry?.importDetails || []).some(detail => detail.type === 'from' && detail.names?.includes('*'))) return false;
+    return !(entry?.importBindings || []).some(binding => binding.name === '*' || binding.kind === 'wildcard' ||
+        binding.name === simple || binding.local === simple || binding.alias === simple);
+}
+
+function unavailableSurface(index, definition, caller) {
+    const sameOwner = caller.file === definition.file && caller.className && caller.className === definition.className &&
+        (caller.namespace || null) === (definition.namespace || null) &&
+        (caller.enclosingType || null) === (definition.enclosingType || null);
+    const uncertain = member => member.isAbstract || (member.modifiers || []).includes('abstract') || (member.decorators || []).length > 0 ||
+        !sameOwner && (member.modifiers || []).some(modifier => ['private', 'protected'].includes(modifier));
+    if (uncertain(definition)) return true;
+    if (definition.initializerOf) {
+        const owners = (index.symbols.get(definition.initializerOf) || []).filter(owner => owner.type === 'class');
+        if (owners.length !== 1 || uncertain(owners[0])) return true;
+    }
+    if (definition.type !== 'class') return false;
+    const entry = index.files.get(definition.file);
+    return (entry?.symbols || []).some(member => member.className === definition.name &&
+        member.startLine >= definition.startLine && member.startLine <= definition.endLine &&
+        (member.type === 'constructor' || member.isConstructor ||
+            ['constructor', '__init__'].includes(member.name)) && uncertain(member));
+}
+
+/** A visible checked-JS/JSDoc contract withdraws the dynamic-only proof. */
+function typedComments(index, file) {
+    const trait = langTraits(index.files.get(file)?.language)?.checkTypedComment;
+    if (!trait) return false;
+    const memo = index._opMemo?.('checkTypedComments', () => new Map());
+    if (memo?.has(file)) return memo.get(file);
+    let found = true;
+    try {
+        const source = index._readFile(file);
+        const root = index._getParsedTree(file, source, index.files.get(file)?.language)?.rootNode;
+        if (root) found = root.descendantsOfType('comment').some(comment => trait(comment.text));
+    } catch (_) { /* unread checking context stays unknown */ }
+    memo?.set(file, found);
+    return found;
+}
+
+/** True is a proof for this small domain; false means review, not mismatch. */
+function positivelyFits(index, definition, caller, record, result, stableInvocation = false) {
+    // A changed call may reuse its baseline availability only under an
+    // unchanged invocation context. Count/type fit alone cannot prove a
+    // new invocation, a receiver/generic/passing-mode change, or its result
+    // use valid. Constructors and their implementation projections are
+    // outside this proof: the public overload interface is not the body.
+    if (!stableInvocation || definition.initializerOf || definition.isConstructor ||
+        ['class', 'struct', 'record', 'constructor'].includes(definition.type)) return false;
+    if (unavailableSurface(index, definition, caller) || (definition.decorators || []).length) return false;
+    // A literal may select a different overload with different access,
+    // exception or passing-mode requirements even when both return the
+    // same type. Family completeness is not proved here: only a unique
+    // project declaration belongs to this small positive domain.
+    if ((index.symbols.get(definition.name) || []).length !== 1) return false;
+    if (definition.className) {
+        // A receiver or an inherited outside overload can choose a method
+        // absent from the project family. Only a static member of a
+        // non-derived owner belongs to this bounded preservation proof.
+        if (!(definition.modifiers || []).includes('static')) return false;
+        const owners = (index.symbols.get(definition.className) || []).filter(owner => owner.file === definition.file &&
+            owner.startLine <= definition.startLine && owner.endLine >= definition.endLine);
+        if (owners.length !== 1 || owners[0].extends?.length || owners[0].implements?.length) return false;
+    }
+    const traits = langTraits(index.files.get(definition.file)?.language);
+    if ((definition.modifiers || []).some(modifier => (traits.compileTimeCallableMarkers || []).includes(modifier))) return false;
+    const callerTraits = langTraits(index.files.get(caller.file)?.language);
+    // Written TS declarations do not make ordinary JS arguments checked.
+    if (callerTraits.lenientCallArity) return !typedComments(index, caller.file) && !typedComments(index, definition.file);
+    const shape = result.callShapes?.[0];
+    if (!shape || shape.hasSpread || shape.indirectKind) return false;
+    const arguments_ = shape.argumentFacts || [];
+    if (arguments_.length === 0) return false;
+    if (arguments_.length !== shape.argCount) return false;
+    const lists = result.parameterLists || [];
+    if (lists.length !== 1) return false;
+    const language = index.files.get(definition.file)?.language;
+    return lists.some(parameters => {
+        let positional = 0;
+        return arguments_.every((argument, at) => {
+            const parameter = argument.keyword ? parameters.find(p => p.name === argument.keyword)
+                : parameters[positional++];
+            if (!parameter || parameter.rest || !parameter.type) return false;
+            // The nominal conversion helpers classify values, not C++
+            // lvalue/rvalue reference binding or language passing modes.
+            if (/[&*]/.test(parameter.type) && parameter.type !== '&str') return false;
+            const kind = literalKind(argument);
+            if (!kind) return false;
+            if (traits.checkLiteralArguments) {
+                const accepted = traits.checkLiteralArguments[kind] || [];
+                return accepted.includes(parameter.type) && unshadowed(index, definition, parameter.type);
+            }
+            // Reuse the nominal overload engine's positive conversion
+            // facts, never its weaker "not disproved" applicability test.
+            if (!traits.hasArityOverloads || parameter.type.includes('.') ||
+                !unshadowed(index, definition, parameter.type)) return false;
+            const argumentKind = record.argKinds?.[at];
+            if (!argumentKind) return false;
+            if (traits.userDefinedConversions === 'constructors-and-operators') {
+                return cppArgumentProvablyConverts(index, argumentKind, parameter, definition,
+                    { ...record, argumentFile: caller.file }, at);
+            }
+            return argumentProvablyConverts(index, argumentKind, parameter, language, definition,
+                { file: caller.file });
+        });
+    });
+}
+
+module.exports = { positivelyFits };