ucn 5.4.2 → 5.5.1

package/core/rust-macro-expansion.js

@@ -0,0 +1,3026 @@
+'use strict';
+
+/**
+ * Project-local Rust `macro_rules!` expansion (fix #374).
+ *
+ * A project macro invocation generates code the AST never shows: impl blocks
+ * (`delegate_iterator! { Iter<'a, K, V> => .., impl<..> }`), test functions
+ * (`quickcheck! { fn prop(a: Iter<u16>) -> bool { .. } }`), forwarding
+ * methods (`deref_forward_buf!();` inside an impl) and calls whose receivers
+ * only get a type once the arguments sit in their expanded context. This
+ * module expands such invocations at build time and makes what they generate
+ * ordinary index facts:
+ *
+ *   1. Invocations are the grammar's `macro_invocation` nodes whose macro
+ *      resolves to a project `macro_rules!` by Rust's own scoping: textual
+ *      scope (earlier in the file, `#[macro_use] mod` children, the parent
+ *      module up to the `mod` declaration), then path scope
+ *      (`#[macro_export]` macros through `crate::`/`$crate::`/package paths,
+ *      `use` bindings, globs, `#[macro_use] extern crate`).
+ *   2. languages/rust-macro-rules.js matches the invocation's token trees
+ *      against the rules and transcribes; project macros invoked by the
+ *      transcription expand recursively (bounded depth and output), locals
+ *      the transcriber introduces are renamed apart (hygiene) and `$crate`
+ *      names the defining crate.
+ *   3. The file is re-analyzed with every expansion spliced in place of its
+ *      invocation, laid out on the invocation's own lines (argument tokens
+ *      keep their line), so the full Rust parser extracts functions, impls,
+ *      calls and receiver facts in their real context. The file's symbols
+ *      and call records become those of the expanded file: facts produced
+ *      inside an invocation carry `macroExpansion {macro, definition, origin,
+ *      line}` (origin 'argument' when the token was written in the
+ *      invocation, 'template' when it came from the transcriber).
+ *
+ * An invocation whose rules do not match, whose expansion exceeds the bounds
+ * or does not parse in its context stays as written (the parser's token-tree
+ * view) and is recorded as blind, disclosed by `repo --sections=health
+ * --deep` and deadcode. Macros from dependencies (`vec!`, `println!`, a
+ * crate's `quickcheck!`) are never expanded: their definitions are not in the
+ * project. Results are persisted with the file entry and revalidated against
+ * the file, every macro definition it used and its module ancestry.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { getParser, safeParse, PARSE_OPTIONS } = require('../languages');
+const { addIRSymbol } = require('./index-ir');
+const { findCargoRoot } = require('./imports');
+const {
+    MacroBlind, argTokensOf, compileMacro, expandWithRules, isPostfixChain, tokenCount,
+} = require('../languages/rust-macro-rules');
+const { codeUnitCompare } = require('./shared');
+
+const MAX_DEPTH = 64;
+const MAX_OUTPUT_TOKENS = 20000;
+const BLIND_SAMPLE = 20;
+
+function isRust(fileEntry) {
+    return fileEntry?.language === 'rust';
+}
+
+/** name -> Rust macro_rules! definitions. */
+function macroInventory(index) {
+    const inventory = new Map();
+    for (const [name, defs] of index.symbols) {
+        for (const def of defs) {
+            if (def.type !== 'macro') continue;
+            if (!isRust(index.files.get(def.file))) continue;
+            if (!inventory.has(name)) inventory.set(name, []);
+            inventory.get(name).push(def);
+        }
+    }
+    return inventory;
+}
+
+function defKey(def) {
+    return `${def.relativePath}:${def.startLine}`;
+}
+
+// ── Per-pass state ────────────────────────────────────────────────────────
+
+function createState(index, inventory = null) {
+    return {
+        index,
+        parser: getParser('rust'),
+        inventory: inventory || macroInventory(index),
+        contents: new Map(),
+        trees: new Map(),
+        compiled: new Map(),
+        parents: null,
+        packages: new Map(),     // file dir -> cargo info
+        crateNames: null,        // crate name -> package root dir
+        roots: new Map(),        // file -> crate root file
+        macroUseCrates: new Map(), // crate root file -> Set<crate name>
+        lineStarts: new Map(),
+        textualMemo: new Map(),
+        productive: new Map(),
+        hygieneSeq: 0,
+        contexts: new Map(),     // file -> calls-pass context (fix #405)
+        resolved: new Map(),     // invocation -> resolveMacro answer
+    };
+}
+
+function readContent(state, file) {
+    let content = state.contents.get(file);
+    if (content === undefined) {
+        try {
+            content = state.index._readFile(file);
+        } catch {
+            content = null;
+        }
+        state.contents.set(file, content);
+    }
+    return content;
+}
+
+function treeOf(state, file) {
+    if (state.trees.has(file)) return state.trees.get(file);
+    const content = readContent(state, file);
+    const tree = content === null ? null : safeParse(state.parser, content, undefined, PARSE_OPTIONS);
+    state.trees.set(file, tree);
+    return tree;
+}
+
+/** child module file -> { file, line, macroUse } from `mod x;` declarations. */
+function moduleParents(state) {
+    if (state.parents) return state.parents;
+    const parents = new Map();
+    const index = state.index;
+    for (const [file, entry] of index.files) {
+        if (!isRust(entry) || !entry.moduleResolved) continue;
+        for (const detail of entry.importDetails || []) {
+            if (detail.type !== 'mod') continue;
+            const rel = entry.moduleResolved[detail.module];
+            if (!rel) continue;
+            const child = path.join(index.root, rel);
+            if (child === file || parents.has(child)) continue;
+            const decl = (entry.symbols || []).find(symbol => symbol.type === 'module' &&
+                symbol.name === detail.module && symbol.startLine === detail.line);
+            parents.set(child, {
+                file, line: detail.line,
+                macroUse: !!decl?.modifiers?.includes('macro_use'),
+            });
+        }
+    }
+    state.parents = parents;
+    return parents;
+}
+
+function crateRoot(state, file) {
+    if (state.roots.has(file)) return state.roots.get(file);
+    const parents = moduleParents(state);
+    let current = file;
+    const seen = new Set();
+    while (parents.has(current) && !seen.has(current)) {
+        seen.add(current);
+        current = parents.get(current).file;
+    }
+    state.roots.set(file, current);
+    return current;
+}
+
+function packageOf(state, file) {
+    const dir = path.dirname(file);
+    if (!state.packages.has(dir)) state.packages.set(dir, findCargoRoot(dir) || null);
+    return state.packages.get(dir);
+}
+
+function packageByCrateName(state, name) {
+    if (!state.crateNames) {
+        state.crateNames = new Map();
+        for (const [file, entry] of state.index.files) {
+            if (!isRust(entry)) continue;
+            const info = packageOf(state, file);
+            if (info?.packageName && !state.crateNames.has(info.packageName)) {
+                state.crateNames.set(info.packageName, info.root);
+            }
+        }
+    }
+    return state.crateNames.get(name) || null;
+}
+
+function isLibRoot(state, rootFile) {
+    const info = packageOf(state, rootFile);
+    return !!info && rootFile === path.join(info.srcDir, 'lib.rs');
+}
+
+/** Tokens `$crate` becomes for a definition expanded at `siteFile`. */
+function crateTokensFor(state, def, siteFile) {
+    const defRoot = crateRoot(state, def.file);
+    if (defRoot === crateRoot(state, siteFile) || !isLibRoot(state, defRoot)) {
+        return [{ k: 'ident', v: 'crate' }];
+    }
+    const name = packageOf(state, def.file)?.packageName;
+    return [{ k: 'ident', v: name || 'crate' }];
+}
+
+// ── Definitions ───────────────────────────────────────────────────────────
+
+function attributeNames(node) {
+    const names = [];
+    for (let sibling = node.previousNamedSibling; sibling; sibling = sibling.previousNamedSibling) {
+        if (sibling.type === 'line_comment' || sibling.type === 'block_comment') continue;
+        if (sibling.type !== 'attribute_item') break;
+        const attribute = sibling.namedChildren.find(child => child.type === 'attribute');
+        const head = attribute?.namedChildren.find(child =>
+            child.type === 'identifier' || child.type === 'scoped_identifier');
+        if (head) names.push(head.text);
+    }
+    return names;
+}
+
+/** Compiled definition + lexical scope, memoized per pass. */
+function compiledDef(state, def) {
+    const key = defKey(def);
+    if (state.compiled.has(key)) return state.compiled.get(key);
+    // Attributes and textual scope are parser facts of the definition; the
+    // rules are compiled from the definition's own text, parsed alone with
+    // its lines kept (no re-parse of the defining file).
+    const attrs = def.modifiers || [];
+    const start = lineOffset(state, def.file, def.startLine);
+    const end = lineOffset(state, def.file, def.endLine + 1);
+    const scope = def.macroScope ? {
+        kind: def.macroScope.kind,
+        start: lineOffset(state, def.file, def.macroScope.startLine),
+        end: lineOffset(state, def.file, def.macroScope.endLine + 1),
+        ...(def.macroScope.macroUse && { macroUse: true }),
+    } : null;
+    const base = { start, end, exported: attrs.includes('macro_export'), cfg: attrs.includes('cfg'), scope };
+    let result;
+    const content = readContent(state, def.file);
+    const text = content === null ? null
+        : '\n'.repeat(def.startLine - 1) + content.slice(start, end);
+    const tree = text === null ? null : safeParse(state.parser, text, undefined, PARSE_OPTIONS);
+    const node = tree && tree.rootNode.descendantsOfType('macro_definition').find(candidate =>
+        candidate.startPosition.row + 1 === def.startLine &&
+        candidate.childForFieldName('name')?.text === def.name);
+    if (!node) {
+        result = { ...base, error: 'definition-unavailable' };
+    } else {
+        try {
+            result = { ...base, compiled: compileMacro(node) };
+        } catch (error) {
+            if (!(error instanceof MacroBlind)) throw error;
+            result = { ...base, error: error.reason };
+        }
+    }
+    state.compiled.set(key, result);
+    return result;
+}
+
+// ── Resolution ────────────────────────────────────────────────────────────
+
+/**
+ * Definitions of `name` in textual scope at (file, offset); `offset`
+ * Infinity asks what a module exports to its parent through #[macro_use].
+ * Returns [{def, pos}] candidates of the innermost scope that has any.
+ */
+function textualCandidates(state, file, offset, line, name, walkParents, seen = new Set()) {
+    if (seen.has(file)) return [];
+    seen.add(file);
+    const candidates = [];
+    for (const def of state.inventory.get(name) || []) {
+        if (def.file !== file) continue;
+        const info = compiledDef(state, def);
+        if (info.start === undefined) continue;
+        if (offset !== Infinity && info.end > offset) continue;
+        const scope = info.scope;
+        if (scope) {
+            const inside = offset >= scope.start && offset <= scope.end;
+            const after = scope.kind === 'mod' && scope.macroUse && offset >= scope.end;
+            if (offset === Infinity ? !(scope.kind === 'mod' && scope.macroUse) : !(inside || after)) continue;
+        }
+        candidates.push({ def, pos: info.start, info });
+    }
+    // `#[macro_use] mod child;` before this point brings the child's macros.
+    const entry = state.index.files.get(file);
+    const parents = moduleParents(state);
+    for (const detail of entry?.importDetails || []) {
+        if (detail.type !== 'mod' || !(detail.line < line || line === Infinity)) continue;
+        const rel = entry.moduleResolved?.[detail.module];
+        if (!rel) continue;
+        const child = path.join(state.index.root, rel);
+        const link = parents.get(child);
+        if (!link || link.file !== file || !link.macroUse) continue;
+        const exported = textualCandidates(state, child, Infinity, Infinity, name, false, seen);
+        // Position: the declaration line (same-line declarations are not
+        // idiomatic), keeping the child's own order among its definitions
+        // so its cfg alternatives stay together.
+        const declared = lineOffset(state, file, detail.line);
+        for (const candidate of exported) {
+            candidates.push({ ...candidate, pos: declared + candidate.pos / 1e12 });
+        }
+    }
+    if (candidates.length > 0) return candidates;
+    if (!walkParents) return [];
+    const parent = parents.get(file);
+    if (!parent) return [];
+    // What the parent sees at the child's `mod` declaration does not depend
+    // on where in the child the invocation is.
+    const key = `${parent.file}\0${parent.line}\0${name}`;
+    if (!state.textualMemo.has(key)) {
+        state.textualMemo.set(key, textualCandidates(state, parent.file,
+            lineOffset(state, parent.file, parent.line), parent.line, name, true, new Set(seen)));
+    }
+    return state.textualMemo.get(key);
+}
+
+function lineOffset(state, file, line) {
+    let starts = state.lineStarts.get(file);
+    if (!starts) {
+        const content = readContent(state, file);
+        starts = [0];
+        if (content !== null) {
+            for (let i = content.indexOf('\n'); i >= 0; i = content.indexOf('\n', i + 1)) starts.push(i + 1);
+        }
+        state.lineStarts.set(file, starts);
+    }
+    return starts[Math.min(Math.max(line - 1, 0), starts.length - 1)];
+}
+
+/** Offset just past `line` (its newline included), or the content's end. */
+function lineEndOffset(state, file, line) {
+    lineOffset(state, file, 1);
+    const starts = state.lineStarts.get(file);
+    return line < starts.length ? starts[line] : (readContent(state, file) || '').length;
+}
+
+function pickLatest(candidates) {
+    return candidates.reduce((best, candidate) => (!best || candidate.pos > best.pos ? candidate : best), null);
+}
+
+/**
+ * Definitions a bare or path invocation of `name` resolves to at
+ * (file, offset). Returns { defs, ambiguous } or null (not a project macro
+ * in scope).
+ */
+function resolveMacro(state, file, offset, line, name, qualifier, dollarCratePackage) {
+    // An invocation's answer is asked again by the pass that expands it
+    // (fix #405: fileMayExpand resolved every invocation first).
+    const key = `${file}\0${offset}\0${line}\0${name}\0${qualifier || ''}\0${dollarCratePackage || ''}`;
+    if (state.resolved.has(key)) return state.resolved.get(key);
+    const result = resolveMacroUncached(state, file, offset, line, name, qualifier, dollarCratePackage);
+    state.resolved.set(key, result);
+    return result;
+}
+
+function resolveMacroUncached(state, file, offset, line, name, qualifier, dollarCratePackage) {
+    const all = state.inventory.get(name);
+    if (!all || all.length === 0) return null;
+    const inPackage = pkgRoot => all.filter(def => packageOf(state, def.file)?.root === pkgRoot);
+    const preferExported = defs => {
+        const exported = defs.filter(def => compiledDef(state, def).exported);
+        return exported.length > 0 ? exported : defs;
+    };
+    const finish = defs => {
+        if (defs.length === 0) return null;
+        return { defs: defs.slice(0, 4), ambiguous: defs.length > 1 };
+    };
+    if (qualifier) {
+        const first = qualifier.split('::')[0];
+        const pkgRoot = dollarCratePackage ||
+            (['crate', 'self', 'super', '$crate'].includes(first) ? packageOf(state, file)?.root
+                : packageByCrateName(state, first));
+        if (!pkgRoot) return null;
+        return finish(preferExported(inPackage(pkgRoot)));
+    }
+    const textual = textualCandidates(state, file, offset, line, name, true);
+    if (textual.length > 0) {
+        const best = pickLatest(textual);
+        // Configuration alternatives: several cfg-gated definitions visible
+        // from the same scope.
+        const alternatives = best.info?.cfg
+            ? textual.filter(candidate => candidate.info?.cfg && candidate.def.file === best.def.file)
+            : [best];
+        // Every configuration's definition expands: cfg-gated code is code.
+        return {
+            defs: alternatives.map(candidate => candidate.def).slice(0, 4),
+            alternatives: alternatives.length > 1,
+            ambiguous: false,
+        };
+    }
+    const own = packageOf(state, file);
+    const root = crateRoot(state, file);
+    const entry = state.index.files.get(file);
+    // #[macro_export] macros live in their crate root's namespace.
+    if (own && root === file) {
+        const exported = inPackage(own.root).filter(def => compiledDef(state, def).exported &&
+            crateRoot(state, def.file) === root);
+        if (exported.length > 0) return finish(exported);
+    }
+    // `use crate::m;` / `use pkg::m;` / `use pkg::path::m as n;`
+    for (const binding of entry?.importBindings || []) {
+        const local = binding.alias || binding.name;
+        if (local !== name) continue;
+        const first = String(binding.module || '').split('::')[0];
+        const pkgRoot = ['crate', 'self', 'super'].includes(first) ? own?.root
+            : packageByCrateName(state, first);
+        if (!pkgRoot) continue;
+        const found = finish(preferExported(inPackage(pkgRoot)));
+        if (found) return found;
+    }
+    // `use pkg::*;` and `#[macro_use] extern crate pkg;`
+    const crates = new Set();
+    for (const detail of entry?.importDetails || []) {
+        if (detail.type === 'use-glob' && !String(detail.module).includes('::')) crates.add(detail.module);
+    }
+    for (const crate of macroUseCrates(state, root)) crates.add(crate);
+    for (const crate of crates) {
+        const pkgRoot = crate === 'crate' ? own?.root : packageByCrateName(state, crate);
+        if (!pkgRoot) continue;
+        const exported = inPackage(pkgRoot).filter(def => compiledDef(state, def).exported);
+        const found = finish(exported);
+        if (found) return found;
+    }
+    return null;
+}
+
+/** Crates whose macros a crate root imports with `#[macro_use] extern crate`. */
+function macroUseCrates(state, rootFile) {
+    if (state.macroUseCrates.has(rootFile)) return state.macroUseCrates.get(rootFile);
+    const crates = new Set();
+    const content = readContent(state, rootFile);
+    if (content !== null && content.includes('macro_use')) {
+        const tree = treeOf(state, rootFile);
+        for (const node of tree?.rootNode.namedChildren || []) {
+            if (node.type !== 'extern_crate_declaration') continue;
+            if (!attributeNames(node).includes('macro_use')) continue;
+            const name = node.childForFieldName('name')?.text;
+            if (name) crates.add(name);
+        }
+    }
+    state.macroUseCrates.set(rootFile, crates);
+    return crates;
+}
+
+// ── Productivity ──────────────────────────────────────────────────────────
+
+/**
+ * Whether expanding a macro can change the facts of the code it expands to
+ * beyond the parser's token-tree view of the invocation (whose argument
+ * calls are already recorded and typed in scope, and whose template calls
+ * are already visible at the definition): it declares items, binds argument
+ * fragments as locals or parameters, places an argument in callee position
+ * (`$f(..)`, `x.$m(..)`), or invokes a project macro that does.
+ * Other macros (logging, `try!`-style matches, assertions) are not expanded.
+ */
+/**
+ * true (always worth expanding), 'callee' (only where an argument names a
+ * project callable) or false.
+ */
+function productivity(state, def, visiting = new Set()) {
+    const key = defKey(def);
+    if (state.productive.has(key)) return state.productive.get(key);
+    if (visiting.has(key)) return false;
+    visiting.add(key);
+    const info = compiledDef(state, def);
+    let productive;
+    if (info.compiled) {
+        productive = info.compiled.declares || info.compiled.bindsArgs ? true
+            : info.compiled.callsArgs ? 'callee' : false;
+        for (const name of info.compiled.invokes) {
+            if (productive === true) break;
+            for (const other of state.inventory.get(name) || []) {
+                const nested = productivity(state, other, visiting);
+                if (nested === true) productive = true;
+                else if (nested === 'callee' && !productive) productive = 'callee';
+            }
+        }
+    } else {
+        // A definition the engine cannot model is expanded (and disclosed).
+        productive = true;
+    }
+    state.productive.set(key, productive);
+    return productive;
+}
+
+/**
+ * Whether an invocation of `defs` is worth expanding given its source text:
+ * a macro that only moves arguments into callee position is expanded where
+ * an argument word names a project callable (a word scan of the invocation
+ * is only a prefilter; the expansion decides what is a call).
+ */
+function worthExpanding(state, defs, text, expressionContext) {
+    let calleeOnly = false;
+    for (const def of defs) {
+        const level = productivity(state, def);
+        if (level === true) return true;
+        if (level === 'callee') calleeOnly = true;
+    }
+    if (expressionContext && forwardsValue(state, defs)) return true;
+    if (!calleeOnly || !text) return false;
+    for (const word of new Set(text.match(/[A-Za-z_][A-Za-z0-9_]*/g) || [])) {
+        if (namesCallable(state.index, word)) return true;
+    }
+    return false;
+}
+
+const NON_CALLABLE_DEF_TYPES = new Set(['macro', 'struct', 'enum', 'trait', 'module', 'type', 'impl', 'field']);
+
+/** Whether a project definition named `word` can be called. */
+function namesCallable(index, word) {
+    if (index.callableNames) return index.callableNames.has(word);
+    const defs = index.symbols.get(word);
+    return !!defs && defs.some(def => !NON_CALLABLE_DEF_TYPES.has(def.type));
+}
+
+/** An expression-position invocation whose value is one of its arguments. */
+function forwardsValue(state, defs) {
+    return defs.some(def => compiledDef(state, def).compiled?.forwardsValue);
+}
+
+/**
+ * Whether any recorded invocation of the file can need expanding, decided
+ * from call records before the file is parsed again.
+ */
+function fileMayExpand(state, filePath) {
+    const calls = state.index.callsCache.get(filePath)?.calls || [];
+    let memberRanges = null;
+    const inImplOrTrait = line => {
+        memberRanges ||= (state.index.files.get(filePath)?.symbols || [])
+            .filter(symbol => symbol.type === 'impl' || symbol.type === 'trait')
+            .map(symbol => [symbol.startLine, symbol.endLine]);
+        return memberRanges.some(([start, end]) => line >= start && line <= end);
+    };
+    for (const call of calls) {
+        if (!call.isMacro || call.inMacro || call.macroExpansion || !state.inventory.has(call.name)) continue;
+        if (!Number.isInteger(call.callStart)) return true;
+        const qualifier = call.isPathMacro ? call.receiver : null;
+        const resolved = resolveMacro(state, filePath, call.callStart, call.line, call.name, qualifier, null);
+        if (!resolved) continue;
+        // Item wrappers (`cfg_x! { items }`) at module level declare what the
+        // parser already recovers from their token trees.
+        if (resolved.defs.every(def => compiledDef(state, def).compiled?.passThroughItems) &&
+            !call.enclosingFunction && !inImplOrTrait(call.line)) continue;
+        const content = readContent(state, filePath);
+        const text = content === null ? null : content.slice(call.callStart, call.callEnd || call.callStart);
+        // Expression position is a parser fact of the invocation record.
+        if (worthExpanding(state, resolved.defs, text, call.macroExpr === true)) return true;
+    }
+    return false;
+}
+
+// ── Expansion ─────────────────────────────────────────────────────────────
+
+function invocationName(node) {
+    const macroNode = node.childForFieldName('macro');
+    if (!macroNode) return null;
+    const parts = macroNode.text.split('::').filter(Boolean);
+    const name = parts.pop();
+    if (!name) return null;
+    return { name, qualifier: parts.length > 0 ? parts.join('::') : null };
+}
+
+/** Syntactic context the invocation's expansion is parsed in. */
+function invocationContext(node) {
+    return require('../languages/rust').rustMacroInvocationContext(node);
+}
+
+function itemRecoveryPosition(node) {
+    if (node.parent?.type === 'source_file') return true;
+    return node.parent?.type === 'declaration_list' && node.parent.parent?.type === 'mod_item';
+}
+
+function isTok(tok, v) {
+    return tok && tok.k !== 'group' && tok.v === v;
+}
+
+/**
+ * Expand `toks` (an invocation's token list) with one definition, then every
+ * project macro the transcription invokes. `site` carries the budgets, the
+ * used definitions and blind records of this top-level invocation.
+ */
+function expandTokens(state, site, def, toks, depth) {
+    if (depth > MAX_DEPTH) throw new MacroBlind('recursion-depth');
+    const info = compiledDef(state, def);
+    if (info.error) throw new MacroBlind(info.error);
+    site.used.set(defKey(def), def);
+    const ctx = {
+        macro: def.name,
+        hygiene: ++state.hygieneSeq,
+        crateTokens: crateTokensFor(state, def, site.file),
+        budget: site.budget,
+    };
+    const { tokens } = expandWithRules(info.compiled, toks, ctx);
+    site.budget -= tokenCount(tokens);
+    if (site.budget < 0) throw new MacroBlind('output-budget');
+    return expandNested(state, site, def, tokens, depth);
+}
+
+function expandNested(state, site, def, tokens, depth) {
+    const out = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok.k === 'group') {
+            out.push({ ...tok, c: expandNested(state, site, def, tok.c, depth) });
+            continue;
+        }
+        if (tok.k !== 'ident' || isTok(tokens[i - 1], '::') || tok.v === 'macro_rules') {
+            out.push(tok);
+            continue;
+        }
+        let k = i;
+        const segments = [tok.v];
+        while (isTok(tokens[k + 1], '::') && tokens[k + 2]?.k === 'ident') {
+            k += 2;
+            segments.push(tokens[k].v);
+        }
+        const group = tokens[k + 2];
+        if (!isTok(tokens[k + 1], '!') || group?.k !== 'group') {
+            out.push(tok);
+            continue;
+        }
+        const name = segments.pop();
+        const qualifier = segments.length > 0 ? segments.join('::') : null;
+        const dollarCratePackage = tok.dollarCrate ? packageOf(state, def.file)?.root : null;
+        let resolved = resolveMacro(state, site.file, site.offset, site.line, name, qualifier, dollarCratePackage);
+        if (!resolved && !qualifier) {
+            const info = compiledDef(state, def);
+            resolved = resolveMacro(state, def.file, info.start ?? 0, def.startLine, name, null, null);
+        }
+        if (!resolved) {
+            out.push(tok);
+            continue;
+        }
+        const prev = out[out.length - 1];
+        const following = tokens[k + 3];
+        // Statement/item position: at the start of a token list or after a
+        // statement, as a braced invocation or one ending its statement.
+        const statementPosition = (!prev || isTok(prev, ';') || (prev.k === 'group' && prev.d === '{')) &&
+            (group.d === '{' || !following || isTok(following, ';'));
+        let inner;
+        try {
+            inner = expandAlternatives(state, site, resolved, group.c, depth + 1,
+                statementPosition ? 'stmts' : 'expr');
+            if (resolved.ambiguous) site.ambiguous = true;
+        } catch (error) {
+            if (!(error instanceof MacroBlind)) throw error;
+            if (error.reason === 'output-budget') throw error;
+            site.nestedBlind.push({ macro: name, reason: error.reason });
+            out.push(tok);
+            continue;
+        }
+        out.push(...(statementPosition ? inner : wrapExpression(inner)));
+        i = k + 2;
+    }
+    return out;
+}
+
+/**
+ * Expand with every configuration alternative of a macro. Items and
+ * statements of each alternative are all kept (each is real code under its
+ * configuration); differing expression values become the arms of one
+ * `match`, so no configuration's calls are lost. Throws MacroBlind when no
+ * alternative expands.
+ */
+function expandAlternatives(state, site, resolved, toks, depth, context) {
+    const outputs = [];
+    const texts = new Set();
+    let failure = null;
+    for (const def of resolved.defs) {
+        try {
+            const tokens = expandTokens(state, site, def, cloneTree(toks), depth);
+            if (resolved.defs.length > 1) {
+                const text = tokenText(tokens);
+                if (texts.has(text)) continue;
+                texts.add(text);
+            }
+            outputs.push(tokens);
+        } catch (error) {
+            if (!(error instanceof MacroBlind) || error.reason === 'output-budget') throw error;
+            failure = failure || error;
+        }
+    }
+    if (outputs.length === 0) throw failure || new MacroBlind('no-matching-rule');
+    if (failure) site.nestedBlind.push({ macro: resolved.defs[0].name, reason: `alternative:${failure.reason}` });
+    if (outputs.length === 1) return outputs[0];
+    if (context !== 'expr') return outputs.flat();
+    const arms = [];
+    outputs.forEach((tokens, i) => {
+        if (i > 0) arms.push({ k: 'punct', v: ',', src: 'tpl' });
+        arms.push(i === outputs.length - 1 ? { k: 'ident', v: '_', src: 'tpl' } : { k: 'lit', v: String(i), src: 'tpl' },
+            { k: 'punct', v: '=>', src: 'tpl' }, ...wrapExpression(tokens));
+    });
+    return [{ k: 'group', v: '(', d: '(', src: 'tpl', synthetic: true, c: [
+        { k: 'ident', v: 'match', src: 'tpl' }, { k: 'lit', v: '0', src: 'tpl' },
+        { k: 'group', v: '{', d: '{', src: 'tpl', synthetic: true, c: arms },
+    ] }];
+}
+
+function cloneTree(tokens) {
+    return tokens.map(tok => (tok.k === 'group' ? { ...tok, c: cloneTree(tok.c) } : { ...tok }));
+}
+
+/**
+ * An expansion used as an expression: a block holding a single expression
+ * (`{{ Command::new() }}`) is that expression; anything that is not one
+ * postfix operand keeps its precedence in parentheses, statements in a block.
+ */
+function wrapExpression(input) {
+    let tokens = input;
+    while (tokens.length === 1 && tokens[0].k === 'group' && tokens[0].d === '{' &&
+        tokens[0].c.length > 0 && !tokens[0].c.some(tok => isTok(tok, ';') || isTok(tok, 'let'))) {
+        tokens = tokens[0].c;
+    }
+    if (tokens.length === 1 && tokens[0].k === 'group') return tokens;
+    if (isPostfixChain(tokens)) return tokens;
+    const hasStatement = tokens.some(tok => isTok(tok, ';'));
+    const d = hasStatement ? '{' : '(';
+    return [{ k: 'group', v: d, d, c: tokens, src: 'tpl', synthetic: true }];
+}
+
+// Hygiene: locals a transcriber introduces (`let x`, closure parameters,
+// `for x in`) live in that expansion step's syntax context and never bind
+// the invocation's tokens of the same spelling (or vice versa).
+const RUST_KEYWORDS = new Set([
+    'as', 'async', 'await', 'break', 'const', 'continue', 'crate', 'dyn', 'else', 'enum', 'extern',
+    'false', 'fn', 'for', 'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub',
+    'ref', 'return', 'self', 'Self', 'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe',
+    'use', 'where', 'while', '_',
+]);
+
+function renameHygienicLocals(tokens) {
+    const binders = new Set();
+    const collect = list => {
+        for (let i = 0; i < list.length; i++) {
+            const tok = list[i];
+            if (tok.k === 'group') {
+                collect(tok.c);
+                if (isTok(list[i - 1], 'let') || (isTok(list[i - 1], 'mut') && isTok(list[i - 2], 'let'))) {
+                    for (const inner of tok.c) {
+                        if (inner.k === 'ident' && inner.src === 'tpl' && !RUST_KEYWORDS.has(inner.v) &&
+                            !/^[A-Z]/.test(inner.v)) {
+                            binders.add(`${inner.ctx}\0${inner.v}`);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (tok.src !== 'tpl' || tok.k !== 'ident' || RUST_KEYWORDS.has(tok.v)) continue;
+            const prev = list[i - 1];
+            const prev2 = list[i - 2];
+            const next = list[i + 1];
+            // `let Some(x)` / `let Point { x, .. }` / `let a::B`: a path,
+            // not a binding (the bindings sit in the pattern's group).
+            const pathHead = (next?.k === 'group' && next.d !== '[') || isTok(next, '::');
+            if (pathHead && (isTok(prev, 'let') || (isTok(prev, 'mut') && isTok(prev2, 'let')))) {
+                for (const inner of next.c || []) {
+                    if (inner.k === 'ident' && inner.src === 'tpl' && !RUST_KEYWORDS.has(inner.v) &&
+                        !/^[A-Z]/.test(inner.v)) binders.add(`${inner.ctx}\0${inner.v}`);
+                }
+                continue;
+            }
+            if (isTok(prev, 'let') || (isTok(prev, 'mut') && isTok(prev2, 'let')) ||
+                (isTok(prev, 'for') && isTok(next, 'in'))) {
+                binders.add(`${tok.ctx}\0${tok.v}`);
+            }
+        }
+        // closure parameters: `|a, mut b: T|`
+        for (let i = 0; i < list.length; i++) {
+            if (!isTok(list[i], '|') || list[i].src !== 'tpl') continue;
+            const prev = list[i - 1];
+            if (prev && prev.k !== 'group' && !['(', ',', '=', 'move', '=>', ';'].includes(prev.v) &&
+                prev.k !== 'punct') continue;
+            let j = i + 1;
+            let expectName = true;
+            while (j < list.length && !isTok(list[j], '|')) {
+                const tok = list[j];
+                if (isTok(tok, ',')) expectName = true;
+                else if (expectName && tok.k === 'ident' && !RUST_KEYWORDS.has(tok.v)) {
+                    if (tok.src === 'tpl') binders.add(`${tok.ctx}\0${tok.v}`);
+                    expectName = false;
+                } else if (!isTok(tok, 'mut') && !isTok(tok, 'ref') && !isTok(tok, '&')) {
+                    expectName = false;
+                }
+                j++;
+            }
+            i = j;
+        }
+    };
+    collect(tokens);
+    if (binders.size === 0) return tokens;
+    const rename = list => {
+        for (let i = 0; i < list.length; i++) {
+            const tok = list[i];
+            if (tok.k === 'group') {
+                rename(tok.c);
+                continue;
+            }
+            if (tok.k !== 'ident' || tok.src !== 'tpl' || RUST_KEYWORDS.has(tok.v) ||
+                !binders.has(`${tok.ctx}\0${tok.v}`)) continue;
+            if (isTok(list[i - 1], '.') || isTok(list[i - 1], '::') ||
+                isTok(list[i + 1], '::') || isTok(list[i + 1], '!')) continue;
+            tok.v = `${tok.v}__ucn_h${tok.ctx}`;
+        }
+    };
+    rename(tokens);
+    return tokens;
+}
+
+// ── Layout ────────────────────────────────────────────────────────────────
+
+const CLOSE = { '(': ')', '[': ']', '{': '}' };
+
+function flatten(tokens, out = []) {
+    for (const tok of tokens) {
+        if (tok.k === 'group') {
+            out.push({ v: tok.d, src: tok.src, line: tok.line, col: tok.col, s: tok.s, e: tok.s !== undefined ? tok.s + 1 : undefined });
+            flatten(tok.c, out);
+            const close = tok.closeOrigin;
+            out.push(close && tok.src === 'arg'
+                ? { v: CLOSE[tok.d], src: 'arg', line: close.line, col: close.col, s: close.s, e: close.e, closer: true }
+                : { v: CLOSE[tok.d], src: 'tpl', closer: true });
+        } else {
+            out.push(tok);
+        }
+    }
+    return out;
+}
+
+const MULTI_PUNCT = ['::', '->', '=>', '==', '!=', '<=', '>=', '&&', '||', '+=', '-=', '*=', '/=',
+    '%=', '^=', '&=', '|=', '<<', '>>', '..', '//', '/*', '*/'];
+// The two-character joints that start a multi-character punctuation token
+// (a one-character joint, from an empty leaf, starts any that begins with it).
+const MULTI_PUNCT_JOINTS = new Set(MULTI_PUNCT.flatMap(p => [p.slice(0, 2), p[0]]));
+const SPACE_AFTER = new Set([',', ';', ':', '=>', '->', '=', '+', '|', '&&', '||', '==', '!=']);
+const SPACE_BEFORE = new Set(['=>', '->', '=', '+', '{', '==', '!=', '&&', '||']);
+// ASCII letters, digits, '_', quotes (and '#' at a word's end): a leaf that
+// ends / starts with one lexes into its neighbor without a space.
+function isWordCode(code) {
+    return (code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) ||
+        code === 95 || code === 39 || code === 34;
+}
+const isWordEnd = leaf => {
+    const v = typeof leaf.v === 'string' ? leaf.v : String(leaf.v);
+    if (v.length === 0) return false;
+    const code = v.charCodeAt(v.length - 1);
+    return isWordCode(code) || code === 35;
+};
+const isWordStart = leaf => {
+    const v = typeof leaf.v === 'string' ? leaf.v : String(leaf.v);
+    return v.length > 0 && isWordCode(v.charCodeAt(0));
+};
+
+/**
+ * Whether two adjacent leaves need a space: when they would lex as one
+ * token, plus conventional spacing so text-derived facts (parameter lists,
+ * generics, paths) read like source.
+ */
+function needsSpace(prev, leaf) {
+    if (!prev) return false;
+    const wordEnd = isWordEnd(prev);
+    const wordStart = isWordStart(leaf);
+    if (wordEnd && wordStart) return true;
+    const a = prev.v;
+    const b = leaf.v;
+    if (b === '.') {
+        const first = String(a).charCodeAt(0);
+        if (first >= 48 && first <= 57) return true;
+    }
+    if (!wordEnd && !wordStart) {
+        const joint = a.slice(-1) + b[0];
+        if (MULTI_PUNCT_JOINTS.has(joint) && !(a === '::' || b === '::')) return true;
+    }
+    if (a === ':' && b === ':') return true;
+    if (SPACE_AFTER.has(a) && a !== '::') return !(a === '|' && prev.closer);
+    if ((a === '>' || a === '}') && wordStart) return true;
+    if (SPACE_BEFORE.has(b)) return true;
+    return false;
+}
+
+/**
+ * Text of an expansion laid out on the invocation's lines [startLine,
+ * endLine]: argument tokens move to their own line when it is ahead, leading
+ * template tokens join the next argument token's line, nothing ever passes
+ * endLine. Returns { text, marks: [{s, e, leaf}] } (offsets relative).
+ */
+function layout(tokens, startLine, startCol, endLine) {
+    const leaves = flatten(tokens);
+    const nextArgLine = new Array(leaves.length + 1).fill(0);
+    for (let i = leaves.length - 1; i >= 0; i--) {
+        nextArgLine[i] = leaves[i].src === 'arg' ? leaves[i].line : nextArgLine[i + 1];
+    }
+    let line = startLine;
+    let col = startCol;
+    let text = '';
+    const marks = [];
+    let first = true;
+    for (let i = 0; i < leaves.length; i++) {
+        const leaf = leaves[i];
+        let target = 0;
+        if (leaf.src === 'arg' && leaf.line > line) target = leaf.line;
+        else if (leaf.src !== 'arg' && !leaf.closer && nextArgLine[i + 1] > line) target = nextArgLine[i + 1];
+        if (target > line && target <= endLine) {
+            text += '\n'.repeat(target - line);
+            line = target;
+            col = 0;
+            if (leaf.src === 'arg' && leaf.col > col) {
+                text += ' '.repeat(leaf.col);
+                col = leaf.col;
+            }
+        } else if (!first && needsSpace(leaves[i - 1], leaf)) {
+            text += ' ';
+            col++;
+        }
+        first = false;
+        let value = leaf.v;
+        if (value.includes('\n')) {
+            const breaks = value.split('\n').length - 1;
+            if (leaf.src === 'arg' && line + breaks <= endLine) {
+                line += breaks;
+                col = value.length - value.lastIndexOf('\n') - 1;
+            } else {
+                value = /^b?r?#*"|^b?"/.test(value) ? '""' : ' ';
+                col += value.length;
+            }
+        } else {
+            col += value.length;
+        }
+        marks.push({ s: text.length, e: text.length + value.length, leaf, line });
+        text += value;
+    }
+    if (line < endLine) text += '\n'.repeat(endLine - line);
+    return { text, marks };
+}
+
+// ── Per-file expansion ────────────────────────────────────────────────────
+
+function collectErrorRanges(node, out) {
+    if (node.type === 'ERROR' || node.isMissing) {
+        out.push([node.startIndex, node.endIndex]);
+        return out;
+    }
+    if (!node.hasError) return out;
+    for (let i = 0; i < node.childCount; i++) collectErrorRanges(node.child(i), out);
+    return out;
+}
+
+/**
+ * The expanded file as analyzed: only the kept ranges (units holding an
+ * invocation and their ancestors' headers) are text; everything else is
+ * blanked with its line breaks kept, so every line keeps its number and the
+ * parser only walks what it must re-derive. Expansions replace their
+ * invocation's span.
+ */
+function buildSynthetic(content, regions, keep) {
+    let text = '';
+    let cursor = 0;
+    const spans = []; // synthetic [start, end) of text that is not blank
+    const blank = (from, to) => content.slice(from, to).replace(/[^\r\n]/g, ' ');
+    const addSpan = (start, end) => {
+        if (end <= start) return;
+        const last = spans[spans.length - 1];
+        if (last && last[1] >= start) last[1] = Math.max(last[1], end);
+        else spans.push([start, end]);
+    };
+    const copy = (from, to) => {
+        // Kept ranges are sorted and disjoint.
+        let at = from;
+        for (const [start, end] of keep) {
+            if (end <= at) continue;
+            if (start >= to) break;
+            if (start > at) text += blank(at, start);
+            const stop = Math.min(end, to);
+            const synthStart = text.length;
+            text += content.slice(Math.max(start, at), stop);
+            addSpan(synthStart, text.length);
+            at = stop;
+        }
+        if (at < to) text += blank(at, to);
+    };
+    for (const region of regions) {
+        copy(cursor, region.start);
+        region.synthStart = text.length;
+        text += region.layout.text;
+        region.synthEnd = text.length;
+        // A stand-in for an expansion another group reads keeps its length.
+        if (!region.blank) addSpan(region.synthStart, region.synthEnd);
+        cursor = region.end;
+    }
+    copy(cursor, content.length);
+    return { text, spans };
+}
+
+/**
+ * Parse only the non-blank spans of the synthetic file (tree-sitter
+ * included ranges): positions stay absolute, blank text costs nothing. The
+ * tree lands in safeParse's cache, so the adapter's analysis reuses it.
+ */
+function parseSynthetic(parser, text, spans) {
+    const starts = [0];
+    for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1)) starts.push(i + 1);
+    const position = offset => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= offset) lo = mid; else hi = mid - 1;
+        }
+        return { row: lo, column: offset - starts[lo] };
+    };
+    const includedRanges = spans.map(([start, end]) => ({
+        startIndex: start, endIndex: end, startPosition: position(start), endPosition: position(end),
+    }));
+    if (includedRanges.length === 0) return safeParse(parser, text, undefined, PARSE_OPTIONS);
+    return safeParse(parser, text, undefined, { ...PARSE_OPTIONS, includedRanges });
+}
+
+const UNIT_TYPES = new Set(['function_item', 'const_item', 'static_item']);
+const HEADER_TYPES = new Set(['function_item', 'impl_item', 'trait_item', 'mod_item', 'foreign_mod_item']);
+
+/** The node plus its preceding attributes and comments. */
+function withLeadingTrivia(node) {
+    let start = node.startIndex;
+    let startRow = node.startPosition.row;
+    for (let sibling = node.previousSibling; sibling; sibling = sibling.previousSibling) {
+        if (sibling.type !== 'attribute_item' && sibling.type !== 'line_comment' &&
+            sibling.type !== 'block_comment') break;
+        start = sibling.startIndex;
+        startRow = sibling.startPosition.row;
+    }
+    return { start, startLine: startRow + 1 };
+}
+
+/**
+ * Units re-derived from the expanded file: the innermost function (or
+ * const/static item) holding each invocation, else the item-position
+ * invocation itself, with leading attributes; plus, kept as text, the
+ * headers and associated types of every enclosing impl/trait/mod/fn so the
+ * unit parses in its real context (Self type, trait, enclosing fn).
+ */
+function analysisUnits(regions, mode = 'calls') {
+    const units = [];
+    const keep = [];
+    const headers = new Set();
+    const keepHeader = parent => {
+        if (headers.has(parent.startIndex)) return;
+        headers.add(parent.startIndex);
+        const body = parent.childForFieldName('body');
+        if (!body) return;
+        keep.push([parent.startIndex, body.startIndex + 1], [body.endIndex - 1, body.endIndex]);
+        // Associated types of an enclosing impl/trait.
+        if (parent.type === 'impl_item' || parent.type === 'trait_item') {
+            for (const member of body.namedChildren) {
+                if (member.type === 'type_item' || member.type === 'associated_type') {
+                    keep.push([member.startIndex, member.endIndex]);
+                }
+            }
+        }
+        const { start: headStart } = withLeadingTrivia(parent);
+        if (headStart < parent.startIndex) keep.push([headStart, parent.startIndex]);
+    };
+    for (const region of regions) {
+        let unitNode = null;
+        for (let parent = region.node.parent; parent; parent = parent.parent) {
+            if (UNIT_TYPES.has(parent.type)) { unitNode = parent; break; }
+        }
+        let start;
+        let startLine;
+        let end;
+        let endLine;
+        if (unitNode) {
+            ({ start, startLine } = withLeadingTrivia(unitNode));
+            end = unitNode.endIndex;
+            endLine = unitNode.endPosition.row + 1;
+        } else {
+            ({ start, startLine } = withLeadingTrivia(region.node));
+            const next = region.node.nextSibling;
+            const last = next && next.type === ';' ? next : region.node;
+            end = last.endIndex;
+            endLine = last.endPosition.row + 1;
+        }
+        units.push({ start, end, startLine, endLine });
+        if (mode === 'symbols' && unitNode) {
+            // Declarations need only the invocation in its enclosing
+            // function's frame, not the rest of the body.
+            if (unitNode.type === 'function_item') keepHeader(unitNode);
+            else keep.push([start, end]);
+            const next = region.node.nextSibling;
+            keep.push([region.start, next && next.type === ';' ? next.endIndex : region.end]);
+        } else {
+            keep.push([start, end]);
+        }
+        for (let parent = (unitNode || region.node).parent; parent; parent = parent.parent) {
+            if (HEADER_TYPES.has(parent.type)) keepHeader(parent);
+        }
+    }
+    const merge = ranges => {
+        ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+        const out = [];
+        for (const range of ranges) {
+            const last = out[out.length - 1];
+            if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1]);
+            else out.push([...range]);
+        }
+        return out;
+    };
+    units.sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const unit of units) {
+        const last = merged[merged.length - 1];
+        if (last && unit.start <= last.end) {
+            if (unit.end > last.end) { last.end = unit.end; last.endLine = unit.endLine; }
+        } else merged.push({ ...unit });
+    }
+    return { units: merged, keep: merge(keep) };
+}
+
+function regionAt(regions, synth) {
+    let lo = 0;
+    let hi = regions.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const region = regions[mid];
+        if (synth < region.synthStart) hi = mid - 1;
+        else if (synth >= region.synthEnd) lo = mid + 1;
+        else return region;
+    }
+    return null;
+}
+
+/**
+ * Mark of the leaf at relative offset `rel`: the leaf containing it, else
+ * (whitespace) the next leaf for a start offset, the previous for an end.
+ */
+function markAt(marks, rel, forEnd) {
+    const probe = forEnd ? rel - 1 : rel;
+    let lo = 0;
+    let hi = marks.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const mark = marks[mid];
+        if (probe < mark.s) hi = mid - 1;
+        else if (probe >= mark.e) lo = mid + 1;
+        else return mark;
+    }
+    // lo = first mark starting after probe, hi = last mark ending before it
+    return forEnd ? (marks[hi] || marks[lo] || null) : (marks[lo] || marks[hi] || null);
+}
+
+/** Maps synthetic offsets back to the source file. */
+function offsetMapper(regions) {
+    // Length change accumulated after each region.
+    let delta = 0;
+    for (const region of regions) {
+        delta += (region.synthEnd - region.synthStart) - (region.end - region.start);
+        region.deltaAfter = delta;
+    }
+    const map = (synth, forEnd) => {
+        const region = regionAt(regions, forEnd ? synth - 1 : synth);
+        if (!region) {
+            // Copied text: shift by every region before it.
+            let lo = 0;
+            let hi = regions.length - 1;
+            let before = null;
+            while (lo <= hi) {
+                const mid = (lo + hi) >> 1;
+                if (regions[mid].synthEnd <= synth) { before = regions[mid]; lo = mid + 1; } else hi = mid - 1;
+            }
+            return synth - (before ? before.deltaAfter : 0);
+        }
+        const rel = synth - region.synthStart;
+        const mark = markAt(region.layout.marks, rel, forEnd);
+        if (mark && mark.leaf.src === 'arg' && Number.isInteger(mark.leaf.s)) {
+            return mark.leaf.s + Math.min(Math.max(rel - mark.s, 0), mark.e - mark.s);
+        }
+        return fraction(region, synth);
+    };
+    // Template text has no source offset: a stable fraction inside the
+    // invocation's first byte keeps order and receiver links.
+    const fraction = (region, synth) =>
+        region.start + (synth - region.synthStart + 1) / (region.synthEnd - region.synthStart + 2);
+    const templateOffset = synth => {
+        const region = regionAt(regions, synth) || regionAt(regions, synth - 1);
+        return region ? fraction(region, Math.min(synth, region.synthEnd)) : map(synth, false);
+    };
+    return { map, templateOffset, regionAt: synth => regionAt(regions, synth) };
+}
+
+const OFFSET_FIELD = /(?:Start|End|^start|^end)$/;
+
+/**
+ * Remap every `<x>Start`/`<x>End` offset field. A span keeps source offsets
+ * only when both ends were written in the source (outside expansions, or
+ * both inside argument tokens); otherwise both ends take the invocation's
+ * fractional template offsets, so a span never inverts.
+ */
+function remapOffsets(record, mapper, depth = 0) {
+    const pairs = new Map();
+    for (const key of Object.keys(record)) {
+        const value = record[key];
+        if (value && typeof value === 'object' && depth < 4) {
+            // Nested evidence (receiverTypeEvidence, origins) carries offsets too.
+            if (Array.isArray(value)) {
+                record[key] = value.map(item => {
+                    if (!item || typeof item !== 'object') return item;
+                    const copy = { ...item };
+                    remapOffsets(copy, mapper, depth + 1);
+                    return copy;
+                });
+            } else {
+                const copy = { ...value };
+                remapOffsets(copy, mapper, depth + 1);
+                record[key] = copy;
+            }
+            continue;
+        }
+        if (typeof value !== 'number' || !OFFSET_FIELD.test(key)) continue;
+        const stem = key.replace(OFFSET_FIELD, '');
+        if (!pairs.has(stem)) pairs.set(stem, {});
+        pairs.get(stem)[/end$/i.test(key) ? 'end' : 'start'] = key;
+    }
+    for (const { start, end } of pairs.values()) {
+        const mappedStart = start ? mapper.map(record[start], false) : null;
+        const mappedEnd = end ? mapper.map(record[end], true) : null;
+        const mixed = start && end &&
+            (Number.isInteger(mappedStart) !== Number.isInteger(mappedEnd) || mappedEnd < mappedStart);
+        if (mixed) {
+            record[start] = mapper.templateOffset(record[start]);
+            record[end] = mapper.templateOffset(record[end]);
+            continue;
+        }
+        if (start) record[start] = mappedStart;
+        if (end) record[end] = mappedEnd;
+    }
+}
+
+const DECLARATION_TYPES = [
+    'function_item', 'function_signature_item', 'impl_item', 'struct_item', 'enum_item', 'union_item',
+    'trait_item', 'mod_item', 'type_item', 'const_item', 'static_item', 'macro_definition',
+    'field_declaration', 'enum_variant', 'associated_type',
+];
+
+const DECLARATION_TYPE_SET = new Set(DECLARATION_TYPES);
+let declarationWalkTypes = null;
+function declarationWalkTypesOf() {
+    return declarationWalkTypes || (declarationWalkTypes =
+        [...new Set([...DECLARATION_TYPES, ...require('../languages/rust').DECLARATION_NODE_TYPES])]);
+}
+
+/**
+ * (startLine\0name) keys of declarations whose name was produced inside a
+ * region. `within`: the roots spanning the regions and their walked
+ * descendants, when every such declaration lies inside one (else the whole
+ * tree is searched).
+ */
+function generatedDeclarations(root, regions, within = null) {
+    const out = new Map();
+    if (regions.length === 0) return out;
+    const nodes = within
+        ? within.roots.flatMap((spanning, i) => [
+            ...(DECLARATION_TYPE_SET.has(spanning.type) ? [spanning] : []),
+            ...within.walked[i].filter(node => DECLARATION_TYPE_SET.has(node.type)),
+        ])
+        : root.descendantsOfType(DECLARATION_TYPES);
+    for (const node of nodes) {
+        const nameNode = node.type === 'impl_item' ? node.childForFieldName('type')
+            : node.childForFieldName('name');
+        if (!nameNode) continue;
+        const region = regionAt(regions, nameNode.startIndex);
+        if (!region || nameNode.endIndex > region.synthEnd) continue;
+        const mark = markAt(region.layout.marks, nameNode.startIndex - region.synthStart, false);
+        const origin = mark?.leaf.src === 'arg' ? 'argument' : 'template';
+        const text = node.type === 'impl_item' ? typeNameOf(nameNode) : nameNode.text;
+        out.set(`${node.startPosition.row + 1}\0${text}`, {
+            region, origin,
+            ...(origin === 'argument' && { nameLine: mark.leaf.line }),
+        });
+    }
+    return out;
+}
+
+function typeNameOf(node) {
+    if (node.type === 'generic_type') return typeNameOf(node.childForFieldName('type'));
+    if (node.type === 'scoped_type_identifier') return node.childForFieldName('name')?.text || node.text;
+    if (node.type === 'reference_type') return typeNameOf(node.childForFieldName('type'));
+    return node.text;
+}
+
+function macroFact(region, origin) {
+    return {
+        macro: region.macro,
+        definition: region.definition,
+        origin,
+        line: region.startLine,
+        ...(region.ambiguous && { ambiguous: true }),
+    };
+}
+
+/**
+ * The invocations of a file the expansion pass reads, in document order:
+ * project macros in scope that are worth expanding. Invocations without a
+ * context or token tree are recorded blind in `rec`.
+ */
+function plannedInvocations(state, filePath, content, tree, rec, invocations = null) {
+    const plan = [];
+    for (const node of invocations || tree.rootNode.descendantsOfType('macro_invocation')) {
+        const id = invocationName(node);
+        if (!id || !state.inventory.has(id.name)) continue;
+        let inDefinition = false;
+        for (let parent = node.parent; parent; parent = parent.parent) {
+            if (parent.type === 'macro_definition') { inDefinition = true; break; }
+        }
+        if (inDefinition) continue;
+        const line = node.startPosition.row + 1;
+        const resolved = resolveMacro(state, filePath, node.startIndex, line, id.name, id.qualifier, null);
+        if (!resolved) continue;
+        const def = resolved.defs[0];
+        const info = compiledDef(state, def);
+        const context = invocationContext(node);
+        if (!worthExpanding(state, resolved.defs, content.slice(node.startIndex, node.endIndex),
+            context === 'expr')) continue;
+        const tokenTree = node.namedChildren.find(child => child.type === 'token_tree');
+        if (info.compiled?.passThroughItems && context === 'items' && itemRecoveryPosition(node)) continue;
+        if (!context) { rec.blind.push({ line, macro: id.name, reason: 'context' }); continue; }
+        if (!tokenTree) { rec.blind.push({ line, macro: id.name, reason: 'token-error' }); continue; }
+        plan.push({ node, id, resolved, def, context, tokenTree, line });
+    }
+    return plan;
+}
+
+/** Expand one planned invocation: its region, or null (recorded blind). */
+function expandPlanned(state, filePath, content, item, rec) {
+    const { node, id, resolved, def, context, tokenTree, line } = item;
+    const site = {
+        file: filePath, offset: node.startIndex, line, budget: MAX_OUTPUT_TOKENS,
+        used: rec.used, nestedBlind: [], ambiguous: resolved.ambiguous,
+    };
+    let tokens;
+    try {
+        lineOffset(state, filePath, 1);
+        const toks = argTokensOf(tokenTree, content, state.lineStarts.get(filePath));
+        tokens = resolved.alternatives
+            ? expandAlternatives(state, site, resolved, toks, 0, context)
+            : expandTokens(state, site, def, toks, 0);
+    } catch (error) {
+        if (!(error instanceof MacroBlind)) throw error;
+        rec.blind.push({ line, macro: id.name, reason: error.reason });
+        return null;
+    }
+    for (const nested of site.nestedBlind) rec.blind.push({ line, macro: nested.macro, reason: `nested:${nested.reason}` });
+    renameHygienicLocals(tokens);
+    let body = tokens;
+    if (context === 'expr') body = wrapExpression(tokens);
+    const startLine = line;
+    const endLine = node.endPosition.row + 1;
+    const ancestors = new Set();
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        const nameNode = parent.type === 'impl_item' ? parent.childForFieldName('type')
+            : DECLARATION_TYPES.includes(parent.type) ? parent.childForFieldName('name') : null;
+        if (nameNode) {
+            ancestors.add(`${parent.startPosition.row + 1}\0${parent.type === 'impl_item' ? typeNameOf(nameNode) : nameNode.text}`);
+        }
+    }
+    return {
+        start: node.startIndex, end: node.endIndex, startLine, endLine,
+        macro: id.name, definition: defKey(def), ambiguous: site.ambiguous, ancestors,
+        node, layout: layout(body, startLine, node.startPosition.column, endLine),
+    };
+}
+
+/**
+ * Expand the project macro invocations of one file. Returns the expansion
+ * record, or null when the file invokes no project macro in scope.
+ */
+function expandFile(state, filePath, mode = 'symbols') {
+    // Hygiene contexts are numbered per file, so an expansion's renamed
+    // locals do not depend on what else this state expanded before.
+    state.hygieneSeq = 0;
+    const index = state.index;
+    const fileEntry = index.files.get(filePath);
+    const content = readContent(state, filePath);
+    if (!fileEntry || content === null) return null;
+    if (!fileMayExpand(state, filePath)) return { sites: 0, blind: [], used: new Map(), expanded: false };
+    const tree = safeParse(state.parser, content, undefined, PARSE_OPTIONS);
+    const rec = { sites: 0, blind: [], used: new Map(), expanded: false };
+    const regions = [];
+    // Each expansion's hygiene start and expanded length (fix #405): the
+    // calls pass expands one group of units with the same numbering and
+    // the same offsets as a pass over the whole file.
+    const expansions = mode === 'symbols' ? [] : null;
+    // The symbols pass also needs the file's literals and comments: one
+    // walk lists both (fix #405b).
+    const clean = !tree.rootNode.hasError;
+    const walked = mode === 'symbols' && clean
+        ? tree.rootNode.descendantsOfType(['macro_invocation', ...NON_CODE_TOKENS]) : null;
+    const invocations = walked ? walked.filter(node => node.type === 'macro_invocation') : null;
+    const nonCode = walked ? walked.filter(node => node.type !== 'macro_invocation') : [];
+    for (const item of plannedInvocations(state, filePath, content, tree, rec, invocations)) {
+        const hygiene = state.hygieneSeq;
+        const region = expandPlanned(state, filePath, content, item, rec);
+        if (expansions) expansions.push(item.node.startIndex, hygiene, region ? region.layout.text.length : -1);
+        if (region) regions.push(region);
+    }
+    rec.sites = regions.length;
+    if (regions.length === 0) return rec;
+    regions.sort((a, b) => a.start - b.start);
+    // The identifiers each expansion outputs.
+    const outputs = mode === 'symbols' ? regions.map(outputWordsOf) : null;
+    // Every word the expanded text of the calls pass can hold (fix #375).
+    const words = mode === 'symbols' ? expansionWords(content, regions, nonCode, outputs) : null;
+    // What each group of units can bear, read before parsing it (fix #405b).
+    const groups = mode === 'symbols' && !tree.rootNode.hasError
+        ? groupRecords(content, regions, nonCode, outputs) : null;
+
+    // Parse the expanded file; an expansion that does not parse in its
+    // context stays as written (blind), and the rest are parsed again.
+    let synthetic;
+    let synthTree;
+    let units;
+    for (let attempt = 0; attempt <= regions.length && regions.length > 0; attempt++) {
+        const scope = analysisUnits(regions, mode);
+        units = scope.units;
+        const built = buildSynthetic(content, regions, scope.keep);
+        synthetic = built.text;
+        synthTree = parseSynthetic(state.parser, synthetic, built.spans);
+        const errors = collectErrorRanges(synthTree.rootNode, []);
+        const bad = new Set();
+        for (const [start, end] of errors) {
+            for (const region of regions) {
+                if (start < region.synthEnd && end > region.synthStart) bad.add(region);
+                else if (start === end && start >= region.synthStart && start <= region.synthEnd) bad.add(region);
+            }
+        }
+        if (bad.size === 0) break;
+        for (const region of bad) {
+            rec.blind.push({ line: region.startLine, macro: region.macro, reason: 'parse-error' });
+            regions.splice(regions.indexOf(region), 1);
+        }
+    }
+    rec.sites = regions.length;
+    if (regions.length === 0) return rec;
+
+    const rust = require('../languages/rust');
+    const mapper = offsetMapper(regions);
+    const lookups = unitLookups(units);
+    rec.expanded = true;
+
+    if (mode === 'symbols') {
+        // The expanded file holds no unexpanded item bodies worth recovering
+        // inside its units; the extractors share the included-ranges tree.
+        rust.primeDeclarationTrees(synthetic, state.parser, synthTree);
+        // Declarations of the regions only: the smallest nodes spanning each.
+        const spanning = regions.map(region => (region.synthEnd > region.synthStart
+            ? synthTree.rootNode.descendantForIndex(region.synthStart, region.synthEnd - 1) : null))
+            .filter(Boolean).sort((a, b) => a.startIndex - b.startIndex || b.endIndex - a.endIndex);
+        const roots = [];
+        for (const node of spanning) {
+            const last = roots[roots.length - 1];
+            if (last && node.startIndex >= last.startIndex && node.endIndex <= last.endIndex) continue;
+            roots.push(node);
+        }
+        // One walk of each root serves both extractions (fix #405b). In a
+        // file that parses cleanly an expansion stands as whole items,
+        // statements or a wrapped expression, so a declaration named inside
+        // it lies inside the root spanning it; otherwise the whole tree is
+        // searched.
+        const walked = roots.map(root => root.descendantsOfType(declarationWalkTypesOf()));
+        rec.symbols = generatedSymbols(filePath, rust.parseDeclarationsIn(synthetic, roots, {
+            descendants: (root, i) => walked[i],
+        }), {
+            regions, mapper, generated: generatedDeclarations(synthTree.rootNode, regions,
+                tree.rootNode.hasError ? null : { roots, walked }),
+        });
+        rec.calleeNames = callableNames(regions);
+        rec.expansions = expansions;
+        // Groups as the calls pass reads them apart: only when no expansion
+        // was left blind by a parse error (the pass then reads the file in
+        // one pass, whose groups can differ).
+        rec.words = words;
+        if (groups && !rec.blind.some(site => site.reason === 'parse-error')) rec.groups = groups;
+        rec.callsPending = true;
+        return rec;
+    }
+
+    // Calls: records of the units from the expanded file, the rest as parsed,
+    // plus the invocations themselves (a derivation context, fix #405).
+    rec.context = callsContext(state, filePath, {
+        content, tree, regions, units, synthetic, synthTree, mapper, lookups,
+    });
+    return rec;
+}
+
+/** Binary-search lookups over sorted, disjoint units. */
+function unitLookups(units) {
+    const unitAtOffset = offset => {
+        let lo = 0;
+        let hi = units.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (offset < units[mid].start) hi = mid - 1;
+            else if (offset >= units[mid].end) lo = mid + 1;
+            else return units[mid];
+        }
+        return null;
+    };
+    const unitAtLine = line => byLine(units, line);
+    const inUnit = record => (Number.isFinite(record.callStart) ? !!unitAtOffset(record.callStart)
+        : !!unitAtLine(record.line));
+    return { unitAtOffset, unitAtLine, inUnit };
+}
+
+function byLine(list, line) {
+    let lo = 0;
+    let hi = list.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (line < list[mid].startLine) hi = mid - 1;
+        else if (line > list[mid].endLine) lo = mid + 1;
+        else return list[mid];
+    }
+    return null;
+}
+
+// ── Calls pass (fix #405) ─────────────────────────────────────────────────
+//
+// The calls of an expanded file are the parsed records outside its units,
+// the records each unit yields in the expanded file, and the invocations
+// themselves. Units sharing a line form one group (records without a span
+// are placed by line). The extractor keeps no scope across functions, so a
+// group's records do not depend on the other groups: a query that needs
+// the records bearing one name, or those of a line range, reads only the
+// groups that can hold them, and the file's calls are composed, as one pass
+// derives them, when a consumer needs them all. Where the build recorded
+// every expansion's hygiene start and expanded length, a group expands and
+// parses alone with the numbering and the offsets of the whole file;
+// otherwise the file's expansions parse in one pass and each group's
+// records are read from that tree with the other units skipped.
+
+/**
+ * Everything the calls pass of a file shares: its regions, units and their
+ * groups, the expanded file and its tree. Per-group records are added as
+ * groups are read.
+ */
+function callsContext(state, filePath, parts) {
+    const { content, tree, regions, units, synthetic, synthTree, mapper, lookups } = parts;
+    const index = state.index;
+    // Units sharing a line form one group.
+    const groups = groupsOf(units);
+    // Unit spans in the expanded file: a unit starts and ends outside every
+    // region, shifted by the regions before it.
+    const toSynth = offset => {
+        let lo = 0;
+        let hi = regions.length - 1;
+        let before = null;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (regions[mid].end <= offset) { before = regions[mid]; lo = mid + 1; } else hi = mid - 1;
+        }
+        return offset + (before ? before.deltaAfter : 0);
+    };
+    for (const unit of units) {
+        unit.synthStart = toSynth(unit.start);
+        unit.synthEnd = toSynth(unit.end);
+    }
+    const cached = index.callsCache.get(filePath);
+    const original = cached?.calls || [];
+    // Records without a source span (struct-literal constructors) are placed
+    // by line: one the unexpanded parse also has on that line is ordinary
+    // code, any other one on an invocation's lines was generated.
+    const originalSpanless = new Map();
+    for (const record of original) {
+        if (Number.isFinite(record.callStart) || !lookups.unitAtLine(record.line)) continue;
+        const key = spanlessKey(record);
+        originalSpanless.set(key, (originalSpanless.get(key) || 0) + 1);
+    }
+    const rust = require('../languages/rust');
+    return {
+        filePath, content, tree, regions, units, groups, synthetic, synthTree, mapper, lookups,
+        original, originalSpanless, seen: new Set(),
+        itemRecovery: rust.rustExpandedItemRecovery(synthetic, state.parser, synthTree),
+        // An expanded file whose parse holds an error is read in one pass.
+        groupwise: !synthTree.rootNode.hasError,
+        invocations: new Map(),
+        parser: state.parser,
+        live: true,
+    };
+}
+
+function spanlessKey(record) {
+    return `${record.name}\0${record.line}\0${record.isConstructor ? 1 : 0}`;
+}
+
+/** Read the records of the groups `wanted` (indices) not read yet. */
+function readGroups(ctx, wanted) {
+    let targets = wanted.filter(i => ctx.groups[i].records === null);
+    if (targets.length === 0) return;
+    if (ctx.isolated) {
+        readIsolatedGroups(ctx, targets);
+        ctx.readLookups = null;
+        return;
+    }
+    if (!ctx.groupwise) targets = ctx.groups.map((group, i) => i).filter(i => ctx.groups[i].records === null);
+    const target = new Set(targets);
+    const all = target.size === ctx.groups.filter(group => group.records === null).length &&
+        ctx.groups.every(group => group.records === null);
+    const units = ctx.units;
+    // Nodes inside a unit of another group are not read.
+    const skip = all ? null : node => {
+        const start = node.startIndex;
+        let lo = 0;
+        let hi = units.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const unit = units[mid];
+            if (start < unit.synthStart) hi = mid - 1;
+            else if (start >= unit.synthEnd) lo = mid + 1;
+            else return node.endIndex <= unit.synthEnd && !target.has(unit.group);
+        }
+        return false;
+    };
+    for (const i of targets) ctx.groups[i].records = [];
+    const rust = require('../languages/rust');
+    const synthCalls = rust.findCallsInCode(ctx.synthetic, ctx.parser, {
+        tree: ctx.synthTree, itemRecovery: ctx.itemRecovery, skip,
+    });
+    mergeRecords(ctx, synthCalls, {
+        mapper: ctx.mapper, lookups: ctx.lookups, regions: ctx.regions, synthTree: ctx.synthTree,
+        originalSpanless: ctx.originalSpanless,
+        accept: unit => target.has(unit.group), push: (unit, call) => ctx.groups[unit.group].records.push(call),
+    });
+}
+
+/**
+ * The records an expanded file's parse yields for the accepted units, with
+ * source offsets, expansion facts, and repeats dropped (`ctx.seen`).
+ */
+function mergeRecords(ctx, synthCalls, { mapper, lookups, regions, synthTree, originalSpanless, accept, push }) {
+    const regionOnLine = line => byLine(regions, line);
+    for (const record of synthCalls) {
+        const synthStart = record.callStart;
+        let unit;
+        if (Number.isFinite(synthStart)) {
+            const mapped = mapper.map(synthStart, false);
+            unit = lookups.unitAtOffset(Math.floor(mapped));
+        } else unit = lookups.unitAtLine(record.line);
+        if (!unit || !accept(unit)) continue;
+        const call = { ...record };
+        let region = Number.isFinite(synthStart) ? mapper.regionAt(synthStart) : null;
+        if (!Number.isFinite(synthStart) && regionOnLine(record.line)) {
+            const key = spanlessKey(record);
+            const left = originalSpanless.get(key) || 0;
+            if (left > 0) originalSpanless.set(key, left - 1);
+            else region = regionOnLine(record.line);
+        }
+        remapOffsets(call, mapper);
+        if (region) {
+            // Origin of the NAME token: `v.iter().collect()` written with a
+            // receiver from the arguments still calls a template `collect`.
+            const nameMark = Number.isFinite(synthStart) ? nameMarkOf(synthTree.rootNode, region, record)
+                : region.layout.marks.find(mark => mark.leaf.v === record.name && mark.leaf.src === 'arg' &&
+                    mark.line === record.line) || null;
+            const origin = nameMark?.leaf.src === 'arg' ? 'argument' : 'template';
+            // An argument token the layout could not keep on its own line
+            // (repeated or reordered by the transcriber) reports its own.
+            if (origin === 'argument' && nameMark.line !== nameMark.leaf.line) call.line = nameMark.leaf.line;
+            call.macroExpansion = macroFact(region, origin);
+            // Repeated argument tokens are one call; template calls at one
+            // line are told apart only by what the engine can see of them
+            // (a transcriber repetition emits the same call per iteration).
+            const key = origin === 'argument'
+                ? `a\0${call.name}\0${call.line}\0${call.callStart}\0${call.callEnd}\0${call.receiver || ''}`
+                : `t\0${call.name}\0${call.line}\0${call.isMethod ? 1 : 0}\0${call.receiver || ''}\0` +
+                    `${call.receiverType || ''}\0${call.receiverRootType || ''}\0${call.receiverField || ''}\0` +
+                    `${call.enclosingFunction?.name || ''}\0${call.argCount ?? ''}`;
+            if (ctx.seen.has(key)) continue;
+            ctx.seen.add(key);
+        }
+        push(unit, call);
+    }
+}
+
+/**
+ * The invocations stay calls of their macros; the value one produces is the
+ * expansion's, so its own value-flow facts are dropped. Built once per
+ * context (the same records in every view and in the composed calls).
+ */
+function invocationRecords(ctx) {
+    // Expanded invocations: every region (one pass), the regions of the
+    // groups read so far (groups read apart).
+    const starts = new Set();
+    if (ctx.isolated) {
+        for (const group of ctx.groups) for (const start of group.starts || []) starts.add(start);
+    } else {
+        for (const region of ctx.regions) starts.add(region.start);
+    }
+    const out = [];
+    for (const record of ctx.original) {
+        if (!record.isMacro || !starts.has(record.callStart)) continue;
+        let invocation = ctx.invocations.get(record);
+        if (!invocation) {
+            invocation = {
+                name: record.name, line: record.line, callStart: record.callStart, callEnd: record.callEnd,
+                isMethod: false, isMacro: true,
+                ...(record.receiver && { receiver: record.receiver, isPathMacro: true }),
+                ...(record.macroExpr && { macroExpr: true }),
+                enclosingFunction: record.enclosingFunction,
+                macroExpanded: true,
+            };
+            ctx.invocations.set(record, invocation);
+        }
+        out.push(invocation);
+    }
+    return out;
+}
+
+/** Whether a parsed record lies in a unit of a group read so far (all units, one pass). */
+function inReadUnit(ctx, record) {
+    if (!ctx.isolated) return ctx.lookups.inUnit(record);
+    if (!ctx.readLookups) {
+        const units = [];
+        for (const group of ctx.groups) if (group.units) units.push(...group.units);
+        units.sort((a, b) => a.start - b.start);
+        ctx.readLookups = unitLookups(units);
+    }
+    return ctx.readLookups.inUnit(record);
+}
+
+/**
+ * The calls of the file: parsed records outside the units, each group's
+ * records, the invocations; stable by line. Installed in the calls cache
+ * with the facts the file entry derives from them.
+ */
+function composeCalls(index, ctx) {
+    readGroups(ctx, ctx.groups.map((group, i) => i));
+    const fileEntry = index.files.get(ctx.filePath);
+    const calls = ctx.original.filter(record => !inReadUnit(ctx, record));
+    for (const group of ctx.groups) for (const record of group.records) calls.push(record);
+    for (const record of invocationRecords(ctx)) calls.push(record);
+    // Shapes of generated calls whose value may be lost (audit-async).
+    const { openCallShape } = require('../languages/rust-value-flow');
+    const shapes = calls.filter(call => call.macroExpansion && call.name && !call.inMacro && !call.valueConsumed)
+        .map(openCallShape);
+    if (shapes.length > 0) {
+        fileEntry.openCalls = [...new Set([...(fileEntry.openCalls || []), ...shapes])].sort(codeUnitCompare);
+    }
+    // Stable by line: records keep document order within a line.
+    calls.sort((a, b) => a.line - b.line);
+    const cached = index.callsCache.get(ctx.filePath);
+    if (cached) {
+        if (index.calleeIndex) index._removeFromCalleeIndex(ctx.filePath, ctx.original);
+        cached.calls = calls;
+        if (index.calleeIndex) index._addToCalleeIndex(ctx.filePath, calls);
+    } else {
+        index.callsCache.set(ctx.filePath, { mtime: fileEntry.mtime, hash: fileEntry.hash, calls });
+    }
+    index.callsCacheDirty = true;
+    return calls;
+}
+
+const CALL_NODES = new Set(['call_expression', 'macro_invocation', 'struct_expression', 'generic_function']);
+
+/** Layout mark of the name token of a call record inside a region. */
+function nameMarkOf(root, region, record) {
+    const start = record.callStart;
+    const end = record.callEnd;
+    let node = Number.isFinite(start) && Number.isFinite(end) && end > start
+        ? root.descendantForIndex(start, end - 1) : null;
+    while (node && !(CALL_NODES.has(node.type) && node.startIndex === start && node.endIndex === end)) {
+        node = node.parent;
+    }
+    let nameNode = null;
+    if (node?.type === 'macro_invocation') {
+        nameNode = node.childForFieldName('macro');
+    } else if (node) {
+        let fn = node.childForFieldName('function') || node.childForFieldName('name');
+        if (fn?.type === 'generic_function') fn = fn.childForFieldName('function');
+        if (fn?.type === 'field_expression') nameNode = fn.childForFieldName('field');
+        else if (fn?.type === 'scoped_identifier' || fn?.type === 'scoped_type_identifier') nameNode = fn.childForFieldName('name');
+        else nameNode = fn;
+    }
+    if (nameNode && nameNode.startIndex >= region.synthStart && nameNode.endIndex <= region.synthEnd) {
+        const rel = nameNode.type === 'scoped_identifier' || nameNode.type === 'macro_invocation'
+            ? nameNode.endIndex - 1 - region.synthStart : nameNode.startIndex - region.synthStart;
+        return markAt(region.layout.marks, rel, false);
+    }
+    // No node at that span: the first leaf spelling the name.
+    const marks = region.layout.marks;
+    return marks.find(mark => mark.leaf.v === record.name &&
+        mark.s >= start - region.synthStart && mark.e <= end - region.synthStart) || null;
+}
+
+/**
+ * The declarations the expansions generate (IR items carrying
+ * `macroExpansion`), and the invocation spans whose recovered declarations
+ * they replace. Pure: computed in a build worker or in place.
+ */
+function generatedSymbols(filePath, parsed, { regions, mapper, generated }) {
+    const { createFileIR } = require('./ir');
+    const ir = createFileIR({ language: 'rust', file: filePath, parsed, calls: [] });
+    const symbols = [];
+    const seen = new Set();
+    let ordinal = 0;
+    for (const item of ir.symbols) {
+        const origin = generated.get(`${item.startLine}\0${item.name}`);
+        if (!origin) continue;
+        // Declarations a repetition generates identically at one line.
+        const key = `${item.kind}\0${item.name}\0${item.owner || ''}\0${item.startLine}\0${item.traitName || ''}\0` +
+            `${item.params || ''}\0${item.returnType || ''}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const symbol = { ...item };
+        remapOffsets(symbol, mapper);
+        symbol.macroExpansion = macroFact(origin.region, origin.origin);
+        if (origin.nameLine && origin.nameLine !== symbol.startLine) symbol.nameLine = origin.nameLine;
+        symbol.id = `macro:${symbol.startLine}:${symbol.kind}:${symbol.owner || ''}:${symbol.name}:${ordinal++}`;
+        symbols.push(symbol);
+    }
+    return {
+        symbols,
+        spans: regions.map(region => ({
+            startLine: region.startLine, endLine: region.endLine, ancestors: [...region.ancestors],
+        })),
+    };
+}
+
+/** Apply generatedSymbols() to the index (main thread). */
+function applyGeneratedSymbols(index, filePath, result) {
+    const fileEntry = index.files.get(filePath);
+    if (!fileEntry || !result) return;
+    for (const symbol of fileEntry.symbols) {
+        const entries = index.symbols.get(symbol.name);
+        if (!entries) continue;
+        const kept = entries.filter(entry => entry.file !== filePath);
+        if (kept.length > 0) index.symbols.set(symbol.name, kept);
+        else index.symbols.delete(symbol.name);
+    }
+    const previous = fileEntry.symbols;
+    fileEntry.symbols = [];
+    fileEntry.bindings = [];
+    // An invocation's token trees held only what the parser recovered from
+    // them (item bodies): those give way to what the expansion declares.
+    // The declarations enclosing an invocation stay.
+    const spans = result.spans.map(span => ({ ...span, ancestors: new Set(span.ancestors) }));
+    const insideSpan = symbol => spans.some(span => symbol.startLine >= span.startLine &&
+        symbol.endLine <= span.endLine && !span.ancestors.has(`${symbol.startLine}\0${symbol.name}`));
+    for (const symbol of previous) {
+        if (insideSpan(symbol)) continue;
+        fileEntry.symbols.push(symbol);
+        if (!index.symbols.has(symbol.name)) index.symbols.set(symbol.name, []);
+        index.symbols.get(symbol.name).push(symbol);
+        if (symbol.memberAssigned || symbol.bodyScopedName || symbol.exportedAlias || symbol.type === 'impl') continue;
+        fileEntry.bindings.push({
+            id: symbol.bindingId, name: symbol.name, type: symbol.type, startLine: symbol.startLine,
+        });
+    }
+    for (const item of result.symbols) {
+        const symbol = addIRSymbol(fileEntry, item, index.symbols);
+        // A generated trait impl for a type declared in this file joins the
+        // type's `implements` (the parser does this for impls it sees).
+        if (symbol.type !== 'impl' || !symbol.traitName) continue;
+        const owner = fileEntry.symbols.find(candidate => (candidate.type === 'struct' || candidate.type === 'enum') &&
+            candidate.name === symbol.name && !candidate.macroExpansion);
+        if (owner && !(owner.implements || []).includes(symbol.traitName)) {
+            owner.implements = [...(owner.implements || []), symbol.traitName];
+        }
+    }
+}
+
+/**
+ * Names the calls of the expansions can bear (callee position, method,
+ * macro, struct literal): the callee index lists the file under them until
+ * its calls are expanded.
+ */
+function callableNames(regions) {
+    const names = new Set();
+    for (const region of regions) {
+        const marks = region.layout.marks;
+        for (let i = 0; i < marks.length - 1; i++) {
+            const next = marks[i + 1].leaf.v;
+            if (!(next === '(' || next === '!' || next === '{' ||
+                (next === '::' && marks[i + 2]?.leaf.v === '<'))) continue;
+            const leaf = marks[i].leaf;
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(leaf.v) || RUST_KEYWORDS.has(leaf.v)) continue;
+            names.add(leaf.v);
+        }
+    }
+    return [...names].sort(codeUnitCompare);
+}
+
+const WORD = /[\p{L}\p{N}_]+/gu;
+const WHOLE_WORD = /^[\p{L}\p{N}_]+$/u;
+
+// Tokens whose text is never an identifier: literals and comments.
+const NON_CODE_TOKENS = ['string_literal', 'raw_string_literal', 'char_literal', 'line_comment', 'block_comment'];
+
+/**
+ * The words (identifier-like runs) of the text the calls pass analyzes for
+ * these regions: the kept source around them (units and their headers) and
+ * every expansion's tokens. A call record derived from that text can bear no
+ * other name, so a file whose calls are not derived yet needs deriving only
+ * for a name among them (fix #375). A record's name and written receiver are
+ * identifier tokens, so the text of literals and comments is left out (fix
+ * #405: `"--count"` and `// the count` made a `count` query derive four
+ * test files); kept ranges are whole items and headers, which the calls
+ * pass lexes as the file's own parse did. A file with parse errors is read
+ * whole. Space-separated, sorted.
+ */
+function expansionWords(content, regions, nonCode = [], outputs = regions.map(outputWordsOf)) {
+    const words = new Set();
+    scanCodeWords(content, analysisUnits(regions, 'calls').keep, nonCode, words);
+    for (const output of outputs) for (const word of output) words.add(word);
+    return [...words].sort(codeUnitCompare).join(' ');
+}
+
+/** Words of `ranges` (sorted, disjoint) of the source, literals and comments (`nonCode`, sorted) left out. */
+function scanCodeWords(content, ranges, nonCode, words) {
+    const scan = (start, end) => {
+        if (end <= start) return;
+        for (const word of content.slice(start, end).match(WORD) || []) words.add(word);
+    };
+    let next = 0;
+    for (const [start, end] of ranges) {
+        let at = start;
+        while (next < nonCode.length && nonCode[next].endIndex <= at) next++;
+        for (let i = next; i < nonCode.length; i++) {
+            const token = nonCode[i];
+            if (token.startIndex >= end) break;
+            scan(at, Math.min(token.startIndex, end));
+            at = Math.max(at, token.endIndex);
+        }
+        scan(at, end);
+    }
+}
+
+/** The identifier tokens an expansion outputs (a non-ASCII identifier is a 'punct' leaf), once each. */
+function outputWordsOf(region) {
+    const words = new Set();
+    for (const mark of region.layout.marks) {
+        const leaf = mark.leaf;
+        if (leaf.k === 'ident' || (leaf.k === 'punct' && WHOLE_WORD.test(leaf.v))) words.add(leaf.v);
+    }
+    return [...words];
+}
+
+/**
+ * The groups of units the calls pass reads apart (fix #405b), each as
+ * [startLine, endLine, expanded length, words]: the identifiers its
+ * expansions output (with those of any expansion in its kept headers) and
+ * the code of its kept headers outside its units (`Self { .. }` names the
+ * impl's type). A record a group derives in the units' own code is written
+ * there, as the file's parsed record on that line is: the calls pass
+ * consults those for the rest (rustPendingRecords). Expanded length: the
+ * text the group's own expansions add, for the cost of reading it.
+ */
+function groupRecords(content, regions, nonCode, outputs) {
+    const { units } = analysisUnits(regions, 'calls');
+    const groups = groupsOf(units);
+    const lookups = unitLookups(units);
+    const members = groups.map(() => []);
+    const groupOf = regions.map((region, i) => {
+        const group = lookups.unitAtOffset(region.start).group;
+        members[group].push(i);
+        return group;
+    });
+    // Expansions are disjoint and sorted: the first one ending after `at`.
+    const firstEndingAfter = at => {
+        let lo = 0;
+        let hi = regions.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (regions[mid].end <= at) lo = mid + 1; else hi = mid;
+        }
+        return lo;
+    };
+    return groups.map((group, gi) => {
+        const keep = analysisUnits(members[gi].map(i => regions[i]), 'calls').keep;
+        const words = new Set();
+        let length = 0;
+        for (const i of members[gi]) {
+            length += regions[i].layout.text.length;
+            for (const word of outputs[i]) words.add(word);
+        }
+        // Expansions inside its kept headers (`impl T for m!() {..}`).
+        for (const [start, end] of keep) {
+            for (let i = firstEndingAfter(start); i < regions.length && regions[i].start < end; i++) {
+                if (groupOf[i] !== gi) for (const word of outputs[i]) words.add(word);
+            }
+        }
+        // Header code: the kept ranges outside the group's units.
+        const headers = [];
+        for (const [start, end] of keep) {
+            let at = start;
+            for (const unit of group.units) {
+                if (unit.end <= at || unit.start >= end) continue;
+                if (unit.start > at) headers.push([at, unit.start]);
+                at = Math.max(at, unit.end);
+            }
+            if (at < end) headers.push([at, end]);
+        }
+        scanCodeWords(content, headers, nonCode, words);
+        // Insertion order is the expansions' and the text's: deterministic.
+        return [group.startLine, group.endLine, length, [...words].join(' ')];
+    });
+}
+
+/** Whether the derived calls of a file pending derivation can bear `name`. */
+const pendingWordSets = new WeakMap();
+function rustPendingMayBear(fileEntry, name) {
+    const rec = fileEntry?.rustMacroExpansion;
+    if (!rec?.callsPending) return false;
+    if (typeof rec.words !== 'string') return true;
+    let words = pendingWordSets.get(rec);
+    if (!words) pendingWordSets.set(rec, words = new Set(rec.words.split(' ')));
+    return hasWord(words, name);
+}
+
+/**
+ * Whether a recorded group's word list (space-separated) holds `name`, as
+ * hasWord does for a set (fix #405b: one name is asked per group, so the
+ * list is searched rather than split).
+ */
+function groupHasWord(list, name) {
+    const text = String(name);
+    const bare = text.replace(/^r#/, '');
+    return listHasWord(list, text) || (bare !== text && listHasWord(list, bare)) || listHasWord(list, `r#${text}`);
+}
+
+function listHasWord(list, word) {
+    if (!word) return false;
+    for (let at = list.indexOf(word); at >= 0; at = list.indexOf(word, at + 1)) {
+        const end = at + word.length;
+        if ((at === 0 || list.charCodeAt(at - 1) === 32) && (end === list.length || list.charCodeAt(end) === 32)) return true;
+    }
+    return false;
+}
+
+const pendingFileLists = new WeakMap(); // operation content cache -> pending file paths
+
+/**
+ * Files whose macro expansions' calls are not derived yet and whose
+ * expanded text can hold one of `names` (fix #405). The callee index lists
+ * such a file under its parsed records' names and its expansions'
+ * callee-position names, but a derived record can bear any word of the
+ * expanded text (`self.view` passed as a value, `Self { .. }` named by its
+ * impl): a query visits these files too, so the files it reads do not
+ * depend on which files earlier queries derived.
+ */
+function rustPendingFilesBearing(index, names) {
+    const scope = index._opContentCache;
+    let files = scope ? pendingFileLists.get(scope) : undefined;
+    if (!files) {
+        files = [];
+        for (const [filePath, fileEntry] of index.files) {
+            if (fileEntry.rustMacroExpansion?.callsPending) files.push(filePath);
+        }
+        if (scope) pendingFileLists.set(scope, files);
+    }
+    const bearing = [];
+    for (const filePath of files) {
+        const fileEntry = index.files.get(filePath);
+        if (names.some(name => rustPendingMayBear(fileEntry, name))) bearing.push(filePath);
+    }
+    return bearing;
+}
+
+function tokenText(tokens) {
+    return flatten(tokens).map(leaf => leaf.v).join(' ');
+}
+
+// ── Build pass ────────────────────────────────────────────────────────────
+
+/** Project macro names a file's call records invoke. */
+function invokedMacroNames(index, filePath, inventory) {
+    const calls = index.callsCache.get(filePath)?.calls;
+    if (!Array.isArray(calls)) return [];
+    const names = new Set();
+    for (const call of calls) {
+        if (call.isMacro && !call.macroExpansion && inventory.has(call.name)) names.add(call.name);
+    }
+    return [...names].sort(codeUnitCompare);
+}
+
+function signatureFor(state, filePath, names) {
+    const index = state.index;
+    const hash = crypto.createHash('md5');
+    hash.update(index.files.get(filePath)?.hash || '');
+    for (const name of names) {
+        for (const def of state.inventory.get(name) || []) {
+            const entry = index.files.get(def.file);
+            hash.update(`\n${name}\0${def.relativePath}\0${def.startLine}\0${def.endLine}\0${entry?.hash || ''}`);
+        }
+    }
+    // Module ancestry decides textual scope; crate roots decide path scope.
+    const parents = moduleParents(state);
+    let current = filePath;
+    const seen = new Set();
+    while (parents.has(current) && !seen.has(current)) {
+        seen.add(current);
+        const link = parents.get(current);
+        current = link.file;
+        hash.update(`\n^${path.relative(index.root, current)}\0${link.line}\0${link.macroUse ? 1 : 0}\0` +
+            `${index.files.get(current)?.hash || ''}`);
+    }
+    return hash.digest('hex');
+}
+
+/**
+ * Build-time pass, phase 1 (before the import graph): Rust files whose
+ * persisted expansion is missing or stale. An expanded file is re-parsed
+ * (`reindex`) so phase 2 starts from its parser facts.
+ */
+function planRustMacroExpansion(index, { reindex = null, files = null } = {}) {
+    const rustFiles = [];
+    for (const [file, entry] of index.files) {
+        if (isRust(entry) && (!files || files.includes(file))) rustFiles.push(file);
+    }
+    if (rustFiles.length === 0) return [];
+    const state = createState(index);
+    const pending = [];
+    for (const file of rustFiles) {
+        const entry = index.files.get(file);
+        const rec = entry.rustMacroExpansion;
+        const names = state.inventory.size > 0 ? invokedMacroNames(index, file, state.inventory) : [];
+        if (names.length === 0 && !rec) continue;
+        if (rec && names.length > 0 && names.join(',') === (rec.callNames || []).join(',') &&
+            signatureFor(state, file, mergedNames(names, rec.nested)) === rec.signature) continue;
+        pending.push(file);
+    }
+    for (const file of pending) {
+        const rec = index.files.get(file)?.rustMacroExpansion;
+        if (rec?.expanded && reindex) reindex(file);
+        const entry = index.files.get(file);
+        if (entry) delete entry.rustMacroExpansion;
+    }
+    return pending;
+}
+
+function mergedNames(names, nested) {
+    return [...new Set([...names, ...(nested || [])])].sort(codeUnitCompare);
+}
+
+/** Planned files that invoke a project macro (from their call records). */
+function invokingFiles(index, pending, inventory, names) {
+    return pending.filter(file => {
+        if (!index.files.has(file)) return false;
+        const invoked = invokedMacroNames(index, file, inventory);
+        names.set(file, invoked);
+        return invoked.length > 0;
+    });
+}
+
+/**
+ * Build-time pass, phase 2a (fix #375): start expanding the planned files in
+ * worker threads while the caller builds the import graph. The workers
+ * resolve module ancestry from the `mod` declarations alone (the only import
+ * facts expansion reads), so their records equal an in-place expansion after
+ * the graph. Returns a handle for applyRustMacroExpansion (null when there is
+ * nothing to expand; `results` null when the files expand in place).
+ */
+function startRustMacroExpansion(index, pending, options = {}) {
+    if (!pending || pending.length === 0) return null;
+    const inventory = macroInventory(index);
+    if (inventory.size === 0) return { inventory, files: [], results: null };
+    const names = new Map();
+    const files = invokingFiles(index, pending, inventory, names);
+    let bytes = 0;
+    for (const file of files) bytes += index.files.get(file)?.size || 0;
+    const run = files.length >= PARALLEL_MIN_FILES && bytes >= PARALLEL_MIN_BYTES
+        ? startWorkers(index, files, { ...options, inventory }) : null;
+    return { inventory, files, names, results: run };
+}
+
+/**
+ * Build-time pass, phase 2b (after the import graph resolved `mod`
+ * declarations): apply the expansions of the planned files, expanding in
+ * place what no worker returned. Returns false when nothing expanded, else
+ * { files, names }: the files whose symbols were replaced and the symbol
+ * names involved.
+ */
+function applyRustMacroExpansion(index, pending, options = {}, started = undefined) {
+    const run = started === undefined ? startRustMacroExpansion(index, pending, options) : started;
+    if (!run) return false;
+    let results;
+    try {
+        results = run.results ? run.results.collect() : null;
+    } finally {
+        run.results?.dispose();
+    }
+    if (run.files.length === 0) return false;
+    const state = createState(index, run.inventory);
+    // What the expansions changed: the files whose symbols were replaced and
+    // the symbol names involved (the caller re-canonicalizes only those).
+    let touched = null;
+    for (const file of run.files) {
+        const entry = index.files.get(file);
+        // Symbols-mode expansion never changes call records.
+        const callNames = run.names?.get(file) || invokedMacroNames(index, file, state.inventory);
+        let rec = results?.get(file);
+        if (!rec) {
+            rec = expandFile(state, file) || { sites: 0, blind: [], used: new Map(), expanded: false };
+            rec = { ...rec, usedNames: [...rec.used.values()].map(def => def.name) };
+        }
+        if (rec.symbols) {
+            touched ||= { files: new Set(), names: new Set() };
+            touched.files.add(file);
+            for (const symbol of entry.symbols) touched.names.add(symbol.name);
+            applyGeneratedSymbols(index, file, rec.symbols);
+            for (const symbol of entry.symbols) touched.names.add(symbol.name);
+        }
+        if (rec.expanded && !touched) touched = { files: new Set(), names: new Set() };
+        const nested = [...new Set(rec.usedNames || [])]
+            .filter(name => !callNames.includes(name)).sort(codeUnitCompare);
+        entry.rustMacroExpansion = {
+            signature: signatureFor(state, file, mergedNames(callNames, nested)),
+            callNames,
+            ...(nested.length > 0 && { nested }),
+            sites: rec.sites,
+            ...(rec.blind.length > 0 && { blind: rec.blind.sort((a, b) => a.line - b.line ||
+                codeUnitCompare(a.macro, b.macro) || codeUnitCompare(a.reason, b.reason)) }),
+            ...(rec.expanded && { expanded: true }),
+            ...(rec.callsPending && {
+                callsPending: true, calleeNames: rec.calleeNames || [], words: rec.words, expansions: rec.expansions,
+                ...(rec.groups && { groups: rec.groups }),
+            }),
+        };
+    }
+    return touched || false;
+}
+
+// Parse workers kept for expansion pay for themselves from a few files of
+// expansion work; the job is posted while the import graph builds.
+const PARALLEL_MIN_FILES = 2;
+const PARALLEL_MIN_BYTES = 32 * 1024;
+// Parse workers a parallel build keeps for expansion (fix #388). Their parser
+// code is already optimized, so a few of them finish the largest invoking
+// files about as fast as more fresh threads would, at a fraction of the CPU
+// (measured on ripgrep, tokio, rayon, axum, hyper, cargo, clap).
+const EXPANSION_WORKERS = 3;
+
+/**
+ * What a worker needs to expand `workload` without the index: the module
+ * tree (every Rust file's `mod` declarations, resolved, and module symbols),
+ * the macro definitions (their text is read from disk), and for the files
+ * to expand their import facts, impl/trait spans and macro invocation
+ * records. Also every name a project callable bears.
+ */
+function workerSnapshot(index, workload, inventory) {
+    const expanding = new Set(workload);
+    // Invocations resolve at the invoking file, and nested ones also at the
+    // defining file.
+    const resolving = new Set(workload);
+    for (const defs of inventory.values()) for (const def of defs) resolving.add(def.file);
+    const files = [];
+    const macros = [];
+    for (const [file, entry] of index.files) {
+        if (!isRust(entry)) continue;
+        const full = expanding.has(file);
+        const resolves = resolving.has(file);
+        // Module ancestry reads `mod` declarations (and the module symbols'
+        // attributes); resolution at a file also reads its glob imports and
+        // the `use` bindings that can name a macro; expansion reads the
+        // invoking file's impl/trait spans and project macro invocations.
+        const record = {
+            path: file, relativePath: entry.relativePath, language: 'rust',
+            importDetails: (entry.importDetails || []).filter(detail => detail.type === 'mod' ||
+                (resolves && detail.type === 'use-glob')),
+            symbols: (entry.symbols || []).filter(symbol => symbol.type === 'module' ||
+                (full && (symbol.type === 'impl' || symbol.type === 'trait')))
+                .map(symbol => ({
+                    name: symbol.name, type: symbol.type, startLine: symbol.startLine, endLine: symbol.endLine,
+                    modifiers: symbol.modifiers || [],
+                })),
+        };
+        if (resolves) {
+            record.importBindings = (entry.importBindings || [])
+                .filter(binding => inventory.has(binding.alias || binding.name));
+        }
+        if (full) {
+            record.calls = (index.callsCache.get(file)?.calls || [])
+                .filter(call => call.isMacro && !call.macroExpansion && inventory.has(call.name))
+                .map(call => ({
+                    name: call.name, line: call.line, callStart: call.callStart, callEnd: call.callEnd,
+                    isMacro: true,
+                    ...(call.inMacro && { inMacro: true }),
+                    ...(call.macroExpr && { macroExpr: true }),
+                    ...(call.isPathMacro && { isPathMacro: true, receiver: call.receiver }),
+                    ...(call.enclosingFunction && { enclosingFunction: { name: call.enclosingFunction.name } }),
+                }));
+        }
+        files.push(record);
+        for (const symbol of entry.symbols || []) {
+            if (symbol.type === 'macro') {
+                macros.push({ name: symbol.name, type: 'macro', file, relativePath: symbol.relativePath,
+                    startLine: symbol.startLine, endLine: symbol.endLine, modifiers: symbol.modifiers || [],
+                    ...(symbol.macroScope && { macroScope: symbol.macroScope }) });
+            }
+        }
+    }
+    // Callee-position macros expand where an argument word names a project
+    // callable: the workers see every such name.
+    const callable = [];
+    for (const [name, defs] of index.symbols) {
+        if (defs.some(def => !NON_CALLABLE_DEF_TYPES.has(def.type))) callable.push(name);
+    }
+    return {
+        root: index.root, files, macros, callableNames: callable,
+        // `mod` declarations resolve in the worker, with this build's view
+        // of the workspace manifests.
+        config: { aliases: index.config?.aliases, includePaths: index.config?.includePaths },
+        cargoManifests: Array.isArray(index.cargoManifests) ? index.cargoManifests : null,
+    };
+}
+
+/** An index-shaped view of a worker snapshot (what createState reads). */
+function snapshotIndex(snapshot) {
+    const { rustModuleDeclarationsResolved, seedWorkspaceManifests } = require('./imports');
+    if (snapshot.cargoManifests) seedWorkspaceManifests(snapshot.root, snapshot.cargoManifests);
+    const files = new Map();
+    const callsCache = new Map();
+    const view = { root: snapshot.root, config: snapshot.config || {}, files };
+    for (const file of snapshot.files) {
+        files.set(file.path, file);
+        if (file.calls) callsCache.set(file.path, { calls: file.calls });
+        let resolved = null;
+        Object.defineProperty(file, 'moduleResolved', {
+            get: () => (resolved ||= rustModuleDeclarationsResolved(view, file.path, file)),
+        });
+    }
+    const symbols = new Map();
+    for (const def of snapshot.macros) {
+        if (!symbols.has(def.name)) symbols.set(def.name, []);
+        symbols.get(def.name).push(def);
+    }
+    let callable = null;
+    return {
+        root: snapshot.root, files, callsCache, symbols,
+        callableNames: {
+            has: word => (callable ||= new Set(snapshot.callableNames || [])).has(word),
+        },
+        _readFile: file => fs.readFileSync(file, 'utf-8'),
+    };
+}
+
+/**
+ * Worker-side: expand the files of a shared queue (`files`, next index at
+ * `signal[queueIndex]`), posting each record to `port`; `signal[workerIndex]`
+ * is set when this worker is done.
+ */
+function runExpansionQueue({ snapshot, files, signal, workerIndex, queueIndex }, port) {
+    const signalArray = new Int32Array(signal);
+    try {
+        const state = createState(snapshotIndex(JSON.parse(Buffer.from(snapshot).toString('utf8'))));
+        for (;;) {
+            const next = Atomics.add(signalArray, queueIndex, 1);
+            if (next >= files.length) break;
+            const file = files[next];
+            let result;
+            try {
+                result = { file, record: expandForWorker(state, file) };
+            } catch (error) {
+                result = { file, error: error.message };
+            }
+            port.postMessage([result]);
+        }
+    } finally {
+        Atomics.store(signalArray, workerIndex, 1);
+        Atomics.notify(signalArray, workerIndex);
+    }
+}
+
+/** Worker-side: symbols-mode expansion of one file, as plain records. */
+function expandForWorker(state, filePath) {
+    const rec = expandFile(state, filePath) || { sites: 0, blind: [], used: new Map(), expanded: false };
+    return {
+        sites: rec.sites, blind: rec.blind, expanded: rec.expanded,
+        usedNames: [...rec.used.values()].map(def => def.name),
+        ...(rec.symbols && { symbols: rec.symbols }),
+        ...(rec.callsPending && {
+            callsPending: true, calleeNames: rec.calleeNames, words: rec.words, expansions: rec.expansions,
+            ...(rec.groups && { groups: rec.groups }),
+        }),
+    };
+}
+
+/**
+ * Start expanding `files` in the parse workers the build kept for it
+ * (largest first from a shared queue). Returns { collect(), dispose() }, or
+ * null without kept workers (a sequential build expands in place, where the
+ * parser is already optimized); collect() blocks until the workers finish
+ * and returns Map<file, record> (files a worker failed on are expanded in
+ * place by the caller).
+ */
+function startWorkers(index, files, options = {}) {
+    const pool = options.pool?.available.length > 0 ? options.pool : null;
+    if (!pool) return null;
+    const { receiveMessageOnPort } = require('worker_threads');
+    const count = Math.min(pool.available.length, EXPANSION_WORKERS, Math.ceil(files.length / 2));
+    if (count < 1) return null;
+    const ordered = [...files].sort((a, b) => (index.files.get(b)?.size || 0) - (index.files.get(a)?.size || 0) ||
+        codeUnitCompare(a, b));
+    // One serialization shared by every worker (a structured clone per
+    // worker cost more than the expansion on large workspaces).
+    const encoded = Buffer.from(JSON.stringify(workerSnapshot(index, files, options.inventory)), 'utf8');
+    const snapshot = new SharedArrayBuffer(encoded.length);
+    encoded.copy(Buffer.from(snapshot));
+    const sab = new SharedArrayBuffer(4 * (count + 1));
+    const signal = new Int32Array(sab);
+    const ports = [];
+    for (let i = 0; i < count; i++) {
+        const worker = pool.available[i];
+        ports.push(pool.ports[worker]);
+        pool.post(worker, { snapshot, files: ordered, signal: sab, workerIndex: i, queueIndex: count });
+    }
+    // Kept workers this job does not need end now.
+    for (const worker of pool.available.slice(count)) pool.retire(worker);
+    // The kept workers belong to the build, which ends them.
+    const dispose = () => {};
+    const collect = () => {
+        const deadline = Date.now() + 300000;
+        let timedOut = false;
+        for (let i = 0; i < count; i++) {
+            while (Atomics.load(signal, i) === 0) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0) { timedOut = true; break; }
+                Atomics.wait(signal, i, 0, Math.min(remaining, 5000));
+            }
+            if (timedOut) break;
+        }
+        const results = new Map();
+        for (const port of ports) {
+            for (let msg = receiveMessageOnPort(port); msg; msg = receiveMessageOnPort(port)) {
+                for (const result of msg.message) {
+                    if (!result.error) results.set(result.file, result.record);
+                }
+            }
+        }
+        return results;
+    };
+    return { collect, dispose, usesPool: true, workerCount: count };
+}
+
+/**
+ * Call records of a Rust file whose expansions' calls are not derived yet
+ * (the build derives generated declarations; calls follow on first use and
+ * are then persisted). `materialize: false` (callee index upkeep) returns the
+ * parsed records plus name-only entries for every name the expansions can
+ * call, without expanding.
+ */
+function rustExpandedCalls(index, filePath, rawCalls, { materialize = true } = {}) {
+    const rec = index.files.get(filePath)?.rustMacroExpansion;
+    if (!rec?.callsPending || !Array.isArray(rawCalls)) return rawCalls;
+    const hints = (rec.calleeNames || []).map(name => ({ name, line: 0, calleeHint: true }));
+    if (!materialize) return hints.length > 0 ? rawCalls.concat(hints) : rawCalls;
+    const ctx = pendingContext(index, filePath, { whole: true });
+    if (index.calleeIndex && hints.length > 0) index._removeFromCalleeIndex(filePath, hints);
+    rec.callsPending = false;
+    try {
+        if (ctx) composeCalls(index, ctx);
+    } catch (error) {
+        rec.callsPending = true;
+        throw error;
+    }
+    index._rustMacroState.contexts.delete(filePath);
+    delete rec.words;
+    delete rec.groups;
+    delete rec.expansions;
+    index.macroExpansionDirty = true;
+    return index.callsCache.get(filePath)?.calls || rawCalls;
+}
+
+// Derivation contexts whose trees are kept (fix #405); a context dropped
+// earlier keeps the records of the groups it read.
+const LIVE_CONTEXTS = 3;
+
+/**
+ * The calls-pass context of a file whose expansion calls are pending, or
+ * null when nothing of it expands (its parsed records stand).
+ */
+function pendingContext(index, filePath, { whole = false } = {}) {
+    if (!index._rustMacroState) index._rustMacroState = createState(index);
+    const state = index._rustMacroState;
+    const contexts = state.contexts;
+    let ctx = contexts.get(filePath);
+    if (ctx === null) return null;
+    if (ctx && ctx.live) {
+        contexts.delete(filePath);
+        contexts.set(filePath, ctx);
+        return ctx;
+    }
+    // A file derived whole before any part of it was read is read in one
+    // pass (fix #405b): the groups apart cost the same expansions and parse
+    // plus a second plan of the file's invocations.
+    const fresh = whole && ctx === undefined
+        ? expandFile(state, filePath, 'calls')?.context || null
+        : buildContext(state, filePath);
+    if (fresh && ctx) {
+        // Rebuilt: the groups the dropped context read keep their records.
+        if (fresh.groups.length !== ctx.groups.length || !!fresh.isolated !== !!ctx.isolated) {
+            throw new Error(`Rust macro expansion context changed: ${filePath}`);
+        }
+        for (let i = 0; i < fresh.groups.length; i++) {
+            const kept = ctx.groups[i];
+            if (!kept.records) continue;
+            Object.assign(fresh.groups[i], { records: kept.records, units: kept.units, starts: kept.starts });
+        }
+        fresh.invocations = ctx.invocations;
+        fresh.seen = ctx.seen;
+    }
+    contexts.delete(filePath);
+    contexts.set(filePath, fresh);
+    if (fresh) {
+        let live = 0;
+        for (const [file, other] of [...contexts].reverse()) {
+            if (!other?.live) continue;
+            if (++live <= LIVE_CONTEXTS || file === filePath) continue;
+            contexts.set(file, releaseContext(other));
+        }
+    }
+    return fresh;
+}
+
+/**
+ * A file's calls-pass context: its groups read apart when the build's
+ * record of its expansions still matches its invocations, else one pass
+ * over the whole file. null when nothing of it expands.
+ */
+function buildContext(state, filePath) {
+    const rec = state.index.files.get(filePath)?.rustMacroExpansion;
+    // Expansions the build could not parse in context are read in one pass
+    // (whose retries can also drop a neighbor).
+    if (Array.isArray(rec?.expansions) && !(rec.blind || []).some(site => site.reason === 'parse-error')) {
+        const isolated = isolatedContext(state, filePath, rec.expansions);
+        if (isolated !== undefined) return isolated;
+    }
+    return expandFile(state, filePath, 'calls')?.context || null;
+}
+
+/** What a dropped context keeps: the records it read. */
+function releaseContext(ctx) {
+    return {
+        isolated: ctx.isolated,
+        groups: ctx.groups.map(group => ({ records: group.records, units: group.units, starts: group.starts })),
+        invocations: ctx.invocations,
+        seen: ctx.seen,
+        live: false,
+    };
+}
+
+/**
+ * A context that reads each group apart (fix #405). The build recorded, for
+ * every invocation it expanded, its hygiene start and its expanded length:
+ * a group expands alone with the numbering and the offsets of a pass over
+ * the whole file, every other expansion standing in as a blank of its
+ * length. undefined when that record no longer matches the file's
+ * invocations or the file has parse errors (one pass reads it), null when
+ * nothing of it expands.
+ */
+function isolatedContext(state, filePath, expansions) {
+    const index = state.index;
+    const content = readContent(state, filePath);
+    if (!index.files.get(filePath) || content === null) return undefined;
+    if (!fileMayExpand(state, filePath)) return null;
+    const tree = safeParse(state.parser, content, undefined, PARSE_OPTIONS);
+    if (tree.rootNode.hasError) return undefined;
+    const plan = plannedInvocations(state, filePath, content, tree, { blind: [] });
+    if (plan.length * 3 !== expansions.length) return undefined;
+    const slots = [];
+    for (let i = 0; i < plan.length; i++) {
+        const item = plan[i];
+        if (item.node.startIndex !== expansions[3 * i]) return undefined;
+        item.hygiene = expansions[3 * i + 1];
+        item.length = expansions[3 * i + 2];
+        if (item.length < 0) continue;
+        slots.push({
+            item, node: item.node, start: item.node.startIndex, end: item.node.endIndex,
+            startLine: item.line, endLine: item.node.endPosition.row + 1,
+        });
+    }
+    if (slots.length === 0) return null;
+    slots.sort((a, b) => a.start - b.start);
+    const { units } = analysisUnits(slots, 'calls');
+    const lookups = unitLookups(units);
+    const groups = groupsOf(units);
+    for (const group of groups) group.slots = [];
+    for (const slot of slots) groups[lookups.unitAtOffset(slot.start).group].slots.push(slot);
+    return {
+        isolated: true, filePath, content, tree, slots, groups,
+        original: index.callsCache.get(filePath)?.calls || [],
+        seen: new Set(), invocations: new Map(), parser: state.parser, state, live: true,
+    };
+}
+
+/** Units sharing a line form one group; units get their group's index. */
+function groupsOf(units) {
+    const groups = [];
+    for (const unit of units) {
+        const last = groups[groups.length - 1];
+        if (last && unit.startLine <= last.endLine) {
+            last.units.push(unit);
+            if (unit.endLine > last.endLine) last.endLine = unit.endLine;
+        } else {
+            groups.push({ units: [unit], startLine: unit.startLine, endLine: unit.endLine, records: null });
+        }
+    }
+    for (let i = 0; i < groups.length; i++) for (const unit of groups[i].units) unit.group = i;
+    return groups;
+}
+
+/**
+ * Read groups of an isolated context. Groups whose expanded text parses
+ * without an error read together as alone (each unit is an item of its
+ * container); otherwise each group is read alone.
+ */
+function readIsolatedGroups(ctx, targets) {
+    if (targets.length === 1) {
+        readIsolatedGroup(ctx, targets[0]);
+        return;
+    }
+    const rec = { blind: [], used: new Map() };
+    const wanted = new Set(targets);
+    const mine = new Set(targets.flatMap(i => ctx.groups[i].slots));
+    const expand = slot => expandSlot(ctx, slot, rec);
+    const live = ctx.slots.filter(slot => mine.has(slot)).map(expand);
+    const keep = analysisUnits(live, 'calls').keep;
+    const extras = ctx.slots.filter(slot => !mine.has(slot) &&
+        keep.some(([start, end]) => slot.start < end && slot.end > start)).map(expand);
+    const expanded = live.concat(extras);
+    const bySlot = new Map(expanded.map(region => [region.slot, region]));
+    const all = ctx.slots.map(slot => bySlot.get(slot) || placeholderOf(ctx, slot));
+    const built = buildSynthetic(ctx.content, all, analysisUnits(expanded, 'calls').keep);
+    const synthTree = parseSynthetic(ctx.parser, built.text, built.spans);
+    if (collectErrorRanges(synthTree.rootNode, []).length > 0) {
+        for (const i of targets) readIsolatedGroup(ctx, i);
+        return;
+    }
+    const units = [];
+    for (const i of targets) {
+        const group = ctx.groups[i];
+        const regions = live.filter(region => region.slot && ctx.groups[i].slots.includes(region.slot));
+        group.units = analysisUnits(regions, 'calls').units;
+        for (const unit of group.units) unit.group = i;
+        group.starts = regions.map(region => region.start);
+        group.records = [];
+        units.push(...group.units);
+    }
+    units.sort((a, b) => a.start - b.start);
+    const lookups = unitLookups(units);
+    const originalSpanless = new Map();
+    for (const record of ctx.original) {
+        if (Number.isFinite(record.callStart) || !lookups.unitAtLine(record.line)) continue;
+        const key = spanlessKey(record);
+        originalSpanless.set(key, (originalSpanless.get(key) || 0) + 1);
+    }
+    const rust = require('../languages/rust');
+    const synthCalls = rust.findCallsInCode(built.text, ctx.parser, {
+        tree: synthTree, itemRecovery: rust.rustExpandedItemRecovery(built.text, ctx.parser, synthTree),
+    });
+    mergeRecords(ctx, synthCalls, {
+        mapper: offsetMapper(all), lookups, regions: live, synthTree, originalSpanless,
+        accept: unit => wanted.has(unit.group), push: (unit, call) => ctx.groups[unit.group].records.push(call),
+    });
+}
+
+/** Expand one invocation of an isolated context as the build did. */
+function expandSlot(ctx, slot, rec) {
+    ctx.state.hygieneSeq = slot.item.hygiene;
+    const region = expandPlanned(ctx.state, ctx.filePath, ctx.content, slot.item, rec);
+    if (!region || region.layout.text.length !== slot.item.length) {
+        throw new Error(`Rust macro expansion at ${ctx.filePath}:${slot.startLine} differs from the build's`);
+    }
+    region.slot = slot;
+    return region;
+}
+
+/** A blank of an expansion's length standing in for it (its newlines kept). */
+function placeholderOf(ctx, slot) {
+    if (!ctx.placeholders) ctx.placeholders = new Map();
+    let region = ctx.placeholders.get(slot);
+    if (!region) {
+        const breaks = slot.endLine - slot.startLine;
+        region = {
+            start: slot.start, end: slot.end, startLine: slot.startLine, endLine: slot.endLine, blank: true,
+            layout: { text: ' '.repeat(slot.item.length - breaks) + '\n'.repeat(breaks), marks: [] },
+        };
+        ctx.placeholders.set(slot, region);
+    }
+    // Its offsets are set by the synthetic it stands in.
+    return { ...region };
+}
+
+/** Read one group of an isolated context: its expansions, parsed alone. */
+function readIsolatedGroup(ctx, gi) {
+    const group = ctx.groups[gi];
+    const rec = { blind: [], used: new Map() };
+    const expand = slot => expandSlot(ctx, slot, rec);
+    const mine = new Set(group.slots);
+    let live = group.slots.map(expand);
+    // Expansions inside the kept headers of this group's units
+    // (`impl T for m!() { .. }`) are part of its text.
+    const headerKeep = analysisUnits(live, 'calls').keep;
+    let extras = ctx.slots.filter(slot => !mine.has(slot) &&
+        headerKeep.some(([start, end]) => slot.start < end && slot.end > start)).map(expand);
+    let synthetic = null;
+    let synthTree = null;
+    let all = null;
+    for (let attempt = 0; live.length > 0 && attempt <= ctx.slots.length; attempt++) {
+        const expanded = live.concat(extras);
+        const bySlot = new Map(expanded.map(region => [region.slot, region]));
+        const dropped = new Set(group.slots.filter(slot => !bySlot.has(slot)));
+        // A dropped expansion stays as written, as in one pass.
+        all = ctx.slots.filter(slot => !dropped.has(slot)).map(slot => bySlot.get(slot) || placeholderOf(ctx, slot));
+        const built = buildSynthetic(ctx.content, all, analysisUnits(expanded, 'calls').keep);
+        synthetic = built.text;
+        synthTree = parseSynthetic(ctx.parser, synthetic, built.spans);
+        const errors = collectErrorRanges(synthTree.rootNode, []);
+        const bad = new Set();
+        for (const [start, end] of errors) {
+            for (const region of expanded) {
+                if (start < region.synthEnd && end > region.synthStart) bad.add(region);
+                else if (start === end && start >= region.synthStart && start <= region.synthEnd) bad.add(region);
+            }
+        }
+        if (bad.size === 0) break;
+        live = live.filter(region => !bad.has(region));
+        extras = extras.filter(region => !bad.has(region));
+    }
+    group.units = live.length > 0 ? analysisUnits(live, 'calls').units : [];
+    group.starts = live.map(region => region.start);
+    group.records = [];
+    if (live.length === 0) return;
+    const lookups = unitLookups(group.units);
+    const mapper = offsetMapper(all);
+    const originalSpanless = new Map();
+    for (const record of ctx.original) {
+        if (Number.isFinite(record.callStart) || !lookups.unitAtLine(record.line)) continue;
+        const key = spanlessKey(record);
+        originalSpanless.set(key, (originalSpanless.get(key) || 0) + 1);
+    }
+    const rust = require('../languages/rust');
+    const synthCalls = rust.findCallsInCode(synthetic, ctx.parser, {
+        tree: synthTree, itemRecovery: rust.rustExpandedItemRecovery(synthetic, ctx.parser, synthTree),
+    });
+    mergeRecords(ctx, synthCalls, {
+        mapper, lookups, regions: live, synthTree, originalSpanless,
+        accept: () => true, push: (unit, call) => group.records.push(call),
+    });
+}
+
+/**
+ * Words the records of an isolated group can bear: its lines and its units'
+ * kept headers in the file (literals and comments left out), the text of
+ * every project macro its expansions can transcribe, and the crate names
+ * `$crate` becomes.
+ */
+function isolatedGroupWords(ctx, group) {
+    if (group.words) return group.words;
+    const state = ctx.state;
+    const words = new Set();
+    const ranges = analysisUnits(group.slots, 'calls').keep.concat([[
+        lineOffset(state, ctx.filePath, group.startLine), lineEndOffset(state, ctx.filePath, group.endLine),
+    ]]).sort((a, b) => a[0] - b[0]);
+    if (!ctx.nonCode) ctx.nonCode = ctx.tree.rootNode.descendantsOfType(NON_CODE_TOKENS);
+    const nonCode = ctx.nonCode;
+    const scan = (start, end) => {
+        if (end <= start) return;
+        for (const word of ctx.content.slice(start, end).match(WORD) || []) words.add(word);
+    };
+    let next = 0;
+    let done = 0;
+    for (const [rangeStart, end] of ranges) {
+        let at = Math.max(rangeStart, done);
+        if (end <= at) continue;
+        while (next < nonCode.length && nonCode[next].endIndex <= at) next++;
+        for (let i = next; i < nonCode.length; i++) {
+            const token = nonCode[i];
+            if (token.startIndex >= end) break;
+            scan(at, Math.min(token.startIndex, end));
+            at = Math.max(at, token.endIndex);
+        }
+        scan(at, end);
+        done = end;
+    }
+    for (const word of [...words]) if (state.inventory.has(word)) addTemplateWords(state, word, words);
+    words.add('crate');
+    group.words = words;
+    return words;
+}
+
+/** Words of every definition of macro `name` and the macros they name, transitively. */
+function addTemplateWords(state, name, words) {
+    if (!state.templateWords) state.templateWords = new Map();
+    let own = state.templateWords.get(name);
+    if (!own) {
+        own = new Set();
+        state.templateWords.set(name, own);
+        const pending = [name];
+        const visited = new Set();
+        while (pending.length > 0) {
+            const next = pending.pop();
+            if (visited.has(next)) continue;
+            visited.add(next);
+            for (const def of state.inventory.get(next) || []) {
+                const content = readContent(state, def.file);
+                if (content === null) continue;
+                const text = content.slice(lineOffset(state, def.file, def.startLine), lineOffset(state, def.file, def.endLine + 1));
+                for (const word of text.match(WORD) || []) {
+                    own.add(word);
+                    if (state.inventory.has(word) && !visited.has(word)) pending.push(word);
+                }
+                const crate = packageOf(state, def.file)?.packageName;
+                if (crate) own.add(crate);
+            }
+        }
+    }
+    for (const word of own) words.add(word);
+}
+
+/**
+ * The records of a file whose expansion calls are pending that a consumer
+ * reading only part of them needs (fix #405), in the order the composed
+ * calls hold them and as the same record objects. `name`: the records
+ * `keep` accepts, each of which must bear the name as one of its own
+ * identifier tokens (its name or written receiver); `lines`: [start, end],
+ * the records on those lines; `lineSet`: the records on any of those lines. Only the groups that can hold such records
+ * are read. undefined when the file's calls are not pending, `name` is not
+ * an identifier, or every group is read (the file's calls are then derived
+ * whole by the caller).
+ */
+const IDENTIFIER = /^(?:r#)?[\p{L}_][\p{L}\p{N}_]*$/u;
+// Tenths of a file's unread expanded text from which a view derives the file
+// whole (fix #405b).
+const WHOLE_FILE_SHARE = 9;
+
+function rustPendingRecords(index, filePath, { name = null, keep = null, lines = null, lineSet = null } = {}) {
+    const entry = index.files.get(filePath);
+    if (!entry?.rustMacroExpansion?.callsPending) return undefined;
+    // Hygiene renames locals a transcriber introduces (`x__ucn_h3`): no
+    // source text holds such a name.
+    if (name !== null && (!IDENTIFIER.test(name) || /__ucn_h\d+$/.test(name))) return undefined;
+    const raw = index.callsCache.get(filePath)?.calls;
+    if (!Array.isArray(raw)) return undefined;
+    const matches = record => (!lines || (record.line >= lines[0] && record.line <= lines[1])) &&
+        (!lineSet || lineSet.has(record.line)) && (!keep || keep(record));
+    // No derived record bears a name outside the file's words (#375): the
+    // parsed records then answer, unless one of them bears it.
+    if (name !== null && !rustPendingMayBear(entry, name) && !raw.some(matches)) return [];
+    // The groups recorded at build (fix #405b) are chosen before anything is
+    // parsed: a group can hold a record `matches` accepts when a word its
+    // expansions output or its headers hold is the name, or when a parsed
+    // record on its lines is accepted (the units' own code is written there).
+    const rec = entry.rustMacroExpansion;
+    const recorded = Array.isArray(rec.groups) ? rec.groups : null;
+    let planned = null;
+    if (recorded) {
+        const read = index._rustMacroState?.contexts?.get(filePath)?.groups || null;
+        const parsedOn = name !== null ? parsedRecordLines(raw, matches) : null;
+        planned = [];
+        let wantedLength = 0;
+        let unreadLength = 0;
+        for (let i = 0; i < recorded.length; i++) {
+            const [startLine, endLine, length] = recorded[i];
+            const unread = !read?.[i]?.records;
+            if (unread) unreadLength += length;
+            if (lines && (endLine < lines[0] || startLine > lines[1])) continue;
+            if (lineSet && ![...lineSet].some(line => line >= startLine && line <= endLine)) continue;
+            if (name !== null && !groupHasWord(recorded[i][3], name) &&
+                !parsedOn.some(line => line >= startLine && line <= endLine)) continue;
+            planned.push(i);
+            if (unread) wantedLength += length;
+        }
+        if (planned.length === 0) {
+            // Every group read: the caller derives the file's calls whole.
+            if (read && read.length > 0 && read.every(group => group.records)) return undefined;
+            // No group can hold one: the accepted records are parsed ones
+            // outside every unit, as the composed calls hold them.
+            return raw.filter(matches).sort((a, b) => a.line - b.line);
+        }
+        // Reading most of the expanded text that is still unread costs more
+        // than deriving the file whole (groups read together cost ~5-10%
+        // over one pass), which then answers every later query of the file:
+        // a cost decision, not a semantic one - either way the records are
+        // the composed calls'.
+        if (wantedLength > 0 && wantedLength * 10 >= unreadLength * WHOLE_FILE_SHARE) return undefined;
+    }
+    const ctx = pendingContext(index, filePath);
+    if (!ctx) return raw.filter(matches);
+    // Every group read: the caller derives the file's calls whole.
+    if (ctx.groups.every(group => group.records)) return undefined;
+    let wanted;
+    if (planned && ctx.groups.length === recorded.length && ctx.groups.every((group, i) =>
+        group.startLine === recorded[i][0] && group.endLine === recorded[i][1])) {
+        wanted = planned;
+    } else {
+        wanted = [];
+        for (let i = 0; i < ctx.groups.length; i++) {
+            const group = ctx.groups[i];
+            if (lines && (group.endLine < lines[0] || group.startLine > lines[1])) continue;
+            if (lineSet && ![...lineSet].some(line => line >= group.startLine && line <= group.endLine)) continue;
+            if (name !== null && !groupMayBear(ctx, group, name)) continue;
+            wanted.push(i);
+        }
+    }
+    readGroups(ctx, wanted);
+    if (ctx.groups.every(group => group.records)) return undefined;
+    const out = ctx.original.filter(record => matches(record) && !inReadUnit(ctx, record));
+    for (const i of wanted) for (const record of ctx.groups[i].records) if (matches(record)) out.push(record);
+    for (const record of invocationRecords(ctx)) if (matches(record)) out.push(record);
+    return out.sort((a, b) => a.line - b.line);
+}
+
+/**
+ * Whether a group's records can bear `name`: a word of the group's lines in
+ * the expanded file or of the kept text outside every unit (headers: a
+ * `Self` record bears its impl's type name).
+ */
+function groupMayBear(ctx, group, name) {
+    if (ctx.isolated) return hasWord(isolatedGroupWords(ctx, group), name);
+    if (!ctx.outsideWords) {
+        const words = new Set();
+        let at = 0;
+        for (const unit of ctx.units) {
+            for (const word of ctx.synthetic.slice(at, unit.synthStart).match(WORD) || []) words.add(word);
+            at = Math.max(at, unit.synthEnd);
+        }
+        for (const word of ctx.synthetic.slice(at).match(WORD) || []) words.add(word);
+        ctx.outsideWords = words;
+    }
+    if (hasWord(ctx.outsideWords, name)) return true;
+    if (!group.words) {
+        if (!ctx.synthLineStarts) {
+            const starts = [0];
+            const text = ctx.synthetic;
+            for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1)) starts.push(i + 1);
+            ctx.synthLineStarts = starts;
+        }
+        const starts = ctx.synthLineStarts;
+        const from = starts[Math.max(group.startLine - 1, 0)] ?? ctx.synthetic.length;
+        const to = starts[group.endLine] ?? ctx.synthetic.length;
+        group.words = new Set(ctx.synthetic.slice(from, to).match(WORD) || []);
+    }
+    return hasWord(group.words, name);
+}
+
+/** Lines of the parsed records `matches` accepts. */
+function parsedRecordLines(raw, matches) {
+    const out = [];
+    for (const record of raw) if (matches(record)) out.push(record.line);
+    return out;
+}
+
+function hasWord(words, name) {
+    // A raw identifier's token is `r#name`; text holds both parts.
+    return words.has(name) || words.has(String(name).replace(/^r#/, '')) || words.has(`r#${name}`);
+}
+
+/**
+ * Relative paths of the files whose expansion calls are pending with no
+ * part derived yet, sorted.
+ */
+function rustUntouchedPendingFiles(index) {
+    const contexts = index._rustMacroState?.contexts;
+    const out = [];
+    for (const [filePath, entry] of index.files) {
+        if (!entry.rustMacroExpansion?.callsPending) continue;
+        if (contexts?.get(filePath)?.groups?.some(group => group.records)) continue;
+        out.push(entry.relativePath);
+    }
+    return out.sort(codeUnitCompare);
+}
+
+/** Derive whole every file whose expansion calls were derived in part. */
+function completeRustMacroCalls(index) {
+    const contexts = index._rustMacroState?.contexts;
+    if (!contexts || contexts.size === 0) return 0;
+    let done = 0;
+    for (const filePath of [...contexts.keys()].sort(codeUnitCompare)) {
+        if (!index.files.get(filePath)?.rustMacroExpansion?.callsPending) continue;
+        const cached = index.callsCache.get(filePath);
+        if (!cached) continue;
+        rustExpandedCalls(index, filePath, cached.calls);
+        done++;
+    }
+    return done;
+}
+
+/** Derive every pending file's expansion calls (whole-program consumers). */
+function materializeRustMacroCalls(index) {
+    for (const [filePath, entry] of index.files) {
+        if (!entry.rustMacroExpansion?.callsPending) continue;
+        const cached = index.callsCache.get(filePath);
+        if (cached) rustExpandedCalls(index, filePath, cached.calls);
+    }
+}
+
+/** Expanded and blind invocation sites, for health and deadcode disclosure. */
+function rustMacroExpansionSummary(index) {
+    const summary = { sites: 0, files: 0, blind: { count: 0, fileCount: 0, files: [], sample: [], reasons: {} } };
+    const files = [...index.files.values()].filter(entry => entry.rustMacroExpansion)
+        .sort((a, b) => codeUnitCompare(a.relativePath, b.relativePath));
+    for (const entry of files) {
+        const rec = entry.rustMacroExpansion;
+        summary.sites += rec.sites || 0;
+        if (rec.expanded) summary.files++;
+        const blind = rec.blind || [];
+        if (blind.length === 0) continue;
+        summary.blind.count += blind.length;
+        summary.blind.fileCount++;
+        if (summary.blind.files.length < 10) summary.blind.files.push(entry.relativePath);
+        for (const site of blind) {
+            const reason = site.reason.startsWith('nested:') ? 'nested' : site.reason;
+            summary.blind.reasons[reason] = (summary.blind.reasons[reason] || 0) + 1;
+            if (summary.blind.sample.length < BLIND_SAMPLE) {
+                summary.blind.sample.push({ file: entry.relativePath, ...site });
+            }
+        }
+    }
+    return summary;
+}
+
+module.exports = {
+    EXPANSION_WORKERS,
+    planRustMacroExpansion,
+    startRustMacroExpansion,
+    // worker-side (core/build-worker.js)
+    runExpansionQueue,
+    applyRustMacroExpansion,
+    rustExpandedCalls,
+    materializeRustMacroCalls,
+    rustMacroExpansionSummary,
+    rustPendingMayBear,
+    rustPendingFilesBearing,
+    rustPendingRecords,
+    completeRustMacroCalls,
+    rustUntouchedPendingFiles,
+};