ucn 5.2.1 → 5.2.2

package/core/index-ir.js

@@ -76,9 +76,9 @@ function createFileEntryFromIR({
 
 const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
-    'isGenerator', 'generics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
+    'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
     'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType',
-    'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
+    'aliasOf', 'aliasMembers', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
     'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
     'registryMember', 'registryContainer', 'namespace',
@@ -86,9 +86,11 @@ const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'lexicalScopeStartLine', 'lexicalScopeEndLine',
     'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
     'returnedConcreteType', 'returnedConstructors', 'templateDependent',
+    'returnedCallStart', 'returnedCallEnd',
+    'returnedReceiverPath',
     'isSpecialization',
     'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
-    'aliasOwner', 'aliasMember', 'macroParamEffects',
+    'aliasOwner', 'aliasMember', 'callableTarget', 'macroParamEffects',
 ]);
 
 function materializeSymbol(fileEntry, item) {

package/core/ir.js

@@ -11,6 +11,24 @@
 const IR_SCHEMA_VERSION = 1;
 const EVIDENCE_TIERS = Object.freeze(['confirmed', 'unverified', 'excluded']);
 
+// Runtime receiver identity for overload-heavy JS/TS member aliases. Generic
+// arguments may differ while the produced value still has one concrete owner
+// (`Factory.create(): Schema<A>` / `Schema<B>`). Transparent/async wrappers
+// are deliberately rejected here: downstream assignment flow unwraps them,
+// so agreement on Promise/Optional alone would not prove the inner receiver.
+function callableAliasReturnHead(returnType) {
+    if (!returnType || typeof returnType !== 'string') return null;
+    const text = returnType.trim();
+    const match = text.match(
+        /^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:<[\s\S]*>|\[[\s\S]*\])?$/);
+    if (!match) return null;
+    const head = match[1].split('.').pop();
+    if (['Promise', 'Awaitable', 'Optional', 'Annotated', 'Final'].includes(head)) {
+        return null;
+    }
+    return head;
+}
+
 function normalizeSymbol(symbol, family, language, kind, owner = null) {
     let normalizedOwner = owner || symbol.className || null;
     if (!normalizedOwner && symbol.receiver && family === 'callable') {
@@ -43,9 +61,9 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
     };
     const passthrough = [
         'docstring', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
-        'isAsync', 'isGenerator', 'generics', 'genericBounds', 'extends', 'implements', 'indent',
+        'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent',
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType',
-        'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
+        'aliasOf', 'aliasMembers', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
         'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
         'registryMember', 'registryContainer', 'isConstructor',
@@ -53,9 +71,11 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         'namespace', 'lexicalScopeStartLine', 'lexicalScopeEndLine',
         'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
         'returnedConcreteType', 'returnedConstructors', 'templateDependent',
+        'returnedCallStart', 'returnedCallEnd',
+        'returnedReceiverPath',
         'isSpecialization',
         'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
-        'aliasOwner', 'aliasMember', 'macroParamEffects',
+        'aliasOwner', 'aliasMember', 'callableTarget', 'macroParamEffects',
     ];
     for (const field of passthrough) {
         if (symbol[field] !== undefined && symbol[field] !== null) {
@@ -106,6 +126,9 @@ function createFileIR({
                     traitImpl: true,
                     traitName: type.traitName,
                 }),
+                ...(type.generics && {
+                    ownerGenerics: type.generics,
+                }),
             };
             append(inherited,
                 ['field', 'property'].includes(inherited.memberType)
@@ -120,19 +143,44 @@ function createFileIR({
     // An immutable module-scope member alias has the callable signature of
     // the class member it captures: `const make = Widget.create`. Materialize
     // the local value and each explicit export alias as real function symbols
-    // only when its member is static and every declared return type agrees.
-    // This is compiler-visible identity; mutable aliases and ambiguous
-    // overload returns were rejected by the parser/agreement gate above.
+    // only when its member is static and every declared return type has the
+    // same concrete runtime head. Generic arguments may differ across legal
+    // overloads; a different head remains ambiguous. This is compiler-visible
+    // identity; mutable aliases and ambiguous overload returns stay rejected.
     for (const alias of (parsed.callableAliases || [])) {
-        const sources = normalizedSymbols.filter(symbol =>
+        let sources = normalizedSymbols.filter(symbol =>
             symbol.name === alias.member && symbol.owner === alias.owner &&
             (symbol.params !== undefined || symbol.paramsStructured) &&
             (symbol.modifiers?.includes('static') ||
                 String(symbol.memberType || symbol.kind).startsWith('static')) &&
             symbol.returnType);
+        if (sources.length === 0) {
+            // Static callable forwarding (zod-measured):
+            // `static create = createSchema; const schema = Type.create`.
+            // The parser records only a direct identifier initializer. Pin it
+            // to top-level callables in this file, and require every matching
+            // field declaration to agree before borrowing its signatures.
+            const forwarded = normalizedSymbols.filter(symbol =>
+                symbol.name === alias.member && symbol.owner === alias.owner &&
+                symbol.family === 'state' && symbol.callableTarget &&
+                symbol.modifiers?.includes('static'));
+            const targets = new Set(forwarded.map(symbol => symbol.callableTarget));
+            if (forwarded.length > 0 && targets.size === 1) {
+                const [target] = targets;
+                sources = normalizedSymbols.filter(symbol =>
+                    symbol.name === target && symbol.family === 'callable' &&
+                    !symbol.owner && !symbol.isNested &&
+                    (symbol.params !== undefined || symbol.paramsStructured) &&
+                    symbol.returnType);
+            }
+        }
         if (sources.length === 0) continue;
         const sourceReturns = new Set(sources.map(source => source.returnType));
-        if (sourceReturns.size !== 1) continue;
+        if (sourceReturns.size !== 1) {
+            const heads = new Set(sources.map(source =>
+                callableAliasReturnHead(source.returnType)));
+            if (heads.has(null) || heads.size !== 1) continue;
+        }
         const source = sources[0];
         const exported = (parsed.exports || []).filter(item =>
             !item.source && item.name === alias.name);

package/core/project.js

@@ -79,8 +79,33 @@ class ProjectIndex {
         this._opLinesCache = null;       // per-operation split-lines cache (Map<filePath, string[]>, bounded FIFO)
         this._opInnerSymbolRangesCache = null; // per-operation sorted class-method ranges by file
         this._opFlowTypeOriginCache = null; // per-operation annotation type identity results
+        this._opCppTypeCategoryCache = null; // per-operation normalized C++ parameter categories
+        this._opCppPathReceiverTypeCache = null; // per-operation C++ qualified receiver identity
+        this._opDerefPairs = null;      // per-operation Rust Deref identity pairs
+        this._opAliasPairs = null;      // per-operation language type-alias identity pairs
         this._parsedTreeCache = new Map(); // cross-operation LRU: filePath -> immutable tree entry
         this._parsedTreeCacheSourceBytes = 0;
+        // Cross-operation, content-hash-keyed usage classifications. Account
+        // queries often ask several projections for the same hot symbol; the
+        // AST answer is immutable until the file hash changes. Bounded by
+        // both entries and approximate payload size to avoid turning a warm
+        // MCP process into an unbounded repository mirror.
+        this._usageResultCache = new Map();
+        this._usageResultCacheWeight = 0;
+        this.usageCacheDirty = false;
+        // Exact text-ground sets are likewise immutable for one built index.
+        // The cache is cleared at every build and bounded in account.js.
+        this._groundSetCache = new Map();
+        this._groundSetCacheLines = 0;
+        // Bounded cross-operation memo for immutable name-level export
+        // ownership. Agent workflows ask show/impact/tests about related
+        // symbols in sequence; retaining these tri-state barrel verdicts
+        // avoids repeating the same bounded graph walks after every command.
+        this._nameBindingReachCache = new Map();
+        // Query-derived return flow depends on cross-file annotations and is
+        // deliberately never persisted. It is safe across commands only
+        // until the next build, which resets it below.
+        this._returnTypeFlowCache = new Map();
         this.calleeIndex = null;         // name -> Set<filePath> — inverted call index (built lazily)
     }
 
@@ -120,6 +145,10 @@ class ProjectIndex {
             this._opInnerSymbolRangesCache = new Map();
             this._opFlowTypeOriginCache = new Map();
             this._opImportReachCache = new Map();
+            this._opCppTypeCategoryCache = new Map();
+            this._opCppPathReceiverTypeCache = new Map();
+            this._opDerefPairs = undefined;
+            this._opAliasPairs = undefined;
             this._opDepth = 0;
         }
         this._opDepth++;
@@ -145,6 +174,10 @@ class ProjectIndex {
             this._opInnerSymbolRangesCache = null;
             this._opFlowTypeOriginCache = null;
             this._opImportReachCache = null;
+            this._opCppTypeCategoryCache = null;
+            this._opCppPathReceiverTypeCache = null;
+            this._opDerefPairs = null;
+            this._opAliasPairs = null;
             // Free cached file content from callsCache entries (retained during
             // operation for _readFile caching, not needed between operations)
             for (const entry of this.callsCache.values()) {
@@ -255,15 +288,38 @@ class ProjectIndex {
      * multiple times within one operation (e.g., about() calls both countSymbolUsages and usages).
      * @param {string} filePath - File to scan
      * @param {string} name - Symbol name to find
+     * @param {object} [options]
+     * @param {boolean} [options.skipCallRecovery] - omit usage-only call
+     * recovery when the caller has already classified lines from the call index
      * @returns {Array|null} Array of usage objects or null if parsing failed
      */
-    _getCachedUsages(filePath, name) {
-        const cacheKey = `${filePath}\0${name}`;
+    _getCachedUsages(filePath, name, options = {}) {
+        // Account construction checks the complete calls cache before it asks
+        // the language adapter to classify the remaining name occurrences.
+        // C/C++ can therefore skip its expensive macro replacement-list call
+        // recovery in that mode. Partition both cache layers so a partial
+        // account classification can never poison the full `usages` result.
+        const mode = [
+            options.skipCallRecovery ? 'skip-call-recovery' : '',
+        ].filter(Boolean).join('+');
+        const modeSuffix = mode ? `\0${mode}` : '';
+        const cacheKey = `${filePath}\0${name}${modeSuffix}`;
         if (this._opUsagesCache) {
             const cached = this._opUsagesCache.get(cacheKey);
             if (cached !== undefined) return cached;
         }
 
+        const fileHash = this.files.get(filePath)?.hash || '';
+        const persistentKey = `${filePath}\0${fileHash}\0${name}${modeSuffix}`;
+        if (this._usageResultCache?.has(persistentKey)) {
+            const cached = this._usageResultCache.get(persistentKey);
+            // Map insertion order is the LRU order.
+            this._usageResultCache.delete(persistentKey);
+            this._usageResultCache.set(persistentKey, cached);
+            if (this._opUsagesCache) this._opUsagesCache.set(cacheKey, cached.value);
+            return cached.value;
+        }
+
         // Header language is resolved during indexing from compilation
         // databases/include context. Re-detecting `.h` here can choose C for
         // a C++ header and silently drop member/template usages from the raw
@@ -292,10 +348,26 @@ class ProjectIndex {
                 !langModule.managesOwnParseTree
                 ? this._getParsedTree(filePath, content, lang)
                 : null;
-            const usages = langModule.findUsagesInCode(content, name, parser, tree);
+            const usages = langModule.findUsagesInCode(
+                content, name, parser, tree, options);
             if (this._opUsagesCache) {
                 this._opUsagesCache.set(cacheKey, usages);
             }
+            if (Array.isArray(usages) && this._usageResultCache) {
+                const weight = 64 + usages.length * 40;
+                this._usageResultCache.set(persistentKey, { value: usages, weight });
+                this._usageResultCacheWeight += weight;
+                this.usageCacheDirty = true;
+                const maxEntries = 4096;
+                const maxWeight = 16 * 1024 * 1024;
+                while (this._usageResultCache.size > maxEntries ||
+                    this._usageResultCacheWeight > maxWeight) {
+                    const oldest = this._usageResultCache.entries().next().value;
+                    if (!oldest) break;
+                    this._usageResultCache.delete(oldest[0]);
+                    this._usageResultCacheWeight -= oldest[1].weight;
+                }
+            }
             return usages;
         } catch (e) {
             return null;
@@ -327,6 +399,14 @@ class ProjectIndex {
         const startTime = Date.now();
         const quiet = options.quiet !== false;
 
+        // Build/discovery can add, remove, or reclassify files. Do not retain
+        // a text-universe answer across that boundary. Hash-keyed usage
+        // results remain safe and useful for unchanged files.
+        this._groundSetCache = new Map();
+        this._groundSetCacheLines = 0;
+        this._nameBindingReachCache = new Map();
+        this._returnTypeFlowCache = new Map();
+
         // A (re)build invalidates any cache-loaded reachability set — the
         // fingerprint guard in computeReachability is content-shaped and
         // cannot see every rebuild (fix #249: a stale loaded set survived
@@ -2414,6 +2494,11 @@ class ProjectIndex {
     /** Load index from cache file */
     loadCache(cachePath) { return indexCache.loadCache(this, cachePath); }
 
+    /** Persist the bounded, content-hash-keyed usage-query cache. */
+    saveUsageCache(cachePath = undefined) {
+        return indexCache.saveUsageCache(this, cachePath);
+    }
+
     /** Return this project's default per-user cache file path. */
     getCachePath() { return indexCache.getProjectCachePath(this.root); }
 

package/languages/c-family.js

@@ -2776,7 +2776,7 @@ function findImportsInCode(code, parser) {
     } finally { /* cached with the selected tree */ }
 }
 
-function findUsagesInCode(code, name, parser, existingTree) {
+function findUsagesInCode(code, name, parser, existingTree, options = {}) {
     // Usage is the raw literal-name inventory. The literal C/C++ tree retains
     // identifiers from every preprocessor branch and is sufficient for
     // occurrence kind/line classification; symbol ownership still comes from
@@ -2860,22 +2860,24 @@ function findUsagesInCode(code, name, parser, existingTree) {
     // call extractor reparses those AST-proven regions; surface the resulting
     // call usages here as well so callers/callees, usages, and tests share one
     // semantic fact set.
-    const seenCalls = new Set(usages
-        .filter(usage => usage.usageType === 'call')
-        .map(usage => `${usage.line}:${usage.column ?? ''}`));
-    const macroCalls = findMacroBodyCalls(tree, code, parser, name);
-    for (const call of macroCalls) {
-        if (call.name !== name) continue;
-        const key = `${call.line}:${call.column ?? ''}`;
-        if (seenCalls.has(key)) continue;
-        seenCalls.add(key);
-        addUsage({
-            line: call.line,
-            column: call.column,
-            usageType: 'call',
-            ...(call.receiver && { receiver: call.receiver }),
-            ...(call.macroParameter && { macroParameter: true }),
-        });
+    if (!options.skipCallRecovery) {
+        const seenCalls = new Set(usages
+            .filter(usage => usage.usageType === 'call')
+            .map(usage => `${usage.line}:${usage.column ?? ''}`));
+        const macroCalls = findMacroBodyCalls(tree, code, parser, name);
+        for (const call of macroCalls) {
+            if (call.name !== name) continue;
+            const key = `${call.line}:${call.column ?? ''}`;
+            if (seenCalls.has(key)) continue;
+            seenCalls.add(key);
+            addUsage({
+                line: call.line,
+                column: call.column,
+                usageType: 'call',
+                ...(call.receiver && { receiver: call.receiver }),
+                ...(call.macroParameter && { macroParameter: true }),
+            });
+        }
     }
     return usages;
 }