ucn 5.1.1 → 5.2.1

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