ucn 5.2.0 → 5.2.2

package/core/output/refactoring.js

@@ -70,7 +70,7 @@ function formatPlan(plan, options = {}) {
     lines.push(`  Files affected: ${plan.filesAffected}`);
     if (plan.changeSummary) {
         const summary = plan.changeSummary;
-        lines.push(`  Definition ${summary.definitions}, calls ${summary.calls}, references ${summary.references || 0}, imports ${summary.imports}, exports ${summary.exports}; manual review required for ${summary.reviewRequired} of these changes`);
+        lines.push(`  Definition ${summary.definitions}, calls ${summary.calls}, references ${summary.references || 0}, text dependencies ${summary.textReferences || 0}, imports ${summary.imports}, exports ${summary.exports}; manual review items ${summary.reviewRequired}`);
     }
     if (plan.unchangedSites > 0) {
         lines.push(`  ${plan.unchangedSites} existing call site${plan.unchangedSites === 1 ? '' : 's'} require no edit because the new parameter has a default.`);
@@ -78,6 +78,9 @@ function formatPlan(plan, options = {}) {
     if (plan.scopeWarning) {
         lines.push(`  Note: ${plan.scopeWarning.hint}`);
     }
+    if (plan.outsideIndexedSource) {
+        lines.push(`  Source boundary: ${plan.outsideIndexedSource.action}`);
+    }
     lines.push('');
 
     // Group by file
@@ -101,6 +104,17 @@ function formatPlan(plan, options = {}) {
         }
     }
 
+    if (plan.reviewItems?.length > 0) {
+        lines.push(`\nREVIEW ITEMS (${plan.reviewItems.length}) — source text dependencies are never rewritten automatically:`);
+        for (const item of plan.reviewItems.slice(0, 20)) {
+            lines.push(`  ${item.file}:${item.line}: ${item.expression.replace(/\s+/g, ' ').slice(0, 120)}`);
+            lines.push(`    → ${item.suggestion}`);
+        }
+        if (plan.reviewItems.length > 20) {
+            lines.push(`  (+${plan.reviewItems.length - 20} more review items)`);
+        }
+    }
+
     // v4 tiered contract: candidates without evidence are not planned but
     // stay visible — a rename that misses one of these breaks at runtime.
     lines.push(..._unverifiedBandLines(plan.unverifiedSites));
@@ -139,7 +153,8 @@ function formatPlanJson(plan) {
     // commands still emitting a bare result object).
     return JSON.stringify({
         meta: {
-            complete: (plan.unverifiedCount || 0) === 0,
+            complete: (plan.unverifiedCount || 0) === 0 &&
+                (plan.changeSummary?.reviewRequired || 0) === 0,
             unverified: plan.unverifiedCount || 0,
             ...(plan.account && { account: plan.account }),
             ...(plan.warnings?.length > 0 && { warnings: plan.warnings }),
@@ -153,8 +168,12 @@ function formatPlanJson(plan) {
             before: { signature: plan.before.signature },
             after: { signature: plan.after.signature },
             totalChanges: plan.totalChanges,
+            totalReviewItems: plan.totalReviewItems || 0,
             filesAffected: plan.filesAffected,
             ...(plan.changeSummary && { changeSummary: plan.changeSummary }),
+            ...(plan.outsideIndexedSource && {
+                outsideIndexedSource: plan.outsideIndexedSource,
+            }),
             ...(plan.unchangedSites > 0 && { unchangedSites: plan.unchangedSites }),
             changes: plan.changes.map(c => ({
                 file: c.file,
@@ -167,6 +186,16 @@ function formatPlanJson(plan) {
                 ...(c.isImport && { isImport: true }),
                 ...(c.isExport && { isExport: true }),
                 ...(c.needsReview && { needsReview: true }),
+                ...(c.textDependency && { textDependency: true }),
+            })),
+            reviewItems: (plan.reviewItems || []).map(item => ({
+                file: item.file,
+                line: item.line,
+                expression: item.expression,
+                suggestion: item.suggestion,
+                editKind: item.editKind,
+                needsReview: true,
+                textDependency: true,
             })),
             // v4 tiered contract passthrough
             unverifiedCount: plan.unverifiedCount,

package/core/output/reporting.js

@@ -294,6 +294,12 @@ function formatDeadcode(results, options = {}) {
     if (results.computedDispatch?.count > 0) {
         lines.push(`\nWARNING: ${results.computedDispatch.count} computed dispatch call(s) in ${results.computedDispatch.fileCount} file(s). Dead-code results are review candidates; runtime-selected members may not have a named static edge.`);
     }
+    if (results.reflection?.literalCount > 0) {
+        lines.push(`\n${results.reflection.literalCount} literal reflection use(s) name ${results.reflection.names.length} member spelling(s); matching symbols were withheld from deletion candidates.`);
+    }
+    if (results.reflection?.dynamicCount > 0) {
+        lines.push(`\nWARNING: ${results.reflection.dynamicCount} dynamic reflection use(s) have no static member spelling. Dead-code results remain review candidates because runtime-selected members cannot be attributed.`);
+    }
     if (results.coverage?.complete === false) {
         const c = results.coverage;
         const reasonText = Object.entries(c.reasons || {})
@@ -337,6 +343,7 @@ function formatDeadcodeJson(results) {
             ...(results.pythonImplicitExportFiles > 0 && { pythonImplicitExportFiles: results.pythonImplicitExportFiles }),
             ...(results.excludedDynamicDispatch > 0 && { excludedDynamicDispatch: results.excludedDynamicDispatch }),
             ...(results.computedDispatch?.count > 0 && { computedDispatch: results.computedDispatch }),
+            ...(results.reflection?.count > 0 && { reflection: results.reflection }),
             ...(results.coverage?.complete === false && { coverage: results.coverage }),
             symbols: results.map(item => {
                 const handleSym = { ...item, relativePath: item.relativePath || item.file };

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/core/verify.js

@@ -8,6 +8,7 @@
 const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits } = require('../languages');
 const { sameNode } = require('../languages/utils');
 const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES } = require('./shared');
+const { findAccessorReferences } = require('./accessors');
 
 function codeUnitColumnForByteColumn(line, byteColumn) {
     if (!Number.isInteger(byteColumn) || byteColumn < 0) return null;
@@ -2084,6 +2085,7 @@ function plan(index, name, options = {}) {
     let newSignature = currentSignature;
     let operation = null;
     let changes = [];
+    const reviewItems = [];
     let unchangedSites = 0;
 
     if (options.addParam) {
@@ -2361,7 +2363,7 @@ function plan(index, name, options = {}) {
         // tests; the import/reference sweep must not silently hide them via
         // usages()' navigation-oriented default test exclusion.
         const usages = index.usages(name, {
-            codeOnly: true,
+            codeOnly: false,
             includeTests: true,
             internalEvidence: true,
         });
@@ -3166,6 +3168,75 @@ function plan(index, name, options = {}) {
                 }
             }
         }
+
+        // Property/getter/setter renames must cover their normal consumption
+        // form: attribute reads and writes. Reuse impact's receiver-evidence
+        // query so a typed field is edited mechanically and an unresolved
+        // receiver is surfaced for review instead of silently omitted.
+        const accessorReferences = findAccessorReferences(index, name, def, {
+            includeTests: true,
+        });
+        if (accessorReferences) {
+            const confirmedByLine = new Map();
+            for (const ref of accessorReferences.confirmed) {
+                const key = `${ref.absoluteFile}\0${ref.line}`;
+                if (!confirmedByLine.has(key)) confirmedByLine.set(key, []);
+                confirmedByLine.get(key).push(ref);
+            }
+            for (const refs of confirmedByLine.values()) {
+                const ref = refs[0];
+                const columns = refs.map(item => item.column)
+                    .filter(Number.isInteger);
+                const edit = renameIdentifierTokens(index, ref.absoluteFile,
+                    ref.line, name, options.renameTo,
+                    columns.length === refs.length ? columns : null);
+                if (edit.renamed === edit.source) continue;
+                const concrete = {
+                    file: ref.file,
+                    line: ref.line,
+                    expression: edit.source,
+                    suggestion: `Update property access: ${edit.renamed}`,
+                    newExpression: edit.renamed,
+                    editKind: 'reference',
+                };
+                const existing = changes.find(change =>
+                    change.file === ref.file && change.line === ref.line &&
+                    !change.needsReview);
+                if (existing) Object.assign(existing, concrete);
+                else changes.push(concrete);
+            }
+            for (const ref of accessorReferences.unverified) {
+                changes.push({
+                    file: ref.file,
+                    line: ref.line,
+                    expression: ref.expression,
+                    suggestion: `Verify this property access resolves to ${name} on ` +
+                        `${accessorReferences.owner} before renaming`,
+                    needsReview: true,
+                    editKind: 'reference',
+                });
+            }
+        }
+
+        // String/comment occurrences in indexed source can encode guards,
+        // reflection keys, protocol names, snapshots, or documentation. AST
+        // identifier replacement must never rewrite them automatically, but a
+        // complete plan must list them as explicit review work.
+        for (const textRef of usages.filter(usage => usage.usageType === 'text')) {
+            const rel = textRef.relativePath || textRef.file;
+            if (reviewItems.some(item =>
+                item.file === rel && item.line === textRef.line)) continue;
+            reviewItems.push({
+                file: rel,
+                line: textRef.line,
+                expression: (textRef.content || '').trim(),
+                suggestion: `Review comment/string dependency on "${name}"; ` +
+                    'rename manually only if its contract changes',
+                needsReview: true,
+                textDependency: true,
+                editKind: 'text-reference',
+            });
+        }
     }
 
     // Every operation changes the selected declaration. Historically `plan`
@@ -3222,7 +3293,9 @@ function plan(index, name, options = {}) {
         imports: changes.filter(change => change.editKind === 'import').length,
         exports: changes.filter(change => change.editKind === 'export').length,
         references: changes.filter(change => change.editKind === 'reference').length,
-        reviewRequired: changes.filter(change => change.needsReview).length,
+        textReferences: reviewItems.length,
+        reviewRequired: changes.filter(change => change.needsReview).length +
+            reviewItems.length,
     };
 
     return {
@@ -3243,9 +3316,11 @@ function plan(index, name, options = {}) {
             params: newParams.map(p => formatPlanParamName(p)).filter(Boolean)
         },
         totalChanges: changes.length,
-        filesAffected: new Set(changes.map(c => c.file)).size,
+        filesAffected: new Set([...changes, ...reviewItems].map(c => c.file)).size,
         changeSummary,
         changes,
+        reviewItems,
+        totalReviewItems: reviewItems.length,
         ...(unchangedSites > 0 && { unchangedSites }),
         // v4 tiered contract: sites that MAY also need this change but lack
         // binding/receiver evidence — review manually before refactoring.
@@ -3253,6 +3328,13 @@ function plan(index, name, options = {}) {
         unverifiedSites: planUnverified,
         account: planAccount,
         scopeWarning: impactScopeWarning,
+        ...(options.renameTo && {
+            outsideIndexedSource: {
+                scope: 'indexed-source-files',
+                excluded: ['documentation', 'configuration', 'generated files', 'unsupported languages'],
+                action: `Search non-source project files for the exact spelling "${name}" before applying the rename.`,
+            },
+        }),
         ...(resolved.warnings.length > 0 && { warnings: resolved.warnings }),
     };
     } finally { index._endOp(); }

package/languages/c-family.js

@@ -513,27 +513,18 @@ function conditionalRecoverySources(code) {
 }
 
 function treeStructureScore(tree) {
-    let declarations = 0;
-    let calls = 0;
     const declarationTypes = new Set([
         'function_definition', 'class_specifier', 'struct_specifier',
         'union_specifier', 'enum_specifier', 'type_definition',
     ]);
-    const cursor = tree.walk();
-    let entered = true;
-    while (entered) {
-        const type = cursor.nodeType;
-        if (declarationTypes.has(type)) declarations++;
-        else if (type === 'call_expression') calls++;
-        if (cursor.gotoFirstChild()) continue;
-        while (!cursor.gotoNextSibling()) {
-            if (!cursor.gotoParent()) {
-                entered = false;
-                break;
-            }
-        }
-    }
-    cursor.delete?.();
+    // `descendantsOfType` performs the filtering in tree-sitter's native
+    // cursor. Recovery can score the same large source under as many as 14
+    // bounded preprocessor views; walking every node through the JS bridge
+    // made scoring alone a material part of cold C/C++ build CPU. The native
+    // query returns the exact same node sets and therefore preserves the
+    // recovery ordering contract while avoiding thousands of wrapper calls.
+    const declarations = tree.rootNode.descendantsOfType([...declarationTypes]).length;
+    const calls = tree.rootNode.descendantsOfType('call_expression').length;
     return declarations * 1000 + calls;
 }
 
@@ -2785,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
@@ -2869,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;
 }

package/languages/csharp.js

@@ -293,7 +293,7 @@ function propertyMember(node, lines) {
         endLine,
         indent,
         modifiers: modifiersOf(node),
-        memberType: 'field',
+        memberType: 'property',
         fieldType: typeNode?.text || null,
     };
 }
@@ -1312,6 +1312,7 @@ function findImportsInCode(code, parser) {
 function findUsagesInCode(code, name, parser, existingTree) {
     const tree = existingTree || parseTree(parser, code);
     const usages = [];
+    const variableTypesByScope = buildVariableTypes(tree, parser);
     visitNameNodes(tree, code, name, node => {
         if (!IDENTIFIER_NODES.has(node.type) || node.text !== name) return;
         let usageType = 'reference';
@@ -1320,6 +1321,8 @@ function findUsagesInCode(code, name, parser, existingTree) {
             if ((parent.type === 'method_declaration' ||
                 parent.type === 'constructor_declaration' ||
                 TYPE_DECLARATIONS.has(parent.type) ||
+                parent.type === 'property_declaration' ||
+                parent.type === 'event_declaration' ||
                 parent.type === 'parameter' ||
                 parent.type === 'variable_declarator') &&
                 (sameNode(parent.childForFieldName('name'), node))) {
@@ -1330,6 +1333,28 @@ function findUsagesInCode(code, name, parser, existingTree) {
             } else if (parent.type === 'using_directive') {
                 usageType = 'import';
             }
+            if (parent.type === 'member_access_expression' &&
+                sameNode(parent.childForFieldName('name'), node)) {
+                const receiverNode = parent.childForFieldName('expression') ||
+                    parent.namedChild(0);
+                const receiver = receiverNode?.text;
+                const scopeTypes = variableTypesByScope.get(variableScopeKey(node)) ||
+                    variableTypesByScope.get('global');
+                const declared = receiverNode?.type === 'identifier'
+                    ? normalizeReceiverType(scopeTypes?.get(receiver)) : null;
+                const sameClass = ['this', 'base'].includes(receiver)
+                    ? enclosingClassName(node) : null;
+                usages.push({
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                    usageType,
+                    ...(receiver && { receiver }),
+                    ...((declared?.name || sameClass) && {
+                        receiverType: declared?.name || sameClass,
+                    }),
+                });
+                return true;
+            }
         }
         usages.push({
             line: node.startPosition.row + 1,