ucn 5.5.1 → 5.5.2

package/core/graph.js

@@ -319,16 +319,27 @@ function fileExports(index, filePath, _visited) {
             (isPythonImplicit && symbol.name && !symbol.name.startsWith('_') && !symbol.className && !symbol.isMethod);
 
         if (isExported) {
+            const variable = symbol.type === 'state' && (fileEntry.exportDetails || [])
+                .find(detail => detail.isVariable && detail.name === symbol.name);
+            const details = (fileEntry.exportDetails || []).filter(detail =>
+                (detail.localName || detail.name) === symbol.name);
+            const defaultLike = detail => detail.type === 'default' ||
+                detail.type === 'module.exports' && detail.defaultLike;
+            const defaultOnly = details.some(defaultLike) &&
+                !details.some(detail => !defaultLike(detail));
             results.push({
                 name: symbol.name,
-                type: symbol.type,
+                type: variable ? 'variable' : symbol.type,
                 file: fileEntry.relativePath,
                 startLine: symbol.startLine,
                 endLine: symbol.endLine,
                 ...(symbol.className && { className: symbol.className }),
                 params: symbol.params,
-                returnType: symbol.returnType,
-                signature: formatExportSignature(index, symbol)
+                returnType: variable ? variable.typeAnnotation || null : symbol.returnType,
+                signature: variable
+                    ? `${variable.declKind} ${variable.name}${variable.typeAnnotation ? ': ' + variable.typeAnnotation : ''}`
+                    : formatExportSignature(index, symbol),
+                ...(defaultOnly && { isDefault: true }),
             });
         }
     }
