ucn 3.8.26 → 4.0.1

package/core/build-worker.js

@@ -34,6 +34,14 @@ function addSymbol(fileEntry, item, type) {
         docstring: item.docstring,
         bindingId: `${fileEntry.relativePath}:${type}:${item.startLine}`,
     };
+    // Field set MUST mirror project.js addSymbol exactly — a worker-side drop
+    // silently strips the field from every parallel-built index (>500 files).
+    // The cache.test.js / perf-optimizations.test.js indexSnapshot guards
+    // compare full symbol shapes, but only for shapes present in their
+    // fixtures — keep this list in sync by hand when addSymbol grows.
+    if (item.paramTypes) symbol.paramTypes = item.paramTypes;
+    if (item.isAsync) symbol.isAsync = true;
+    if (item.isGenerator) symbol.isGenerator = true;
     if (item.generics) symbol.generics = item.generics;
     if (item.extends) symbol.extends = item.extends;
     if (item.implements) symbol.implements = item.implements;
@@ -44,9 +52,14 @@ function addSymbol(fileEntry, item, type) {
     if (item.className) symbol.className = item.className;
     if (item.memberType) symbol.memberType = item.memberType;
     if (item.fieldType) symbol.fieldType = item.fieldType;
+    if (item.aliasOf) symbol.aliasOf = item.aliasOf;
     if (item.decorators && item.decorators.length > 0) symbol.decorators = item.decorators;
+    if (item.decoratorsWithArgs && item.decoratorsWithArgs.length > 0) symbol.decoratorsWithArgs = item.decoratorsWithArgs;
+    if (item.annotationsWithArgs && item.annotationsWithArgs.length > 0) symbol.annotationsWithArgs = item.annotationsWithArgs;
+    if (item.attributesWithArgs && item.attributesWithArgs.length > 0) symbol.attributesWithArgs = item.attributesWithArgs;
     if (item.nameLine) symbol.nameLine = item.nameLine;
     if (item.traitImpl) symbol.traitImpl = true;
+    if (item.traitName) symbol.traitName = item.traitName;
     if (item.isSignature) symbol.isSignature = true;
 
     fileEntry.symbols.push(symbol);
@@ -130,6 +143,12 @@ function processFile(filePath) {
         size: stat.size,
         imports: imports.map(i => i.module),
         importNames: imports.flatMap(i => i.names || []),
+        // Paired name↔module bindings (fix #209) — mirrors indexFile; was
+        // missing here, so parallel-built indexes (>500 files) silently lost
+        // the name-level scope/ownership discipline (found during fix #217).
+        importBindings: imports.flatMap(i => (i.names || [])
+            .filter(n => n && n !== '*' && n !== '_' && n !== '.')
+            .map(n => ({ name: n, module: i.module }))),
         exports: exports.map(e => e.name),
         exportDetails: exports,
         symbols: [],
@@ -137,6 +156,7 @@ function processFile(filePath) {
         dynamicImports: dynamicCount || 0,
     };
     if (importAliases) fileEntry.importAliases = importAliases;
+    if (parsed.moduleAssignedNames) fileEntry.moduleAssignedNames = parsed.moduleAssignedNames;
     if (isBundled) fileEntry.isBundled = true;
     if (isGenerated) fileEntry.isGenerated = true;
 
@@ -152,7 +172,7 @@ function processFile(filePath) {
         addSymbol(fileEntry, cls, cls.type || 'class');
         if (cls.members) {
             for (const m of cls.members) {
-                addSymbol(fileEntry, { ...m, className: cls.name, ...(cls.traitName && { traitImpl: true }) }, m.memberType || 'method');
+                addSymbol(fileEntry, { ...m, className: cls.name, ...(cls.traitName && { traitImpl: true, traitName: cls.traitName }) }, m.memberType || 'method');
             }
         }
     }

package/core/cache.js

@@ -13,6 +13,46 @@ const { expandGlob, detectProjectPattern, parseGitignore, DEFAULT_IGNORES } = re
 // Read UCN version for cache invalidation
 const UCN_VERSION = require('../package.json').version;
 
+// Index/calls cache format version — bump when the persisted call-record or
+// symbol shape changes (saveCache writes it; loadCache rejects anything else).
+// v14: Go qualified composite literals (pkg.Foo{...}) record the package
+// qualifier as `receiver` (fix #206).
+// v15: Go/Rust/Java calls record assignedTo (+assignedTuple/assignedUnwrap)
+// for nominal return-type flow; Java declared-type locals feed receiverType
+// (fix #207).
+// v16: Rust/Go type-alias symbols record aliasOf (fix #208 — alias-qualified
+// receivers are the aliased type); Go `type A = B` aliases now indexed.
+// v17: TS type-alias symbols record aliasOf (fix #208 TS parity — alias-
+// annotated receivers validate against the aliased type).
+// v18: Go callback references carry localShadow (fix #203 Go parity —
+// func-literal params and block locals shadow bare-identifier references).
+// v19: Rust trait-impl member symbols carry traitName (fix #210 — external-
+// contract attribution: `impl Iterator for X` members name their contract).
+// v20: persisted extends/extendedBy graphs split parent lists on TOP-LEVEL
+// commas and strip type-argument suffixes (fix #214 — `extends Base<string,
+// object>` produced parents ["Base<string", "object>"], so every generically
+// extended class had no usable ancestor edges).
+// v21: fileEntry.moduleAssignedNames (fix #217)
+// v22 (fix #219): JS/TS member fieldType; receiverRoot/receiverField/
+// receiverRootType + receiverCall/receiverCallIsMethod/receiverCallAwaited on
+// JS/TS/Python calls; build-worker symbol-field parity (paramTypes, isAsync,
+// isGenerator, aliasOf, traitName, *WithArgs were silently dropped from
+// parallel-built indexes).
+// v23 (fix #220): receiverCall/receiverCallIsMethod on Go/Rust/Java calls
+// (+receiverCallReceiver for Go package-qualified producers); Go receiverType
+// from `var x T` declarations and new(T) allocations; Rust literal-receiver
+// types ("...".parse() → str).
+// v24 (fix #221): boundCall on JS/TS bind/call/apply call records (family B
+// contract field — edges surface as calledAs:'bound').
+// v25 (fix #222): turbofish path receivers — `Vec::<T>::new()` records
+// receiver 'Vec' in BOTH the macro token-tree branch (was receiver-less) and
+// the AST branch (was 'Vec::<T>').
+// v26 (fix #223): Go selector-call line attribution moves to the FIELD
+// node's line (the #201/RUST-2 name-node convention — multi-line receivers
+// like `(&pkg.Name{...}).String()` reported the chain-start line; Go was the
+// only parser still keying calls off the call node's start).
+const CACHE_FORMAT_VERSION = 26;
+
 /**
  * Save index to cache file
  * @param {object} index - ProjectIndex instance
@@ -109,7 +149,16 @@ function saveCache(index, cachePath) {
 
     const cacheData = {
         // v10: persist _reachableSymbols set (computed by entrypoints.computeReachability)
-        version: 10,
+        // v11: fix #202 — calls carry receiverRoot/receiverField/receiverRootType,
+        //      Java classes emit field members with fieldType (stale shapes would
+        //      silently disable declared-field receiver typing)
+        // v12: fix #203 — callback references carry localShadow (lexical-scope
+        //      shadowing computed parser-side)
+        // v13: fix #205 — Python/Go/Rust/Java calls carry argCount (+argSpread
+        //      where the language has call-site spread); Java calls carry
+        //      argKinds for overload discipline (stale shapes would silently
+        //      disable arity pruning)
+        version: CACHE_FORMAT_VERSION,
         ucnVersion: UCN_VERSION,  // Invalidate cache when UCN is updated
         configHash,
         root,
@@ -215,7 +264,7 @@ function loadCache(index, cachePath) {
         // v7: symbols/bindings stripped from file entries (dedup)
         // v9: addSymbol propagates isAsync/isGenerator/paramTypes (force rebuild for old)
         // v10: persists _reachableSymbols set
-        if (cacheData.version !== 10) {
+        if (cacheData.version !== CACHE_FORMAT_VERSION) {
             return false;
         }
 
@@ -566,5 +615,5 @@ function _computeReachabilityFingerprint(index) {
 
 module.exports = {
     saveCache, loadCache, loadCallsCache, isCacheStale, ensureCallsCacheLoaded,
-    _computeReachabilityFingerprint,
+    _computeReachabilityFingerprint, CACHE_FORMAT_VERSION,
 };