ucn 5.0.6 → 5.2.0

package/core/graph-build.js

@@ -451,6 +451,12 @@ function buildInheritanceGraph(index) {
                 }
                 index.extendsGraph.get(symbol.name).push({
                     file: filePath,
+                    // Per-def anchor (fix #300, attrs-measured): five
+                    // function-local `class C2Slots(...)` defs in one file
+                    // carry DIFFERENT parents — file-granular lookup returned
+                    // the first entry for all of them. startLine lets scope-
+                    // aware consumers pick the def the call site actually sees.
+                    startLine: symbol.startLine,
                     parents: resolvedParents
                 });
 

package/core/index-ir.js

@@ -16,6 +16,7 @@ function createImportBindings(imports) {
             return {
                 name,
                 module: item.module,
+                ...(item.type && { kind: item.type }),
                 ...(item.line != null && { line: item.line }),
                 ...(rename && { alias: rename.local }),
                 ...(item.defaultLike && { defaultLike: true }),
@@ -65,17 +66,19 @@ function createFileEntryFromIR({
 
 const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
-    'isGenerator', 'generics', 'extends', 'implements', 'indent', 'isNested',
+    'isGenerator', 'generics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
     'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType',
     'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
-    'traitName', 'isSignature', 'memberAssigned', 'bodyScopedName',
+    'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
     'registryMember', 'registryContainer', 'namespace',
     'isExtensionMethod', 'extensionReceiver', 'explicitInterface',
     'lexicalScopeStartLine', 'lexicalScopeEndLine',
     'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
     'returnedConcreteType', 'returnedConstructors', 'templateDependent',
-    'linkage', 'functionLike',
+    'isSpecialization',
+    'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
+    'aliasOwner', 'aliasMember', 'macroParamEffects',
 ]);
 
 function materializeSymbol(fileEntry, item) {
@@ -91,7 +94,9 @@ function materializeSymbol(fileEntry, item) {
         returnType: item.returnType,
         modifiers: item.modifiers,
         docstring: item.docstring,
-        bindingId: `${fileEntry.relativePath}:${item.kind}:${item.startLine}`,
+        bindingId: item.id
+            ? `${fileEntry.relativePath}:${item.id}`
+            : `${fileEntry.relativePath}:${item.kind}:${item.startLine}`,
         ...(item.owner && { className: item.owner }),
     };
     for (const field of OPTIONAL_SYMBOL_FIELDS) {
@@ -109,7 +114,13 @@ function materializeSymbol(fileEntry, item) {
 function addIRSymbol(fileEntry, item, symbolTable = null) {
     const symbol = materializeSymbol(fileEntry, item);
     fileEntry.symbols.push(symbol);
-    if (!item.memberAssigned && !item.bodyScopedName) {
+    // A Rust `impl X`/`impl Trait for X` block introduces NO name into any
+    // scope (fix #286b, cursive-measured: the impl symbol stole the bare-name
+    // binding of ColorPair from the cross-file struct, excluding a compiler-
+    // true composite-literal caller as other-definition). The struct/enum
+    // claim covers the impl — same discipline as deadcode's CLASS_AUDIT_KINDS.
+    if (!item.memberAssigned && !item.bodyScopedName && !item.exportedAlias &&
+        item.kind !== 'impl') {
         fileEntry.bindings.push({
             id: symbol.bindingId,
             name: symbol.name,

package/core/ir.js

@@ -43,17 +43,19 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
     };
     const passthrough = [
         'docstring', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
-        'isAsync', 'isGenerator', 'generics', 'extends', 'implements', 'indent',
+        'isAsync', 'isGenerator', 'generics', 'genericBounds', 'extends', 'implements', 'indent',
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType',
         'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
-        'traitName', 'isSignature', 'memberAssigned', 'bodyScopedName',
+        'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
         'registryMember', 'registryContainer', 'isConstructor',
         'isExtensionMethod', 'extensionReceiver', 'explicitInterface',
         'namespace', 'lexicalScopeStartLine', 'lexicalScopeEndLine',
         'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
         'returnedConcreteType', 'returnedConstructors', 'templateDependent',
-        'linkage', 'functionLike',
+        'isSpecialization',
+        'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
+        'aliasOwner', 'aliasMember', 'macroParamEffects',
     ];
     for (const field of passthrough) {
         if (symbol[field] !== undefined && symbol[field] !== null) {
@@ -114,6 +116,51 @@ function createFileIR({
     for (const symbol of stateObjects) append(symbol, 'state', 'state');
     for (const symbol of macros) append(symbol,
         symbol.functionLike ? 'callable' : 'state', 'macro');
+    // 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.
+    for (const alias of (parsed.callableAliases || [])) {
+        const 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) continue;
+        const sourceReturns = new Set(sources.map(source => source.returnType));
+        if (sourceReturns.size !== 1) continue;
+        const source = sources[0];
+        const exported = (parsed.exports || []).filter(item =>
+            !item.source && item.name === alias.name);
+        const exposed = exported.map(item => ({
+            name: item.type === 'default' ? 'default' : (item.alias || item.name),
+            line: item.line || alias.startLine,
+        }));
+        const localIsExported = exposed.some(item => item.name === alias.name);
+        const makeAlias = (name, startLine, isExported, exportedAlias = false) => ({
+            bindingId: `callable-alias:${alias.owner}.${alias.member}:${name}:${startLine}`,
+            name,
+            startLine,
+            endLine: startLine,
+            params: source.params,
+            ...(source.paramsStructured && { paramsStructured: source.paramsStructured }),
+            returnType: source.returnType,
+            modifiers: isExported ? ['export'] : [],
+            callableAlias: true,
+            ...(exportedAlias && { exportedAlias: true }),
+            aliasOwner: alias.owner,
+            aliasMember: alias.member,
+        });
+        append(makeAlias(alias.name, alias.startLine, localIsExported),
+            'callable', 'function');
+        for (const item of exposed) {
+            if (item.name === alias.name) continue;
+            append(makeAlias(item.name, item.line, true, true), 'callable', 'function');
+        }
+    }
     const imports = [...(parsed.imports || [])];
     return {
         schemaVersion: IR_SCHEMA_VERSION,

package/core/output/analysis.js

@@ -74,6 +74,23 @@ function isTestEntry(entry) {
     return isTestPath(entry.relativePath || entry.file || '');
 }
 
+function formatAmbiguityCandidates(lines, ambiguity) {
+    if (!ambiguity?.items?.length) return;
+    const owners = ambiguity.dispatchOwners
+        ? `; ${ambiguity.dispatchOwners} dispatch owners` : '';
+    lines.push(`  competing definitions (${ambiguity.totalDefinitions}${owners}):`);
+    for (const candidate of ambiguity.items) {
+        const owner = candidate.owner
+            ? ` on ${candidate.owner}${candidate.memberAssignment ? ' (member assignment)' : ''}` : '';
+        const selected = candidate.selected ? ' [selected target]' : '';
+        lines.push(`    - ${candidate.handle} — ${candidate.type}${owner}${selected}`);
+    }
+    if (ambiguity.truncated) {
+        lines.push(`    (+${ambiguity.totalDefinitions - ambiguity.items.length} more — ` +
+            `use find ${ambiguity.name})`);
+    }
+}
+
 /**
  * Render the conservation contract lines: ACCOUNT and CONTRACT (always),
  * WARNING (unparsed files containing the symbol), FILTERED (display-filter
@@ -273,6 +290,9 @@ function formatContextJson(context) {
                             ? 'runtime-dispatch' : 'actionable-ambiguity'),
                     ...(c.dispatchFamily && { dispatchFamily: c.dispatchFamily }),
                 })),
+                ...(context.ambiguityCandidates && {
+                    ambiguityCandidates: context.ambiguityCandidates,
+                }),
                 ...(context.warnings && { warnings: context.warnings })
             }
         });
@@ -327,6 +347,9 @@ function formatContextJson(context) {
                         ? 'runtime-dispatch' : 'actionable-ambiguity'),
                 ...(c.dispatchFamily && { dispatchFamily: c.dispatchFamily }),
             })),
+            ...(context.ambiguityCandidates && {
+                ambiguityCandidates: context.ambiguityCandidates,
+            }),
             callees: callees.map(c => ({
                 name: c.name,
                 type: c.type,
@@ -427,6 +450,7 @@ function formatContext(ctx, options = {}) {
         const typeUnverified = ctx.unverifiedCallers || [];
         if (typeUnverified.length > 0) {
             lines.push(`\nCALLERS — UNVERIFIED (${typeUnverified.length}) — call syntax, no binding/receiver evidence:`);
+            formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
             const cap = 10;
             let shown = 0;
             for (const u of typeUnverified) {
@@ -653,6 +677,7 @@ function formatContext(ctx, options = {}) {
     // Always visible and capped at 10 one-liners unless --all.
     if (actionableUnverified.length > 0) {
         lines.push(`${compact ? '' : '\n'}CALLERS — UNVERIFIED (${actionableUnverified.length}) — call syntax, no binding/receiver evidence:`);
+        formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
         const cap = (ctx.meta && ctx.meta.all) ? Infinity : 10;
         let shown = 0;
         for (const u of actionableUnverified) {

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/references ${summary.calls}, 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}, imports ${summary.imports}, exports ${summary.exports}; manual review required for ${summary.reviewRequired} of these changes`);
     }
     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.`);

package/core/output/shared.js

@@ -338,7 +338,7 @@ function formatGitLine(git) {
  * Display label for an unverified-tier entry's reason. Dispatch-tiered
  * entries (nominal languages) carry attribution metadata: the declared
  * supertype the call dispatches through (dispatchVia) and how many
- * same-name definitions the dispatch could land on (dispatchCandidates).
+ * distinct same-name owners the dispatch could land on (dispatchCandidates).
  */
 function unverifiedReasonLabel(entry) {
     if (!entry || !entry.reason) return '';
@@ -356,7 +356,7 @@ function unverifiedReasonLabel(entry) {
             : `possible-dispatch via ${entry.dispatchVia}`;
     }
     if (entry.reason === 'method-ambiguous' && entry.dispatchCandidates > 1) {
-        return `method-ambiguous — ${entry.dispatchCandidates} same-name definitions`;
+        return `method-ambiguous — ${entry.dispatchCandidates} dispatch owners`;
     }
     if (entry.reason === 'overload-ambiguous' && entry.dispatchCandidates > 1) {
         return `overload-ambiguous — 1 of ${entry.dispatchCandidates} applicable overloads`;

package/core/project.js

@@ -444,6 +444,9 @@ class ProjectIndex {
         this._completenessCache = null;
         this._attrTypeCache = null;
         this._computedDispatchBlindspots = null;
+        this._cppVisibleFilesCache?.clear();
+        this._cppTargetVisibilityCache?.clear();
+        this._cppMacroParamOutcomesCache?.clear();
         // Endpoints cache (server routes / client requests / bridges) becomes
         // stale when files change; clear on every rebuild.
         this._endpointsCache = null;
@@ -589,6 +592,13 @@ class ProjectIndex {
             return false;
         }
 
+        // These query caches depend on project symbols and include closure.
+        // A changed file can alter either even before a full rebuild reaches
+        // its graph phase, so no prior call-identity verdict may survive.
+        this._cppVisibleFilesCache?.clear();
+        this._cppTargetVisibilityCache?.clear();
+        this._cppMacroParamOutcomesCache?.clear();
+
         if (existing) {
             this.removeFileSymbols(filePath);
         }
@@ -942,6 +952,28 @@ class ProjectIndex {
         return entries;
     }
 
+    /**
+     * Def-exact inheritance parents (fix #300): resolve parents for ONE
+     * specific class definition by (file, startLine). Same-name classes in
+     * one file (function-local test classes) carry different parents; the
+     * file-granular lookup above conflates them. Returns null when no entry
+     * matches — for a known def that means it extends nothing (entries are
+     * only recorded for extends-bearing defs), which callers must treat as
+     * "no parents", never fall back to a sibling def's edges.
+     * @param {string} className
+     * @param {string} contextFile
+     * @param {number} defStartLine
+     * @returns {string[]|null}
+     */
+    _getInheritanceParentsAt(className, contextFile, defStartLine) {
+        const entries = this.extendsGraph.get(className);
+        if (!entries || entries.length === 0) return null;
+        if (typeof entries[0] !== 'object' || entries[0].file === undefined) return null;
+        const match = entries.find(e => e.file === contextFile &&
+            e.startLine === defStartLine);
+        return match ? match.parents : null;
+    }
+
     /**
      * Resolve which file a class is defined in, preferring contextFile.
      * Used during inheritance BFS to find grandparent chains.

package/core/search.js

@@ -352,6 +352,15 @@ function usages(index, name, options = {}) {
                         usageType: u.usageType,
                         isDefinition: false,
                         ...(u.receiver && { receiver: u.receiver }),
+                        // Refactoring internals need the exact AST token and
+                        // receiver provenance, but the public usages JSON is a
+                        // stable line-oriented inventory. Keep this opt-in so
+                        // plan gains precision without changing that surface.
+                        ...(options.internalEvidence && {
+                            ...(Number.isInteger(u.column) && { column: u.column }),
+                            ...(u.receiverIsModule && { receiverIsModule: true }),
+                            ...(u.receiverLocalBinding && { receiverLocalBinding: true }),
+                        }),
                         ...(callerSym && {
                             callerName: callerSym.name,
                             callerStartLine: callerSym.startLine