@@ -522,63 +533,59 @@ function fileExports(index, filePath, _visited) {
         const matchedNames = new Set(results.map(r => r.name));
         const unmatched = fileEntry.exports.filter(name => !matchedNames.has(name));
         if (unmatched.length > 0) {
-            // Re-extract raw imports to get name→module mapping (not stored in fileEntry)
-            try {
-                const content = index._readFile(absPath);
-                const { imports: rawImports } = extractImports(content, 'python');
-                // Build name→module map from raw imports
-                const nameToModule = new Map();
-                for (const imp of rawImports) {
-                    if (imp.names) {
-                        for (const name of imp.names) {
-                            if (name !== '*') nameToModule.set(name, imp.module);
-                        }
+            // Read imports for exported names that have no local declaration.
+            const content = index._readFile(absPath);
+            const { imports: rawImports } = extractImports(content, 'python');
+            // Build name→module map from raw imports
+            const nameToModule = new Map();
+            for (const imp of rawImports) {
+                if (imp.names) {
+                    for (const name of imp.names) {
+                        if (name !== '*') nameToModule.set(name, imp.module);
                     }
                 }
-                for (const name of unmatched) {
-                    const sourceModule = nameToModule.get(name);
-                    if (!sourceModule) continue;
-                    const resolvedSrc = resolveImport(sourceModule, absPath, {
-                        language: 'python',
-                        root: index.root,
-                        extensions: index.extensions
+            }
+            for (const name of unmatched) {
+                const sourceModule = nameToModule.get(name);
+                if (!sourceModule) continue;
+                const resolvedSrc = resolveImport(sourceModule, absPath, {
+                    language: 'python',
+                    root: index.root,
+                    extensions: index.extensions
+                });
+                if (!resolvedSrc) continue;
+                const sourceEntry = index.files.get(resolvedSrc);
+                const srcSymbol = sourceEntry && sourceEntry.symbols.find(s => s.name === name);
+                if (srcSymbol) {
+                    matchedNames.add(name);
+                    results.push({
+                        name,
+                        type: srcSymbol.type,
+                        file: fileEntry.relativePath,
+                        startLine: srcSymbol.startLine,
+                        endLine: srcSymbol.endLine,
+                        params: srcSymbol.params,
+                        returnType: srcSymbol.returnType,
+                        signature: index.formatSignature(srcSymbol),
+                        reExportedFrom: sourceEntry.relativePath
+                    });
+                } else {
+                    // Source not indexed or symbol not found — still list it
+                    matchedNames.add(name);
+                    results.push({
+                        name,
+                        type: 're-export',
+                        file: fileEntry.relativePath,
+                        startLine: undefined,
+                        endLine: undefined,
+                        params: undefined,
+                        returnType: null,
+                        signature: `re-export ${name} from '${sourceModule}'`,
+                        reExportedFrom: resolvedSrc
+                            ? (sourceEntry ? sourceEntry.relativePath : resolvedSrc)
+                            : sourceModule
                     });
-                    if (!resolvedSrc) continue;
-                    const sourceEntry = index.files.get(resolvedSrc);
-                    const srcSymbol = sourceEntry && sourceEntry.symbols.find(s => s.name === name);
-                    if (srcSymbol) {
-                        matchedNames.add(name);
-                        results.push({
-                            name,
-                            type: srcSymbol.type,
-                            file: fileEntry.relativePath,
-                            startLine: srcSymbol.startLine,
-                            endLine: srcSymbol.endLine,
-                            params: srcSymbol.params,
-                            returnType: srcSymbol.returnType,
-                            signature: index.formatSignature(srcSymbol),
-                            reExportedFrom: sourceEntry.relativePath
-                        });
-                    } else {
-                        // Source not indexed or symbol not found — still list it
-                        matchedNames.add(name);
-                        results.push({
-                            name,
-                            type: 're-export',
-                            file: fileEntry.relativePath,
-                            startLine: undefined,
-                            endLine: undefined,
-                            params: undefined,
-                            returnType: null,
-                            signature: `re-export ${name} from '${sourceModule}'`,
-                            reExportedFrom: resolvedSrc
-                                ? (sourceEntry ? sourceEntry.relativePath : resolvedSrc)
-                                : sourceModule
-                        });
-                    }
                 }
-            } catch (_) {
-                // File read failure — skip Python re-export resolution
             }
         }
     }
@@ -991,6 +998,11 @@ function circularDeps(index, options = {}) {
                         }),
                     });
                 }
+                // Go/Rust/Java/C#/C/C++ files run no module code when they
+                // are imported or included: their cycles are static
+                // dependency cycles, neither import-time nor deferred.
+                const runsModules = rotatedAbs.some(file =>
+                    langTraits(index.files.get(file)?.language)?.importsRunModules !== false);
                 const deferredEdges = edges.filter(edge => edge.deferred)
                     .map(edge => ({
                         from: edge.from,
@@ -1002,7 +1014,7 @@ function circularDeps(index, options = {}) {
                 uniqueCycles.push({
                     files: rotated,
                     length: rotated.length,
-                    classification: deferredEdges.length > 0 ? 'deferred' : 'eager',
+                    classification: !runsModules ? 'static' : deferredEdges.length > 0 ? 'deferred' : 'eager',
                     edges,
                     deferredEdges,
                 });
@@ -1023,8 +1035,10 @@ function circularDeps(index, options = {}) {
             if (targets && targets.size > 0) filesWithImports++;
         }
 
-        const eagerCycles = result.filter(cycle => cycle.classification !== 'deferred').length;
-        const deferredCycles = result.length - eagerCycles;
+        const eagerCycles = result.filter(cycle => cycle.classification !== 'deferred' &&
+            cycle.classification !== 'static').length;
+        const deferredCycles = result.filter(cycle => cycle.classification === 'deferred').length;
+        const staticCycles = result.length - eagerCycles - deferredCycles;
         const groupOf = new Map();
         componentSummaries.forEach((group, i) => { for (const f of group.files) groupOf.set(f, i); });
         for (const group of componentSummaries) { group.eagerCycles = 0; group.deferredCycles = 0; }
@@ -1032,6 +1046,7 @@ function circularDeps(index, options = {}) {
             const group = componentSummaries[groupOf.get(cycle.files[0])];
             if (!group) continue;
             if (cycle.classification === 'deferred') group.deferredCycles++;
+            else if (cycle.classification === 'static') group.staticCycles = (group.staticCycles || 0) + 1;
             else group.eagerCycles++;
         }
         const cycleGroups = fileFilter
@@ -1050,6 +1065,7 @@ function circularDeps(index, options = {}) {
                 filesInCycles: new Set(cycleGroups.flatMap(c => c.files)).size,
                 eagerCycles,
                 deferredCycles,
+                ...(staticCycles > 0 && { staticCycles }),
                 componentCount: cycleGroups.length,
                 ...(truncated && { truncated: true, cycleLimit,
                     maxComponentSize: MAX_ENUMERATED_COMPONENT,

package/core/ignore-rules.js

@@ -46,7 +46,8 @@ const POSIX_CLASSES = {
     lower: 'a-z',
     print: '\\x20-\\x7e',
     punct: '!-\\/:-@\\[-`{-~',
-    space: ' \\t\\n\\v\\f\\r',
+    // git's sane ctype isspace: space, \t, \n and \r, never \v or \f (fix #433).
+    space: ' \\t\\n\\r',
     upper: 'A-Z',
     xdigit: '0-9A-Fa-f',
 };

package/core/imports.js

@@ -22,16 +22,12 @@ function extractImports(content, language) {
 
     const langModule = getLanguageAdapter(moduleLang);
     if (langModule && typeof langModule.findImportsInCode === 'function') {
-        try {
-            const parser = getParser(language);
-            if (parser) {
-                const imports = langModule.findImportsInCode(content, parser);
-                const dynamicCount = imports.filter(i => i.dynamic).length;
-                const importAliases = imports.aliases || null;
-                return { imports, dynamicCount, importAliases };
-            }
-        } catch (e) {
-            // AST parsing failed
+        const parser = getParser(language);
+        if (parser) {
+            const imports = langModule.findImportsInCode(content, parser);
+            const dynamicCount = imports.filter(i => i.dynamic).length;
+            const importAliases = imports.aliases || null;
+            return { imports, dynamicCount, importAliases };
         }
     }
 
@@ -47,14 +43,10 @@ function extractExports(content, language) {
 
     const langModule = getLanguageAdapter(moduleLang);
     if (langModule && typeof langModule.findExportsInCode === 'function') {
-        try {
-            const parser = getParser(language);
-            if (parser) {
-                const foundExports = langModule.findExportsInCode(content, parser);
-                return { exports: foundExports };
-            }
-        } catch (e) {
-            // AST parsing failed
+        const parser = getParser(language);
+        if (parser) {
+            const foundExports = langModule.findExportsInCode(content, parser);
+            return { exports: foundExports };
         }
     }
 
@@ -202,6 +194,17 @@ function resolveImport(importPath, fromFile, config = {}) {
     // Relative imports
     const extensions = config.extensions || getExtensions(config.language);
     const resolved = path.resolve(fromDir, normalizedPath);
+    // A JS/TS directory specifier (`require('..')`, `require('../')`) loads
+    // the directory's package.json `main` before its index file (Node's
+    // directory resolution, fix #423), unless a file of that name exists.
+    if (_isJsFamily(config.language) && _isDir(resolved) && !_isFile(resolved) &&
+        !extensions.some(ext => _isFile(resolved + ext))) {
+        const manifest = _findPackageJson(resolved, resolved);
+        if (manifest && manifest.dir === resolved && typeof manifest.main === 'string' && manifest.main) {
+            const main = resolveFilePath(path.resolve(resolved, manifest.main), extensions);
+            if (main) return main;
+        }
+    }
     const direct = resolveFilePath(resolved, extensions);
     if (direct) return direct;
 
@@ -459,6 +462,9 @@ function snapshotWorkspaceManifests(projectRoot) {
             packageName: info.packageName,
             srcDir: rel(info.srcDir),
             targetDirs: info.targetDirs.map(rel),
+            ...(info.dependencies && { dependencies: Object.fromEntries(Object.entries(info.dependencies)
+                .map(([name, dep]) => [name, { ...dep, ...(dep.path && { path: rel(dep.path) }) }])) }),
+            ...(info.edition && { edition: info.edition }),
         });
     }
     workspaceCrateCache.set(projectRoot, _registryFromManifestDirs(dirs));
@@ -480,6 +486,9 @@ function seedWorkspaceManifests(projectRoot, manifests) {
             srcDir: path.join(projectRoot, m.srcDir),
             packageName: m.packageName,
             targetDirs: m.targetDirs.map(t => path.join(projectRoot, t)),
+            ...(m.dependencies && { dependencies: Object.fromEntries(Object.entries(m.dependencies)
+                .map(([name, dep]) => [name, { ...dep, ...(dep.path && { path: path.join(projectRoot, dep.path) }) }])) }),
+            ...(m.edition && { edition: m.edition }),
         });
     }
     workspaceCrateCache.set(projectRoot, _registryFromManifestDirs(dirs));
@@ -516,6 +525,50 @@ function resetCargoCaches(projectRoot) {
     }
 }
 
+/**
+ * The crate names a manifest's dependency tables declare (fix #422), as
+ * code spells them (`-` read as `_`): `{ name: { path?, package?,
+ * workspace? } }` with `path` the dependency's directory for a path
+ * dependency, `package` the package a rename names, `workspace` for an entry
+ * inherited from the workspace. Null when the manifest declares none.
+ */
+function cargoDependencies(toml, dir) {
+    const deps = {};
+    let section = null;
+    let tableDep = null;
+    const add = (name, body) => {
+        const key = name.replace(/-/g, '_');
+        const entry = deps[key] || (deps[key] = {});
+        const pathMatch = /\bpath\s*=\s*"([^"]+)"/.exec(body);
+        if (pathMatch) entry.path = path.resolve(dir, pathMatch[1]);
+        const pkg = /\bpackage\s*=\s*"([^"]+)"/.exec(body);
+        if (pkg) entry.package = pkg[1].replace(/-/g, '_');
+        if (/\bworkspace\s*=\s*true\b/.test(body)) entry.workspace = true;
+    };
+    for (const raw of toml.split(/\r?\n/)) {
+        const line = raw.replace(/#.*$/, '').trim();
+        if (!line) continue;
+        const header = /^\[\s*([^\]]+?)\s*\]$/.exec(line);
+        if (header) {
+            const name = header[1].replace(/\s+/g, '');
+            const parts = name.split('.');
+            const kind = parts.findIndex(part => /^(dev-|build-)?dependencies$/.test(part));
+            section = kind >= 0 ? name : null;
+            tableDep = kind >= 0 && kind === parts.length - 2 ? parts[parts.length - 1].replace(/^["']|["']$/g, '') : null;
+            if (tableDep) add(tableDep, '');
+            continue;
+        }
+        if (!section) continue;
+        if (tableDep) {
+            add(tableDep, line);
+            continue;
+        }
+        const entry = /^["']?([A-Za-z0-9_-]+)["']?(\.workspace)?\s*=\s*(.*)$/.exec(line);
+        if (entry) add(entry[1], entry[2] ? 'workspace = true' : entry[3]);
+    }
+    return Object.keys(deps).length > 0 ? deps : null;
+}
+
 /**
  * Find the nearest Cargo.toml and return the crate's source root
  * @param {string} startDir - Directory to start searching from
@@ -539,11 +592,20 @@ function findCargoRoot(startDir) {
             // tests/*.rs — fix #246); `-` normalizes to `_` in code.
             let packageName = null;
             const targetDirs = [];
+            let dependencies = null;
+            let edition = null;
             try {
                 const toml = fs.readFileSync(cargoPath, 'utf-8');
                 const pkgSection = toml.split(/^\s*\[/m).find(s => s.startsWith('package]'));
                 const m = pkgSection && pkgSection.match(/^\s*name\s*=\s*"([^"]+)"/m);
                 if (m) packageName = m[1].replace(/-/g, '_');
+                // The edition decides how `use` paths start (fix #422): a
+                // package without one is 2015 (paths from the crate root);
+                // an inherited edition is not known here.
+                if (pkgSection) {
+                    const ed = pkgSection.match(/^\s*edition\s*=\s*"(\d+)"/m);
+                    edition = ed ? ed[1] : /^\s*edition(\.workspace|\s*=\s*\{)/m.test(pkgSection) ? null : '2015';
+                }
                 // Explicit target roots (fix #260b, ripgrep-measured): a
                 // manifest may root its targets OUTSIDE src/ — ripgrep's
                 // `[[bin]] path = "crates/core/main.rs"` puts the whole bin
@@ -554,8 +616,10 @@ function findCargoRoot(startDir) {
                     const tDir = path.dirname(path.resolve(dir, tm[1]));
                     if (!targetDirs.includes(tDir)) targetDirs.push(tDir);
                 }
+                dependencies = cargoDependencies(toml, dir);
             } catch { /* unreadable Cargo.toml — no package identity */ }
-            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName, targetDirs };
+            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName, targetDirs,
+                ...(dependencies && { dependencies }), ...(edition && { edition }) };
             cargoCache.set(startDir, result);
             return result;
         }
@@ -1006,7 +1070,10 @@ function _resolvePackageSpecifier(pkg, importPath, config) {
         return subpath === '.' ? tryTargets(exp, null) : null;
     }
     if (exp && typeof exp === 'object') {
+        // The subpath's entry, exact or through a '*' pattern.
+        let matched = null;
         if (exp[subpath] !== undefined) {
+            matched = { entry: exp[subpath], wildcard: null };
             const hit = tryTargets(exp[subpath], null);
             if (hit) return hit;
         }
@@ -1018,6 +1085,7 @@ function _resolvePackageSpecifier(pkg, importPath, config) {
             if (subpath.length > pre.length + post.length &&
                 subpath.startsWith(pre) && subpath.endsWith(post)) {
                 const wild = subpath.slice(pre.length, subpath.length - post.length);
+                if (!matched) matched = { entry: val, wildcard: wild };
                 const hit = tryTargets(val, wild);
                 if (hit) return hit;
             }
@@ -1031,6 +1099,11 @@ function _resolvePackageSpecifier(pkg, importPath, config) {
             if (source) return source;
         }
         if (subpath === '.' && pkg.workspace) return _workspaceSourceEntry(pkg, extensions);
+        // A subpath of a package of the repository whose targets are build
+        // output absent from the checkout (fix #423, swr `swr/infinite` ->
+        // `./dist/infinite/index.mjs`) is its source under `src/`, the
+        // layout the package's own entry falls back to.
+        if (matched && pkg.workspace) return _workspaceSubpathSource(pkg, matched, extensions);
         return null;
     }
     // No exports map: bare name -> main/index; subpath -> direct file
@@ -1042,6 +1115,55 @@ function _resolvePackageSpecifier(pkg, importPath, config) {
     return resolveFilePath(path.resolve(pkg.dir, subpath), extensions);
 }
 
+// Export conditions in the order a source build resolves them: the module
+// and default entries first, platform and custom conditions after.
+const _SOURCE_CONDITION_RANK = ['import', 'module', 'default', 'require', 'node', 'browser'];
+
+/** The export targets of an entry with their condition paths (fix #423). */
+function _conditionTargets(entry, conditions = [], out = []) {
+    if (typeof entry === 'string') out.push({ target: entry, conditions });
+    else if (Array.isArray(entry)) for (const e of entry) _conditionTargets(e, conditions, out);
+    else if (entry && typeof entry === 'object') {
+        for (const [cond, v] of Object.entries(entry)) _conditionTargets(v, [...conditions, cond], out);
+    }
+    return out;
+}
+
+/**
+ * The source of a workspace package subpath whose export targets name build
+ * output absent from the checkout (fix #423): each target's path below its
+ * output directory, under the package's `src/` (`./dist/infinite/index.mjs`
+ * -> `src/infinite/index.ts`). Standard conditions are tried before custom
+ * ones (`react-server`), declaration targets last; a target leaving the
+ * package or a declaration file never answers.
+ */
+function _workspaceSubpathSource(pkg, matched, extensions) {
+    const rank = conditions => {
+        let worst = 0;
+        for (const cond of conditions) {
+            const at = cond === 'types' ? _SOURCE_CONDITION_RANK.length + 1
+                : (_SOURCE_CONDITION_RANK.indexOf(cond) === -1 ? _SOURCE_CONDITION_RANK.length
+                    : _SOURCE_CONDITION_RANK.indexOf(cond));
+            if (at > worst) worst = at;
+        }
+        return worst;
+    };
+    const targets = _conditionTargets(matched.entry)
+        .map((t, order) => ({ ...t, order, rank: rank(t.conditions) }))
+        .sort((a, b) => a.rank - b.rank || a.order - b.order);
+    for (const { target } of targets) {
+        const concrete = matched.wildcard != null ? target.replace(/\*/g, matched.wildcard) : target;
+        const rel = path.relative(pkg.dir, path.resolve(pkg.dir, concrete));
+        if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) continue;
+        const segments = rel.split(path.sep);
+        if (segments.length < 2 || segments[0] === 'src') continue;
+        const rest = segments.slice(1).join(path.sep).replace(/(\.d)?\.[cm]?[jt]sx?$/, '');
+        const hit = resolveFilePath(path.join(pkg.dir, 'src', rest), extensions);
+        if (hit && !/\.d\.[cm]?ts$/.test(hit)) return hit;
+    }
+    return null;
+}
+
 // A workspace package whose `main` names a build artifact absent from the
 // source checkout: its declared source/module/types entries, else src/index.
 function _workspaceSourceEntry(pkg, extensions) {
@@ -1105,6 +1227,10 @@ function _isDir(p) {
     try { return fs.statSync(p).isDirectory(); } catch { return false; }
 }
 
+function _isJsFamily(language) {
+    return language === 'javascript' || language === 'typescript' || language === 'tsx';
+}
+
 /**
  * Resolve an absolute Python module against the nearest non-package ancestor
  * of the importing file (fix #366). Walks from the importing directory up to

package/core/index-ir.js

@@ -45,6 +45,11 @@ function createImportBindings(imports) {
                 ...(item.deferred && { deferred: true }),
                 ...(item.dynamic && { dynamic: true }),
                 ...(item.namespace && { namespace: item.namespace }),
+                // Rust block `use` (fix #422): visible in its block only.
+                ...(item.lexicalScopeStartLine != null && {
+                    lexicalScopeStartLine: item.lexicalScopeStartLine,
+                    lexicalScopeEndLine: item.lexicalScopeEndLine,
+                }),
             };
         });
     });
@@ -106,6 +111,13 @@ function createFileEntryFromIR({
             ...(item.global && { global: true }),
             // Go (fix #400): the import writes no local name.
             ...(item.implicitName && { implicitName: true }),
+            // Rust block `use` (fix #422): visible in its block only; a
+            // `use` item's visibility.
+            ...(item.lexicalScopeStartLine != null && {
+                lexicalScopeStartLine: item.lexicalScopeStartLine,
+                lexicalScopeEndLine: item.lexicalScopeEndLine,
+            }),
+            ...(item.visibility && { visibility: item.visibility }),
         })),
         globalImports: imports.filter(item => item.global).map(item => item.module),
         importNames: imports.flatMap(item => item.names || []),
@@ -126,6 +138,7 @@ function createFileEntryFromIR({
         ...(ir.asyncClosureNames?.length > 0 && {
             asyncClosureNames: ir.asyncClosureNames,
         }),
+        ...(ir.itemMacros?.length > 0 && { itemMacros: ir.itemMacros }),
         ...(Array.isArray(ir.openCalls) && { openCalls: ir.openCalls }),
         ...(ir.typeConversions?.length > 0 && {
             typeConversions: ir.typeConversions,
@@ -133,12 +146,16 @@ function createFileEntryFromIR({
         ...(ir.reflectionSites?.length > 0 && {
             reflectionSites: ir.reflectionSites,
         }),
+        ...(Array.isArray(ir.computedDispatchSites) && {
+            computedDispatchSites: ir.computedDispatchSites,
+        }),
         ...(ir.macroScopeMarkers?.length > 0 && {
             macroScopeMarkers: ir.macroScopeMarkers,
         }),
         ...(ir.cppUsings?.length > 0 && {
             cppUsings: ir.cppUsings,
         }),
+        ...(Array.isArray(ir.typeParameterNames) && { typeParameterNames: ir.typeParameterNames }),
         ...(ir.languageFeatures?.length > 0 && {
             languageFeatures: ir.languageFeatures,
         }),
@@ -152,6 +169,7 @@ function createFileEntryFromIR({
         ...(ir.moduleValueAliases?.length > 0 && { moduleValueAliases: ir.moduleValueAliases }),
         ...(ir.moduleConstructedValues?.length > 0 && { moduleConstructedValues: ir.moduleConstructedValues }),
         ...(ir.configurationItems?.length > 0 && { configurationItems: ir.configurationItems }),
+        ...(Array.isArray(ir.cppBaseSyntax) && { cppBaseSyntax: ir.cppBaseSyntax }),
         ...(Array.isArray(ir.recoveryBlanks) && { recoveryBlanks: ir.recoveryBlanks }),
         ...(Array.isArray(ir.recoveryCandidates) && { recoveryCandidates: ir.recoveryCandidates }),
         ...(Array.isArray(ir.externalMacroNames) && { externalMacroNames: ir.externalMacroNames }),
@@ -161,13 +179,13 @@ function createFileEntryFromIR({
 }
 
 const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
-    'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
-    'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
+    'sourceSpan', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
+    'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'typeParameterConstraints', 'extends', 'implements', 'indent', 'isNested',
     'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType', 'embedded',
     'aliasOf', 'aliasQualifier', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
     'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'assignedObject', 'selfNamed', 'bodyScopedName',
-    'registryMember', 'registryContainer', 'registryContainerType', 'objectLiteralLine', 'namespace',
+    'registryMember', 'registryContainer', 'registryContainerType', 'objectLiteralLine', 'namespace', 'isConstructor',
     'isExtensionMethod', 'extensionReceiver', 'explicitInterface', 'primaryParams',
     'lexicalScopeStartLine', 'lexicalScopeEndLine',
     'returnTypeQualifier', 'returnTypeResolved', 'supertraits', 'ownerGenericBounds', 'ownerSelfArgs', 'implSelfRef', 'implSelfQualifier', 'blanketSelfBounds', 'selfParamKind', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType', 'futureReturn',
@@ -181,7 +199,9 @@ const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'generatedByMacro',
     'typeArity', 'ownerTypeArity',
     'annotationType', 'valueShape', 'friendOf', 'templateParams', 'delegateParams',
-        'typedefName',
+        'typedefName', 'forwardDeclaration', 'anonymousNamespace', 'specialization',
+        'memberConst', 'refQualifier', 'fieldPointers', 'memberPaths', 'instanceAttribute',
+        'ambientAugmentation',
 ]);
 
 function materializeSymbol(fileEntry, item) {
@@ -214,8 +234,25 @@ function materializeSymbol(fileEntry, item) {
     return symbol;
 }
 
+const fileBindingIds = new WeakMap();
+
 function addIRSymbol(fileEntry, item, symbolTable = null) {
     const symbol = materializeSymbol(fileEntry, item);
+    // Several declarations can occupy one source line. Keep the ordinary
+    // line-based id for its first declaration and give each later declaration
+    // an id of its own, in the parser's stable source order.
+    let ids = fileBindingIds.get(fileEntry);
+    if (!ids) {
+        ids = new Set(fileEntry.symbols.map(existing => existing.bindingId));
+        fileBindingIds.set(fileEntry, ids);
+    }
+    if (!item.id && ids.has(symbol.bindingId)) {
+        const base = symbol.bindingId;
+        let ordinal = 2;
+        while (ids.has(`${base}#${ordinal}`)) ordinal++;
+        symbol.bindingId = `${base}#${ordinal}`;
+    }
+    ids.add(symbol.bindingId);
     fileEntry.symbols.push(symbol);
     // 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

package/core/ir.js

@@ -62,8 +62,8 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         modifiers: [...(symbol.modifiers || [])],
     };
     const passthrough = [
-        'docstring', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
-        'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent',
+        'docstring', 'sourceSpan', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
+        'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'typeParameterConstraints', 'extends', 'implements', 'indent',
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType', 'embedded',
         'aliasOf', 'aliasQualifier', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
@@ -82,7 +82,9 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         'generatedByMacro',
         'typeArity', 'ownerTypeArity',
         'annotationType', 'valueShape', 'friendOf', 'templateParams', 'delegateParams',
-        'typedefName',
+        'typedefName', 'forwardDeclaration', 'anonymousNamespace', 'specialization',
+        'memberConst', 'refQualifier', 'fieldPointers', 'memberPaths', 'instanceAttribute',
+        'ambientAugmentation',
     ];
     for (const field of passthrough) {
         if (symbol[field] !== undefined && symbol[field] !== null) {
@@ -110,9 +112,15 @@ function createFileIR({
     const append = (symbol, family, kind, owner = null) => {
         // Members one macro invocation declares share its lines (fix #385):
         // their own binding ids keep overloads apart.
-        const key = `${owner || symbol.className || ''}\0${symbol.name}\0${kind}\0` +
-            `${symbol.startLine}\0${symbol.endLine}` +
-            (symbol.generatedByMacro ? `\0${symbol.bindingId || ''}` : '');
+        const key = JSON.stringify([
+            owner || symbol.className || '', symbol.name, kind,
+            symbol.startLine, symbol.endLine, symbol.namespace || '',
+            symbol.enclosingType || '', symbol.lexicalScopeStartLine ?? null,
+            symbol.lexicalScopeEndLine ?? null, symbol.anonymousNamespace || false,
+            symbol.typeArity ?? null, symbol.ownerTypeArity ?? null,
+            symbol.params ?? null,
+            symbol.generatedByMacro ? symbol.bindingId || '' : '',
+        ]);
         if (seen.has(key)) return;
         seen.add(key);
         normalizedSymbols.push(normalizeSymbol(symbol, family, language, kind, owner));
@@ -236,6 +244,10 @@ function createFileIR({
         ...(parsed.asyncClosureNames?.length > 0 && {
             asyncClosureNames: [...parsed.asyncClosureNames],
         }),
+        // Rust item-position macro invocations of each module (fix #422).
+        ...(parsed.itemMacros?.length > 0 && {
+            itemMacros: parsed.itemMacros.map(item => ({ ...item })),
+        }),
         // Shapes of calls whose value is not consumed where it is produced
         // (fix #371/#372): audit-async reads a file's call records only when
         // one of these can reach a future producer.
@@ -249,12 +261,18 @@ function createFileIR({
         ...(parsed.reflectionSites?.length > 0 && {
             reflectionSites: parsed.reflectionSites.map(item => ({ ...item })),
         }),
+        ...(Array.isArray(parsed.computedDispatchSites) && {
+            computedDispatchSites: parsed.computedDispatchSites.map(item => ({ ...item })),
+        }),
         ...(parsed.macroScopeMarkers?.length > 0 && {
             macroScopeMarkers: parsed.macroScopeMarkers.map(item => ({ ...item })),
         }),
         ...(parsed.cppUsings?.length > 0 && {
             cppUsings: parsed.cppUsings.map(item => ({ ...item })),
         }),
+        // Type-parameter names a file declares (fix #421), when the parser
+        // read them from the raw source.
+        ...(Array.isArray(parsed.typeParameterNames) && { typeParameterNames: [...parsed.typeParameterNames] }),
         ...(parsed.languageFeatures?.length > 0 && {
             languageFeatures: [...parsed.languageFeatures],
         }),
@@ -289,6 +307,9 @@ function createFileIR({
         }),
         // The byte ranges the C/C++ recovery blanked (fix #387): a query
         // rebuilds the recovered tree with one parse.
+        ...(Array.isArray(parsed.cppBaseSyntax) && { cppBaseSyntax: parsed.cppBaseSyntax.map(row => ({
+            ...row, syntax: row.syntax && { ...row.syntax, namespaces: [...row.syntax.namespaces], classes: [...row.syntax.classes] },
+        })) }),
         ...(Array.isArray(parsed.recoveryBlanks) && {
             recoveryBlanks: parsed.recoveryBlanks.map(range => [...range]),
         }),