ucn 5.4.2 → 5.5.0

package/core/verify.js

@@ -7,9 +7,29 @@
 
 const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits } = require('../languages');
 const { sameNode } = require('../languages/utils');
-const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES } = require('./shared');
-const { findAccessorReferences } = require('./accessors');
+const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES, isOverrideMarked, isMacroNamespaceDefinition } = require('./shared');
+const { classDefsNamed, distinctOwnerDefinitions } = require('./class-identity');
+const { isTypeRenamePin } = require('./type-references');
+const { findAccessorReferences, isAccessorDefinition } = require('./accessors');
 const { validateCallMismatch, declarationIdentity } = require('./provenance');
+const { UcnError } = require('./errors');
+const { execFileSync, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * The string index of a token that a parser column points at. The
+ * tree-sitter binding reports columns of string input in UTF-16 code units;
+ * a column that does not spell the token there is read as a UTF-8 byte
+ * column (fix #386: tokens after a non-ASCII character on the same line
+ * were skipped).
+ */
+function tokenColumn(line, column, token) {
+    if (!Number.isInteger(column) || column < 0) return null;
+    if (token && line.slice(column, column + token.length) === token) return column;
+    return codeUnitColumnForByteColumn(line, column);
+}
 
 function codeUnitColumnForByteColumn(line, byteColumn) {
     if (!Number.isInteger(byteColumn) || byteColumn < 0) return null;
@@ -25,6 +45,101 @@ function codeUnitColumnForByteColumn(line, byteColumn) {
     return null;
 }
 
+/**
+ * Choose the declaration's own name token among name-field identifiers on a
+ * definition line (fix #359). Candidates carry `{column, decl}` where decl is
+ * the node whose name/declarator field the identifier is.
+ *   1. The declaration must end where the indexed definition ends (when the
+ *      definition's endLine is known): a multi-line body's nested parameter
+ *      or type declarations end earlier.
+ *   2. A member definition (className set) whose class lexically encloses it
+ *      binds the candidate INSIDE that class (a one-line `class A { A() {} }`
+ *      or `type T struct { T int }` pins the member, not the container).
+ *   3. Otherwise the outermost declaration wins: parameters, named results
+ *      and qualified type names are always nested inside the declaration
+ *      they belong to.
+ */
+function pickDeclarationNameToken(candidates, definition) {
+    if (!candidates || candidates.length === 0) return null;
+    let pool = candidates;
+    if (definition && Number.isInteger(definition.endLine)) {
+        const spanMatch = pool.filter(c => c.decl.endPosition.row + 1 === definition.endLine);
+        if (spanMatch.length > 0) pool = spanMatch;
+    }
+    const className = definition && definition.className;
+    if (className) {
+        const inside = pool.filter(c => {
+            for (let anc = c.decl.parent, depth = 0; anc && depth < 12;
+                anc = anc.parent, depth++) {
+                const ancName = anc.childForFieldName?.('name');
+                if (ancName && ancName.text === className &&
+                    !sameNode(anc, c.decl)) return true;
+            }
+            return false;
+        });
+        if (inside.length > 0) pool = inside;
+    }
+    let best = null;
+    for (const c of pool) {
+        if (!best) { best = c; continue; }
+        const a = c.decl, b = best.decl;
+        if (a.startIndex <= b.startIndex && a.endIndex >= b.endIndex &&
+            (a.startIndex < b.startIndex || a.endIndex > b.endIndex)) {
+            best = c;
+        } else if (!(b.startIndex <= a.startIndex && b.endIndex >= a.endIndex) &&
+            c.column < best.column) {
+            // Disjoint declarations: earliest on the line.
+            best = c;
+        }
+    }
+    return best ? best.column : null;
+}
+
+/**
+ * Byte columns of `NAME` tokens on one line that are member accesses on the
+ * enclosing instance or class receiver (`this.NAME`, `self.NAME`,
+ * `cls.NAME`, `Self::NAME`), by AST: the token is the member part of its
+ * parent node and the parent's receiver part is a receiver keyword of the
+ * language (traits.selfParam) or a `this`/`self` node (fix #376).
+ */
+function selfMemberTokenColumns(index, filePath, lineNumber, name) {
+    const path = require('path');
+    const absolute = path.isAbsolute(filePath) ? filePath : path.join(index.root, filePath);
+    const language = index.files.get(absolute)?.language;
+    const parser = language && getParser(language);
+    if (!parser) return [];
+    let content;
+    try { content = index._readFile(absolute); } catch { return []; }
+    const tree = index._getParsedTree?.(absolute, content, language) || safeParse(parser, content);
+    if (!tree) return [];
+    const receivers = new Set([...(langTraits(language)?.selfParam || []), 'this', 'self', 'Self']);
+    const row = lineNumber - 1;
+    const out = [];
+    const stack = [tree.rootNode];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.endPosition.row < row || node.startPosition.row > row) continue;
+        if (node.startPosition.row === row && node.text === name &&
+            /identifier$/.test(node.type) && node.parent) {
+            const parent = node.parent;
+            const receiver = parent.namedChild(0);
+            if (receiver && !sameNode(receiver, node) &&
+                parent.namedChildCount === 2 && sameNode(parent.namedChild(1), node) &&
+                receivers.has(receiver.text.replace(/\s+/g, ''))) {
+                out.push(node.startPosition.column);
+            } else if (parent.type === 'member_access_expression' &&
+                sameNode(parent.childForFieldName('name'), node) &&
+                receivers.has(String(parent.childForFieldName('expression')?.text || '').replace(/\s+/g, ''))) {
+                // C# `this.m`: the keyword receiver is an anonymous node.
+                out.push(node.startPosition.column);
+            }
+            continue;
+        }
+        for (let i = 0; i < node.namedChildCount; i++) stack.push(node.namedChild(i));
+    }
+    return out;
+}
+
 /** Replace only AST identifier tokens on one source line. */
 function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
     preferredByteColumns = null, expectedCallCount = null, tokenOptions = {}) {
@@ -77,9 +192,15 @@ function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
                         // Wrapper identity via sameNode (#233 — wrappers are
                         // not reference-stable across walks).
                         if (tokenOptions.definitionNameOnly && node.parent) {
-                            const nameChild = node.parent.childForFieldName?.('name');
-                            if (nameChild && sameNode(nameChild, node)) {
-                                defNameByteColumns.push(node.startPosition.column);
+                            const decl = node.parent;
+                            const nameChild = decl.childForFieldName?.('name');
+                            const declaratorChild = decl.childForFieldName?.('declarator');
+                            if ((nameChild && sameNode(nameChild, node)) ||
+                                (declaratorChild && sameNode(declaratorChild, node))) {
+                                defNameByteColumns.push({
+                                    column: node.startPosition.column,
+                                    decl,
+                                });
                             }
                         }
                     }
@@ -95,14 +216,20 @@ function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
     // BuildVarsFunc) *Route`) — renaming every token breaks the type
     // reference. Rename only the definition's own NAME token (AST name field;
     // first occurrence as fallback) — javac/gopls rename semantics.
+    //
+    // Declaration identity (fix #359, gin-measured): several identifiers on
+    // a definition line can be their parent's name field (a Go named result
+    // `(head string)`, a qualified return type `http.Pusher`, a Java/C
+    // parameter declarator). The definition token is the name of the
+    // symbol's OWN declaration node, never a nested declaration's name.
     if (tokenOptions.definitionNameOnly && byteColumns.length > 1) {
-        byteColumns = defNameByteColumns.length > 0
-            ? [defNameByteColumns[0]]
-            : [Math.min(...byteColumns)];
+        const chosen = pickDeclarationNameToken(defNameByteColumns,
+            tokenOptions.definition || null);
+        byteColumns = chosen != null ? [chosen] : [Math.min(...byteColumns)];
     }
 
     const columns = [...new Set(byteColumns
-        .map(column => codeUnitColumnForByteColumn(sourceLine, column))
+        .map(column => tokenColumn(sourceLine, column, oldName))
         .filter(Number.isInteger))].sort((a, b) => b - a);
     if (expectedCallCount != null && columns.length !== expectedCallCount) {
         return { source: sourceLine.trim(), renamed: sourceLine.trim(), count: 0 };
@@ -113,7 +240,102 @@ function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
         renamed = renamed.slice(0, column) + newName +
             renamed.slice(column + oldName.length);
     }
-    return { source: sourceLine.trim(), renamed: renamed.trim(), count: columns.length };
+    return {
+        source: sourceLine.trim(), renamed: renamed.trim(), count: columns.length,
+        columns, rawSource: sourceLine, oldName, newName,
+    };
+}
+
+/**
+ * The column of the called name inside one call's source range (fix #392):
+ * two same-name calls on a line (`a.run(b.run())`) are two tokens, and the
+ * record of each call spans its own call node. Returns null when the range
+ * does not resolve to one name token on the line.
+ */
+function callTokenColumn(index, filePath, range, name, line) {
+    if (!range || !filePath) return null;
+    const absolute = require('path').isAbsolute(filePath)
+        ? filePath : require('path').join(index.root, filePath);
+    const language = index.files.get(absolute)?.language;
+    const parser = language && getParser(language);
+    if (!parser) return null;
+    let content;
+    try { content = index._readFile(absolute); } catch { return null; }
+    const tree = index._getParsedTree?.(absolute, content, language) || safeParse(parser, content);
+    if (!tree) return null;
+    let node = tree.rootNode.descendantForIndex(range.start, Math.max(range.start, range.end - 1));
+    while (node && !(node.startIndex <= range.start && node.endIndex >= range.end)) node = node.parent;
+    if (!node) return null;
+    // A call spelled inside a Python string annotation (fix #398F): the
+    // parser read it from the annotation's expression; the range is the
+    // called name inside the string's content.
+    if (node.type === 'string_content' && content.slice(range.start, range.end) === name &&
+        node.startPosition.row === line - 1 && node.endPosition.row === line - 1) {
+        return node.startPosition.column + (range.start - node.startIndex);
+    }
+    const isName = n => n && n.text === name && /identifier$/.test(n.type) &&
+        n.startPosition.row === line - 1;
+    if (isName(node)) return node.startPosition.column;
+    // The callee part of the call node: its last same-name token outside
+    // the argument list names the call (`x.run(y.run())` -> the outer run).
+    const callee = node.childForFieldName?.('function') || node.childForFieldName?.('name') ||
+        node.childForFieldName?.('method') || node.childForFieldName?.('constructor') ||
+        node.childForFieldName?.('macro') || null;
+    if (!callee) return null;
+    if (isName(callee)) return callee.startPosition.column;
+    const named = ['property', 'attribute', 'field', 'name'];
+    for (const field of named) {
+        const part = callee.childForFieldName?.(field);
+        if (isName(part)) return part.startPosition.column;
+    }
+    return null;
+}
+
+/**
+ * Merge a second token edit into an existing change on the same line
+ * (fix #376): a one-line method whose body calls a same-named slot member
+ * (`@Override public String m() { return delegate.m(); }`) needs its
+ * declaration token and its call token renamed in ONE line edit. Changes
+ * carry their token edit as a non-enumerable `_edit`.
+ */
+function mergeTokenEdit(change, edit) {
+    const prior = change?._edit;
+    if (!prior || !edit || prior.rawSource !== edit.rawSource ||
+        prior.oldName !== edit.oldName || prior.newName !== edit.newName) return false;
+    const columns = [...new Set([...prior.columns, ...edit.columns])].sort((a, b) => b - a);
+    if (columns.length === prior.columns.length) return true;
+    let renamed = prior.rawSource;
+    for (const column of columns) {
+        if (renamed.slice(column, column + prior.oldName.length) !== prior.oldName) continue;
+        renamed = renamed.slice(0, column) + prior.newName + renamed.slice(column + prior.oldName.length);
+    }
+    const previous = change.newExpression;
+    change.newExpression = renamed.trim();
+    if (typeof change.suggestion === 'string' && previous) {
+        change.suggestion = change.suggestion.replace(previous, change.newExpression);
+    }
+    tagTokenEdit(change, { ...prior, columns, renamed: change.newExpression });
+    return true;
+}
+
+/**
+ * Mark a change whose tokens a dedicated pass proved (a macro argument that
+ * declares the renamed class, an exactly resolved using-declaration): the
+ * type-reference pass keeps them even where its own lookup is unsure.
+ */
+function markEvidence(change) {
+    Object.defineProperty(change, '_evidence', {
+        value: true, enumerable: false, writable: true, configurable: true,
+    });
+    return change;
+}
+
+function tagTokenEdit(change, edit) {
+    if (!change || !edit || !Array.isArray(edit.columns)) return change;
+    Object.defineProperty(change, '_edit', {
+        value: edit, enumerable: false, writable: true, configurable: true,
+    });
+    return change;
 }
 
 // ============================================================================
@@ -335,8 +557,20 @@ function _collectCallNodes(node, callTypes, targetRow, funcName, limit, out = []
 
     // Recurse into children — nested same-name calls (`greet(greet(x))`)
     // are separate records, so a match's children are still scanned.
-    for (let i = 0; i < node.childCount; i++) {
-        _collectCallNodes(node.child(i), callTypes, targetRow, funcName, limit, out);
+    // Children are in source order: binary-search the first one that can
+    // reach the target row instead of visiting every earlier sibling.
+    const count = node.childCount;
+    let lo = 0;
+    let hi = count;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (node.child(mid).endPosition.row < targetRow) lo = mid + 1;
+        else hi = mid;
+    }
+    for (let i = lo; i < count; i++) {
+        const child = node.child(i);
+        if (child.startPosition.row > targetRow) break;
+        _collectCallNodes(child, callTypes, targetRow, funcName, limit, out);
         if (out.length >= limit) return out;
     }
     return out;
@@ -712,7 +946,7 @@ function _constructorParamLists(index, def, lang) {
  * @param {object} def - Resolved definition (pinned target)
  * @returns {{ confirmed: Array, unverified: Array, account: object }}
  */
-function contractedCallerSweep(index, name, def) {
+function contractedCallerSweep(index, name, def, options = {}) {
     const rawCallers = index.findCallers(name, {
         includeMethods: true,
         targetDefinitions: [def],
@@ -728,11 +962,38 @@ function contractedCallerSweep(index, name, def) {
     for (const u of rawCallers.unverifiedEntries || []) {
         unverified.push(u);
     }
+    // Call sites that bound the definition's base declaration and that the
+    // sweep of the changed declaration excludes (fix #394): they leave the
+    // excluded bucket and join the unverified band, to be checked against
+    // the new signature.
+    const rebound = options.baseChanges
+        ? sitesReboundByChange(index, name, def, rawCallers, confirmed, unverified, options.baseChanges)
+        : [];
+    if (rebound.length > 0 && rawCallers.accountRaw) {
+        const moved = new Set(rebound.filter(site => !site.stillUnverified)
+            .map(site => `${site.file}\0${site.line}`));
+        rawCallers.accountRaw = {
+            ...rawCallers.accountRaw,
+            excludedEntries: rawCallers.accountRaw.excludedEntries.filter(entry =>
+                !moved.has(`${entry.file}\0${entry.line}`)),
+        };
+        for (const site of rebound) {
+            // A site already in the band is replaced by its checked record.
+            const at = site.stillUnverified ? unverified.findIndex(u => u.file === site.file &&
+                u.line === site.line && !u.rebind && (site.column == null || u.column == null || u.column === site.column)) : -1;
+            if (at >= 0) unverified[at] = site;
+            else unverified.push(site);
+        }
+    }
 
     // Conservation account from the sweep's claims (impact's manual
     // composition).
     const { computeGroundSet, buildAccount } = require('./account');
-    const groundSet = computeGroundSet(index, name);
+    let groundSet = index._opGroundSetCache?.get(name);
+    if (!groundSet) {
+        groundSet = computeGroundSet(index, name);
+        index._opGroundSetCache?.set(name, groundSet);
+    }
     const accountRaw = rawCallers.accountRaw || { unverifiedLines: [], excludedEntries: [] };
     const confirmedEntries = confirmed.map(c => ({ file: c.file, line: c.line }));
     const unverifiedEntries = [
@@ -760,7 +1021,295 @@ function contractedCallerSweep(index, name, def) {
         return (a.line || 0) - (b.line || 0);
     });
 
-    return { confirmed, unverified, account, groundSet };
+    return {
+        confirmed, unverified, account, groundSet, rebound, baseChanges: rebound.baseChanges || null,
+        accountParts: { confirmedEntries, unverifiedEntries, excludedEntries: accountRaw.excludedEntries },
+    };
+}
+
+// ── Signature changes against a base revision (fix #394) ─────────────────
+//
+// The caller engine binds call sites the way the compiler does for code
+// that compiles: after `isEmpty(String)` became `isEmpty(String, boolean)`,
+// `Util.isEmpty(s)` fits no parameter list of the pin and the sibling
+// `isEmpty(Object[])` takes one argument, so the site is excluded as an
+// arity/overload mismatch - exactly the site `check` exists to report. The
+// base declaration decides which sites bound the definition before the
+// change; each is then judged against the new signature and the remaining
+// overloads.
+
+// Exclusions whose verdict depends on the pin's declared parameters.
+const SIGNATURE_DEPENDENT_EXCLUSIONS = new Set(['arity-mismatch', 'overload-mismatch', 'generic-arity-mismatch']);
+
+/** Declared parameter shape (types, optional/default/rest, method type parameters); names ignored. */
+function declaredSignatureKey(symbol) {
+    const ps = symbol?.paramsStructured;
+    const params = Array.isArray(ps)
+        ? ps.map(p => [String(p?.type ?? '').replace(/\s+/g, ''), p?.optional ? 'o' : '',
+            p?.default !== undefined ? 'd' : '', p?.rest ? 'r' : '', p?.type ? '' : String(p?.name ?? '')].join(':')).join(',')
+        : `raw:${String(symbol?.params ?? '').replace(/\s+/g, '')}`;
+    return `${params}|${String(symbol?.generics ?? '').replace(/\s+/g, '')}`;
+}
+
+/**
+ * The definition (and, for C/C++, its declarations elsewhere) whose declared
+ * parameters differ at `base`: [{ def, before }] with `before` the base
+ * declaration of the same name and owner, or [] (no git, untracked, file
+ * unchanged, parameters unchanged, or a new overload).
+ */
+const GIT_REF_FORMAT = /^[a-zA-Z0-9._\-~\/^@{}:]+$/;  // eslint-disable-line no-useless-escape
+
+/**
+ * Start reading `file` at `base` in the background (a shell running `git
+ * show` into a temporary file), so the read overlaps the caller sweep of the
+ * current declaration; null where that is not available.
+ */
+let baseReadSerial = 0;
+
+function startBaseRead(file, base) {
+    if (process.platform === 'win32' || !file || !GIT_REF_FORMAT.test(base)) return null;
+    const out = path.join(os.tmpdir(),
+        `ucn-base-${process.pid}-${++baseReadSerial}-${Math.random().toString(36).slice(2, 10)}`);
+    let child;
+    try {
+        // The content appears under `out` only once complete; `out.none`
+        // marks a revision that does not hold the file.
+        child = spawn('/bin/sh', ['-c',
+            'git show "$1" > "$2.part" 2>/dev/null && mv "$2.part" "$2" || { rm -f "$2.part"; : > "$2.none"; }',
+            'ucn-base', `${base}:./${path.basename(file)}`, out],
+        { cwd: path.dirname(file), stdio: 'ignore' });
+    } catch {
+        child = null;
+    }
+    if (!child?.pid) return null;
+    child.on('error', () => {});
+    child.unref();
+    return { file, out };
+}
+
+/** Throw a UcnError unless `base` names a commit of the repository holding `file`. */
+function assertGitCommit(file, base) {
+    try {
+        execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd: path.dirname(file), stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    } catch (e) {
+        throw new UcnError('Not a git repository. check --base requires git.', { cause: e });
+    }
+    try {
+        execFileSync('git', ['rev-parse', '--verify', '--quiet', '--end-of-options', `${base}^{commit}`], {
+            cwd: path.dirname(file), stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    } catch (e) {
+        throw new UcnError(`Unknown git ref: ${base}`, { cause: e });
+    }
+}
+
+/** The content a background read produced: a string, null (not at base), or undefined (no answer in time). */
+function finishBaseRead(handle, timeoutMs = 15000) {
+    const cell = new Int32Array(new SharedArrayBuffer(4));
+    const started = Date.now();
+    const none = `${handle.out}.none`;
+    try {
+        for (;;) {
+            if (fs.existsSync(handle.out)) return fs.readFileSync(handle.out, 'utf-8');
+            if (fs.existsSync(none)) return null;
+            if (Date.now() - started > timeoutMs) return undefined;
+            Atomics.wait(cell, 0, 0, 1);
+        }
+    } catch {
+        return undefined;
+    } finally {
+        handle.done = true;
+        for (const leftover of [handle.out, none]) {
+            try { fs.unlinkSync(leftover); } catch { /* not created */ }
+        }
+    }
+}
+
+function baseDeclarationChanges(index, name, def, base = 'HEAD', baseRead = null) {
+    if (!GIT_REF_FORMAT.test(base)) {
+        throw new UcnError(`Invalid git ref format: ${base}`);
+    }
+    const language = index.files.get(def.file)?.language;
+    let members = [def];
+    if (language === 'c' || language === 'cpp') {
+        const { _closeCallableIdentityGroup } = require('./callers');
+        members = _closeCallableIdentityGroup(index, [def], index.symbols.get(name) || [def]);
+    }
+    const byFile = new Map();
+    for (const member of members) {
+        if (!member.file || !index.files.has(member.file)) continue;
+        if (!byFile.has(member.file)) byFile.set(member.file, []);
+        byFile.get(member.file).push(member);
+    }
+    const { extractCallableSymbols } = require('./analysis');
+    const changes = [];
+    for (const [file, defs] of [...byFile].sort(([a], [b]) => codeUnitCompare(a, b))) {
+        let baseContent = baseRead && !baseRead.done && baseRead.file === file ? finishBaseRead(baseRead) : undefined;
+        if (baseContent === null) continue;
+        if (baseContent === undefined) {
+            try {
+                baseContent = execFileSync('git', ['show', `${base}:./${path.basename(file)}`], {
+                    cwd: path.dirname(file), encoding: 'utf-8', maxBuffer: 256 * 1024 * 1024,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                });
+            } catch {
+                continue;
+            }
+        }
+        // Unchanged since base: the index's content hash of the file says so
+        // without reading it again.
+        const indexedHash = index.files.get(file)?.hash;
+        if (indexedHash && require('crypto').createHash('md5').update(baseContent).digest('hex') === indexedHash) continue;
+        if (!indexedHash) {
+            let current;
+            try { current = index._readFile(file); } catch { continue; }
+            if (baseContent === current) continue;
+        }
+        const entry = index.files.get(file);
+        let baseSymbols;
+        try {
+            baseSymbols = extractCallableSymbols(require('./parser').parse(baseContent, entry.language));
+        } catch {
+            continue;
+        }
+        for (const d of defs) {
+            const before = baseCounterpartOf(entry.symbols, baseSymbols, d);
+            if (before) changes.push({ def: d, before });
+        }
+    }
+    return changes;
+}
+
+/**
+ * The base declaration of `d` (same name and owner) when its declared
+ * parameters changed, else null: base overloads a current sibling still
+ * declares are that sibling; among the rest the nearest line wins.
+ */
+function baseCounterpartOf(currentSymbols, baseSymbols, d) {
+    const identity = symbol => `${symbol.name}\0${symbol.className || ''}`;
+    const callable = symbol => {
+        const type = symbol.type || symbol.memberType || 'method';
+        return !NON_CALLABLE_TYPES.has(type) || (type === 'field' && symbol.isMethod);
+    };
+    const same = baseSymbols.filter(symbol => identity(symbol) === identity(d));
+    const key = declaredSignatureKey(d);
+    if (same.length === 0 || same.some(symbol => declaredSignatureKey(symbol) === key)) return null;
+    const siblings = new Set((currentSymbols || []).filter(symbol => symbol !== d && callable(symbol) &&
+        identity(symbol) === identity(d)).map(declaredSignatureKey));
+    const changed = same.filter(symbol => !siblings.has(declaredSignatureKey(symbol)));
+    if (changed.length === 0) return null;
+    changed.sort((a, b) => Math.abs(a.startLine - d.startLine) - Math.abs(b.startLine - d.startLine) ||
+        a.startLine - b.startLine);
+    return changed[0];
+}
+
+const DECLARED_SIGNATURE_FIELDS = ['params', 'paramsStructured', 'generics'];
+
+/** Callers of `def` as the index binds them with each changed declaration's base parameters. */
+function callersBeforeChange(index, name, def, changes) {
+    return index._isolatedOperation(() => {
+        const saved = changes.map(change => [change.def, DECLARED_SIGNATURE_FIELDS.map(field =>
+            [field, Object.prototype.hasOwnProperty.call(change.def, field), change.def[field]])]);
+        try {
+            for (const change of changes) {
+                for (const field of DECLARED_SIGNATURE_FIELDS) {
+                    if (change.before[field] === undefined) delete change.def[field];
+                    else change.def[field] = change.before[field];
+                }
+            }
+            const raw = index.findCallers(name, { includeMethods: true, targetDefinitions: [def], collectAccount: true });
+            return [
+                ...raw.filter(c => c.tier !== 'unverified').map(c => ({ site: c, boundBefore: 'confirmed' })),
+                ...raw.filter(c => c.tier === 'unverified').concat(raw.unverifiedEntries || [])
+                    .map(c => ({ site: c, boundBefore: 'unverified' })),
+            ];
+        } finally {
+            for (const [definition, fields] of saved) {
+                for (const [field, own, value] of fields) {
+                    if (own) definition[field] = value;
+                    else delete definition[field];
+                }
+            }
+        }
+    });
+}
+
+/**
+ * Sites the base declaration bound that the current sweep excludes, each
+ * with its verdict against the new signature: `rebind.kind` is
+ * 'no-overload' (fits no parameter list: a compile error), 'other-overload'
+ * (another overload may take it now), 'count' (the argument count decides)
+ * or 'unread' (the call record could not be re-read).
+ */
+function sitesReboundByChange(index, name, def, rawCallers, confirmed, unverified, changes) {
+    const excluded = rawCallers.accountRaw?.excludedEntries || [];
+    // Only an exclusion by parameter fit, or a site left unverified, can hide
+    // a call of the old declaration; otherwise the base is not read.
+    const dependent = excluded.filter(entry => SIGNATURE_DEPENDENT_EXCLUSIONS.has(entry.reason));
+    if (dependent.length === 0 && unverified.length === 0) return [];
+    const baseChanges = typeof changes === 'function' ? changes() : changes;
+    if (!baseChanges || baseChanges.length === 0) return [];
+    const siteKey = site => `${site.file}\0${site.line}`;
+    const confirmedKeys = new Set(confirmed.map(siteKey));
+    const unverifiedKeys = new Set(unverified.map(siteKey));
+    const reasonAt = new Map(excluded.map(entry => [siteKey(entry), entry.reason]));
+    const before = callersBeforeChange(index, name, def, baseChanges);
+    const { getCachedCalls, _overloadDiscipline, _overloadApplicable } = require('./callers');
+    const pins = [...new Set([def, ...baseChanges.map(change => change.def)])];
+    const definitions = index.symbols.get(name) || [];
+    const out = [];
+    const seen = new Set();
+    for (const { site, boundBefore } of before) {
+        const key = siteKey(site);
+        // A site still confirmed is arg-checked as usual. A site the old
+        // declaration confirmed and the new one leaves unverified or
+        // excludes is checked against the new declaration here.
+        if (confirmedKeys.has(key) || seen.has(key)) continue;
+        if (unverifiedKeys.has(key) ? boundBefore !== 'confirmed' : !reasonAt.has(key)) continue;
+        seen.add(key);
+        const calls = (getCachedCalls(index, site.file) || []).filter(call =>
+            call.line === site.line && (call.name === name || call.resolvedName === name));
+        const call = calls.find(c => site.column == null || c.column === site.column) || calls[0];
+        const language = index.files.get(site.file)?.language;
+        let rebind = { kind: call ? 'count' : 'unread' };
+        if (call && langTraits(language)?.hasArityOverloads && call.argCount != null && !call.argSpread) {
+            const verdict = _overloadDiscipline(index, call, pins, definitions, site.file);
+            if (verdict === 'other-overload') {
+                const { ownerRefOf } = require('./class-identity');
+                const ownerKey = ownerRefOf(index, def)?.key;
+                const others = definitions.filter(d => !pins.includes(d) && !NON_CALLABLE_TYPES.has(d.type) &&
+                    d.className === def.className && ownerKey && ownerRefOf(index, d)?.key === ownerKey &&
+                    _overloadApplicable(index, call, d));
+                rebind = { kind: 'other-overload', overloads: others.map(d => formatTypedSignature(d)) };
+            } else if (verdict?.ambiguous) {
+                rebind = verdict.candidates === 0 ? { kind: 'no-overload' }
+                    : { kind: 'other-overload', candidates: verdict.candidates };
+            }
+        }
+        let content = site.content;
+        if (content == null) {
+            try { content = index._getFileLines(site.file)[site.line - 1] ?? ''; } catch { content = ''; }
+        }
+        const prior = unverifiedKeys.has(key)
+            ? unverified.find(u => siteKey(u) === key && (site.column == null || u.column == null || u.column === site.column))
+            : null;
+        out.push({
+            ...site,
+            content,
+            tier: 'unverified',
+            reason: 'bound-before-change',
+            ...(prior?.reason && { priorReason: prior.reason }),
+            boundBefore,
+            excludedAs: reasonAt.get(key) || null,
+            ...(unverifiedKeys.has(key) && { stillUnverified: true }),
+            rebind,
+        });
+    }
+    out.sort((a, b) => codeUnitCompare(a.relativePath || '', b.relativePath || '') || a.line - b.line);
+    out.baseChanges = baseChanges;
+    return out;
 }
 
 /** Map an unverified sweep entry to the public site shape (relative `file`). */
@@ -782,6 +1331,7 @@ function unverifiedSiteShape(u) {
         // Module-attribute attribution (fix #294): the name binds the module's
         // export surface — a non-slot surface for rename purposes.
         ...(u.moduleAttribute && { moduleAttribute: true }),
+        ...(u.annotationShorthand && { annotationShorthand: u.annotationShorthand }),
     };
 }
 
@@ -794,12 +1344,22 @@ function unverifiedSiteShape(u) {
  * @param {object} def - Resolved definition
  * @returns {{ sites: Array, unverifiedSites: Array, account: object }}
  */
-function computePlanCallSites(index, name, def) {
-    const { confirmed, unverified, account, groundSet } = contractedCallerSweep(index, name, def);
+function computePlanCallSites(index, name, def, options = {}) {
+    // A plan holds one call-site tree per file across its sweeps (fix #395).
+    const ownsTreeCache = !index._treeCache;
+    // A rename edits name tokens only; argument analysis (a parse of every
+    // caller file) serves signature changes (fix #396).
+    const analyzeArgs = options.analyzeArgs !== false;
+    const { confirmed, unverified, account, groundSet, accountParts } =
+        contractedCallerSweep(index, name, def);
 
     const sites = [];
     const planLineSeen = new Map(); // 'file:line' -> per-line ordinal (fix #231)
     for (const c of confirmed) {
+        // A call a macro template generated is spelled in the macro
+        // definition (fix #374): the template pass edits or lists it there;
+        // the invocation line has no token to rename.
+        if (c.macroExpansion?.origin === 'template') continue;
         const call = {
             file: c.file,
             relativePath: c.relativePath,
@@ -813,35 +1373,50 @@ function computePlanCallSites(index, name, def) {
         const siteKey = `${c.file}:${c.line}:${c.calledAs || name}`;
         const occurrence = planLineSeen.get(siteKey) || 0;
         planLineSeen.set(siteKey, occurrence + 1);
-        const analysis = analyzeCallSite(index, call, name, occurrence);
+        const analysis = analyzeArgs ? analyzeCallSite(index, call, name, occurrence) : { args: null, argCount: 0 };
+        // The call's source range (provenance site) lets the rename find
+        // its own name token when the record carries no column (fix #392).
+        const siteFacts = c.provenance?.facts?.site;
+        const siteRange = !Number.isInteger(c.column) && siteFacts &&
+            siteFacts.line === c.line && Number.isInteger(siteFacts.start) &&
+            Number.isInteger(siteFacts.end) ? { start: siteFacts.start, end: siteFacts.end } : null;
         sites.push({
             file: call.relativePath,
             absoluteFile: call.file,
             line: call.line,
             ...(Number.isInteger(c.column) && { column: c.column }),
+            ...(siteRange && { siteRange }),
             expression: (call.content || '').trim(),
             args: analysis.args,
             argCount: analysis.argCount,
             ...(analysis.keywordArgNames && { keywordArgNames: analysis.keywordArgNames }),
             ...(analysis.positionalCount != null && { positionalCount: analysis.positionalCount }),
             ...(c.calledAs && { calledAs: c.calledAs }),
+            ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
+            ...(c.targetTyped && { targetTyped: true }),
+            ...(c.destructured && { destructured: c.destructured }),
+            ...(c.importAliasSpelling && { importAliasSpelling: true }),
         });
     }
-    clearTreeCache(index);
-    // Stable ordering (matches CLAUDE.md rule #11): files alphabetical, sites by line ascending.
+    if (ownsTreeCache) clearTreeCache(index);
+    // Stable ordering contract: files alphabetical, sites by line ascending.
     sites.sort((a, b) => {
         const fc = codeUnitCompare(String(a.file), String(b.file));
         if (fc !== 0) return fc;
         return (a.line || 0) - (b.line || 0);
     });
+    // A target-typed `new(..)` spells no name (fix #400): a rename never
+    // edits it, so an undecided one is no rename candidate either.
+    const renameRelevant = u => u.macroExpansion?.origin !== 'template' && !u.targetTyped;
     return {
         sites,
-        unverifiedSites: unverified.map(unverifiedSiteShape),
+        unverifiedSites: unverified.filter(renameRelevant).map(unverifiedSiteShape),
         // Plan-only evidence used to promote calls through a compiler-proven
         // Go interface slot. Kept out of the public JSON surface.
-        rawUnverified: unverified,
+        rawUnverified: unverified.filter(renameRelevant),
         account,
         groundSet,
+        accountParts,
     };
 }
 
@@ -877,6 +1452,22 @@ function computePlanScopeWarning(index, name, def, options) {
  * @param {string} funcName - Function name to find
  * @returns {object} { args, argCount, hasSpread, hasVariable }
  */
+/**
+ * The operation's parsed tree of a file (the one the ground-set
+ * classification already parsed) when the language's query tree for this
+ * content is the plain parse; null otherwise (a C# file with conditional
+ * directives reads a configuration view).
+ */
+function sharedParsedTree(index, file, content, language) {
+    if (typeof index._getParsedTree !== 'function') return null;
+    // A language that queries its own view of a file (C# conditional
+    // compilation) shares the tree only where that view is the plain parse
+    // (fix #395).
+    const adapter = getLanguageAdapter(language);
+    if (adapter?.queryTree && !adapter.queryTreeIsPlain?.(content, index.files?.get(file))) return null;
+    return index._getParsedTree(file, content, language);
+}
+
 function analyzeCallSite(index, call, funcName, occurrence = 0) {
     try {
         const language = detectLanguage(call.file);
@@ -897,9 +1488,12 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
                 const virtualJS = htmlModule.buildVirtualJSContent(content, blocks);
                 tree = safeParse(jsParser, virtualJS);
             } else {
-                const parser = getParser(language);
-                if (!parser) return { args: null, argCount: 0 };
-                tree = safeParse(parser, content);
+                tree = sharedParsedTree(index, call.file, content, language);
+                if (!tree) {
+                    const parser = getParser(language);
+                    if (!parser) return { args: null, argCount: 0 };
+                    tree = safeParse(parser, content);
+                }
             }
             if (!tree) return { args: null, argCount: 0 };
             if (!index._treeCache) index._treeCache = new Map();
@@ -1069,9 +1663,12 @@ function analyzeCallShape(index, filePath, lineNum, funcName) {
                 const virtualJS = htmlModule.buildVirtualJSContent(content, blocks);
                 tree = safeParse(jsParser, virtualJS);
             } else {
-                const parser = getParser(language);
-                if (!parser) return null;
-                tree = safeParse(parser, content);
+                tree = sharedParsedTree(index, filePath, content, language);
+                if (!tree) {
+                    const parser = getParser(language);
+                    if (!parser) return null;
+                    tree = safeParse(parser, content);
+                }
             }
             if (!tree) return null;
             if (!index._treeCache) index._treeCache = new Map();
@@ -1323,7 +1920,11 @@ function verify(index, name, options = {}) {
     const ctorParamLists = _constructorParamLists(index, def, lang);
     const inheritedCtorOnly = !ctorParamLists && def.type === 'class' && !!def.extends;
     const selfParams = langTraits(lang)?.selfParam;
-    const stripSelf = (list) => (selfParams && list.length > 0 && list[0] && selfParams.includes(list[0].name))
+    // `&'a mut self` names the receiver too (fix #369): lifetimes are not
+    // part of the receiver spelling.
+    const selfSpelling = name => String(name || '').replace(/'[A-Za-z_]\w*\s*/g, '').trim();
+    const stripSelf = (list) => (selfParams && list.length > 0 && list[0] &&
+        selfParams.includes(selfSpelling(list[0].name)))
         ? list.slice(1) : list;
     let callableIdentityParams = null;
     if (!ctorParamLists && ['c', 'cpp'].includes(lang)) {
@@ -1354,21 +1955,47 @@ function verify(index, name, options = {}) {
     // dropped). Engine receiver physics replace the pre-v4 className filter
     // and the isMethodCall secondary filter — --include-methods and
     // --include-uncertain are implied no-ops for verify.
-    const { confirmed: callerResults, unverified: sweepUnverified, account } =
-        contractedCallerSweep(index, name, def);
+    // A declaration changed since the base revision is checked on the call
+    // sites its base declaration bound (fix #394); the base file is read in
+    // the background while the current declaration is swept, and used only
+    // when the sweep excludes a site by parameter fit or leaves one unverified.
+    const baseRef = options.base || 'HEAD';
+    if (!GIT_REF_FORMAT.test(baseRef)) throw new UcnError(`Invalid git ref format: ${baseRef}`);
+    // A base the user names must be a commit: a misspelled ref would read as
+    // a file absent at base and check nothing against the old declaration
+    // (the target-less check already resolved its base through the diff).
+    if (options.base && options.checkBaseRef) assertGitCommit(def.file, baseRef);
+    const baseRead = startBaseRead(def.file, baseRef);
+    let sweep;
+    try {
+        sweep = contractedCallerSweep(index, name, def, {
+            baseChanges: () => baseDeclarationChanges(index, name, def, baseRef, baseRead),
+        });
+    } finally {
+        if (baseRead && !baseRead.done) finishBaseRead(baseRead);
+    }
+    const { confirmed: callerResults, unverified: sweepUnverified, account, rebound, baseChanges } = sweep;
 
     // Convert caller results to usage-like objects for analyzeCallSite.
     // Carry callerFile/callerStartLine through so we can compute inTestCase.
     const invalidFamilyCalls = sweepUnverified.filter(c =>
-        validateCallMismatch(c.provenance, declarationIdentity(def)));
-    const calls = [...callerResults, ...invalidFamilyCalls].map(c => ({
-        invalidOverload: invalidFamilyCalls.includes(c),
+        !c.rebind && validateCallMismatch(c.provenance, declarationIdentity(def)));
+    const siteContent = c => {
+        if (c.content != null) return c.content;
+        try { return index._getFileLines(c.file)[c.line - 1] ?? ''; } catch { return ''; }
+    };
+    const pinBaseChange = (baseChanges || []).find(change => change.def === def) || null;
+    const calls = [...callerResults, ...invalidFamilyCalls, ...rebound].map(c => ({
+        invalidOverload: invalidFamilyCalls.includes(c) || c.rebind?.kind === 'no-overload',
+        ...(c.rebind && { rebind: c.rebind, excludedAs: c.excludedAs, boundBefore: c.boundBefore,
+            unverifiedReason: c.priorReason }),
         file: c.file,
         relativePath: c.relativePath,
         line: c.line,
-        content: c.content,
+        content: siteContent(c),
         usageType: 'call',
         receiver: c.receiver,
+        isMethod: c.isMethod,
         calledAs: c.calledAs,
         callSite: c.provenance?.facts?.site,
         // Preserve receiver identity through the usage-shaped adapter. Go
@@ -1378,6 +2005,7 @@ function verify(index, name, options = {}) {
         receiverType: c.receiverType,
         callerFile: c.callerFile,
         callerStartLine: c.callerStartLine,
+        ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
     }));
 
     const valid = [];
@@ -1424,13 +2052,17 @@ function verify(index, name, options = {}) {
             callerStartLine: call.callerStartLine,
         };
 
-        if (analysis.args === null) {
-            // Couldn't parse arguments
+        if (analysis.args === null || call.macroExpansion) {
+            // Couldn't parse arguments, or the call exists only in the
+            // expansion of a macro invocation on this line (fix #362): its
+            // arguments are the macro's, not text on the line.
             uncertain.push({
                 file: call.relativePath,
                 line: call.line,
                 expression: call.content.trim(),
-                reason: analysis.uncertainReason || 'Could not parse call arguments',
+                reason: call.macroExpansion
+                    ? `Call produced by expanding macro ${call.macroExpansion.macro}; check the macro's argument list`
+                    : analysis.uncertainReason || 'Could not parse call arguments',
                 patterns: patternFlagsFrom(analysis),
                 ...carry,
             });
@@ -1453,6 +2085,9 @@ function verify(index, name, options = {}) {
         }
 
         let argCount = analysis.argCount;
+        // A C# extension method called on its receiver (`b.Length(1, 2)`)
+        // receives that receiver as its `this` parameter (fix #394).
+        if (def.isExtensionMethod && call.isMethod && call.receiver !== def.className) argCount += 1;
         // Method-expression / UFCS receiver shift (fix #230): Go
         // `M.Add(*m, 2)` and Rust `Engine::run(&e, 1)` pass the receiver as
         // the FIRST argument — the same +1 shift the #205 arity discipline
@@ -1472,11 +2107,32 @@ function verify(index, name, options = {}) {
         const countOk = hasRest
             ? argCount >= minArgs
             : (argCount >= minArgs && argCount <= expectedParamCount);
+        if (call.rebind && call.rebind.kind !== 'no-overload' && (countOk || call.rebind.kind !== 'count')) {
+            // Bound the base declaration; the new one may still take it, or
+            // another overload may: the compiler decides (fix #394).
+            const target = call.rebind.overloads?.length > 0
+                ? `it may now bind ${call.rebind.overloads.join(' or ')}`
+                : call.rebind.candidates > 0 ? `it may now bind one of ${call.rebind.candidates} overloads`
+                    : call.rebind.kind === 'unread' ? 'its call could not be re-read'
+                        : call.excludedAs ? `the index excludes it now (${call.excludedAs})`
+                            : `its binding to the new declaration is unverified (${call.unverifiedReason || 'no evidence'})`;
+            uncertain.push({
+                file: call.relativePath,
+                line: call.line,
+                expression: call.content.trim(),
+                reason: `Called the declaration before the change; ${target}`,
+                boundBeforeChange: true,
+                patterns: patternFlagsFrom(analysis),
+                ...carry,
+            });
+            continue;
+        }
         if (!countOk || call.invalidOverload) {
             mismatches.push({
                 file: call.relativePath,
                 line: call.line,
                 expression: call.content.trim(),
+                ...(call.rebind && { boundBeforeChange: true }),
                 expected: call.invalidOverload && countOk ? 'a compatible overload signature' : hasRest
                     ? `at least ${minArgs} arg(s)`
                     : (minArgs === expectedParamCount
@@ -1641,6 +2297,15 @@ function verify(index, name, options = {}) {
         patterns: patternsAgg,
         scopeWarning,
         ...(warnings.length > 0 && { warnings }),
+        // The base declaration whose call sites were checked (fix #394).
+        ...(pinBaseChange && {
+            changedSince: {
+                base: options.base || 'HEAD',
+                signature: formatTypedSignature({ ...def, ...pinBaseChange.before,
+                    ...(pinBaseChange.before.generics === undefined && { generics: undefined }) }),
+                callSites: rebound.length,
+            },
+        }),
     };
     } finally { index._endOp(); }
 }
@@ -1690,223 +2355,80 @@ const RESERVED_WORDS_BY_LANGUAGE = {
         'while').split(' ')),
 };
 
-/** Split a Go signature list on commas outside nested type syntax. */
-function splitGoSignatureList(raw) {
-    const text = String(raw || '').trim().replace(/^\((.*)\)$/s, '$1');
-    if (!text) return [];
-    const out = [];
-    let start = 0;
-    let round = 0;
-    let square = 0;
-    let curly = 0;
-    for (let i = 0; i < text.length; i++) {
-        const ch = text[i];
-        if (ch === '(') round++;
-        else if (ch === ')') round = Math.max(0, round - 1);
-        else if (ch === '[') square++;
-        else if (ch === ']') square = Math.max(0, square - 1);
-        else if (ch === '{') curly++;
-        else if (ch === '}') curly = Math.max(0, curly - 1);
-        else if (ch === ',' && round === 0 && square === 0 && curly === 0) {
-            out.push(text.slice(start, i).trim());
-            start = i + 1;
-        }
-    }
-    out.push(text.slice(start).trim());
-    return out.filter(Boolean);
-}
-
-const GO_UNNAMED_TYPE_PREFIX = /^(?:\*|\[|map\[|chan(?:<-)?\s|<-chan\s|func\s*\(|interface\s*\{|struct\s*\{|\.\.\.)/;
-
-/** Turn one raw Go parameter/result declaration into its type spelling. */
-function goDeclarationType(raw) {
-    let value = String(raw || '').trim();
-    if (!value) return null;
-    // Named slots/results: `value T`, `ctx context.Context`. Unnamed type
-    // forms starting with Go type syntax (`chan T`, `func(...)`, `*T`) keep
-    // their whole text. Structured params normally handle grouped names;
-    // this fallback exists for unnamed interface slots and result tuples.
-    if (!GO_UNNAMED_TYPE_PREFIX.test(value)) {
-        const named = value.match(/^[A-Za-z_][A-Za-z0-9_]*\s+(.+)$/s);
-        if (named) value = named[1].trim();
-    }
-    return value.replace(/\s+/g, '');
-}
+const {
+    goContractClosure,
+    externalContractOf,
+    hierarchySlotClosure,
+    anonymousSlotMembers,
+    typedLiteralContract,
+    typedLiteralMembers,
+    rustProjectTraits,
+    rustMacroTemplateSites,
+    splitGoSignatureList,
+    goDeclarationType,
+} = require('./contract-membership');
 
-/** Compiler-shaped Go method fingerprint: parameter types + result types. */
-function goMethodFingerprint(def) {
-    let params;
-    if (Array.isArray(def.paramsStructured) && def.paramsStructured.length > 0) {
-        params = [];
-        for (const param of def.paramsStructured) {
-            const rawType = param.type || (param.unnamed ? param.name : null);
-            const type = goDeclarationType(rawType);
-            if (!type) return null;
-            params.push(type);
-        }
-    } else if (def.params === '' || def.params == null) {
-        params = [];
+/**
+ * Plan verdict of a C++ qualified reference `Q::name` to the renamed
+ * callable (fix #393): Q resolved from the reference's scope (macro-opened
+ * namespaces, usings, aliases) names the pin's namespace (a namespace-scope
+ * pin) or its class (a member): 'edit'; another namespace or class: null;
+ * unresolvable: 'review'.
+ */
+function cppQualifiedReferenceVerdict(index, ref, def) {
+    const { resolveQualifier, effectiveNamespace, macroPrefixAt, includeClosure } = require('./cpp-scope');
+    // Inside an indexed declaration the reference's scope is that
+    // declaration's (as for calls); at namespace scope (an explicit
+    // instantiation is no indexed symbol) it is read from the AST under the
+    // macro-opened prefix.
+    const enclosing = index.findEnclosingFunction(ref.file, ref.line, true);
+    let namespace;
+    if (enclosing) {
+        namespace = effectiveNamespace(index, enclosing) || '';
     } else {
-        params = splitGoSignatureList(def.params).map(goDeclarationType);
-        if (params.some(type => !type)) return null;
+        let astNamespace = '';
+        try {
+            const content = index._readFile(ref.file);
+            const tree = index._getParsedTree?.(ref.file, content, 'cpp') || safeParse(getParser('cpp'), content);
+            const row = ref.line - 1;
+            const text = (index._getFileLines?.(ref.file) || content.split('\n'))[row] || '';
+            const column = Number.isInteger(ref.column) ? ref.column : Math.max(0, text.search(/\S/));
+            const parts = [];
+            for (let node = tree?.rootNode.descendantForPosition({ row, column }); node; node = node.parent) {
+                if (node.type !== 'namespace_definition') continue;
+                const nameNode = node.childForFieldName('name');
+                if (nameNode?.text) parts.unshift(nameNode.text.replace(/\s+/g, ''));
+            }
+            astNamespace = parts.join('::');
+        } catch { /* unparsed: the prefix alone */ }
+        const prefix = macroPrefixAt(index, ref.file, ref.line) || '';
+        namespace = prefix && astNamespace ? `${prefix}::${astNamespace}` : prefix || astNamespace;
     }
-    const results = def.returnType
-        ? splitGoSignatureList(def.returnType).map(goDeclarationType)
-        : [];
-    if (results.some(type => !type)) return null;
-    return `${params.join(',')}->${results.join(',')}`;
-}
-
-function goTypeIdentity(name, file) {
-    const pathMod = require('path');
-    return `${pathMod.dirname(file || '')}\0${name}`;
-}
-
-function goTypeDefinition(index, name, fromFile) {
-    const pathMod = require('path');
-    const dir = pathMod.dirname(fromFile || '');
-    const kinds = new Set(['struct', 'type', 'class']);
-    const defs = (index.symbols.get(name) || []).filter(candidate =>
-        candidate.file && pathMod.dirname(candidate.file) === dir &&
-        kinds.has(candidate.type));
-    if (defs.length !== 1 || defs[0].generics) return null;
-    return defs[0];
-}
-
-function goInterfaceMembers(index, interfaceDef) {
-    const out = [];
-    for (const defs of index.symbols.values()) {
-        for (const candidate of defs) {
-            if (candidate.file === interfaceDef.file &&
-                candidate.className === interfaceDef.name &&
-                candidate.type === 'method' &&
-                candidate.startLine >= interfaceDef.startLine &&
-                candidate.startLine <= interfaceDef.endLine) out.push(candidate);
-        }
+    const context = {
+        file: ref.file,
+        line: ref.line,
+        namespace,
+        className: enclosing?.className || null,
+    };
+    let resolved;
+    try {
+        resolved = resolveQualifier(index, context, String(ref.receiver), includeClosure(index, ref.file));
+    } catch {
+        return 'review';
     }
-    return out;
-}
-
-/** Authored embedded-type spellings for one Go type declaration. */
-function goEmbeddedTypes(index, typeDef) {
-    const out = [];
-    for (const definitions of index.symbols.values()) {
-        for (const candidate of definitions) {
-            if (candidate.file === typeDef.file &&
-                candidate.className === typeDef.name &&
-                candidate.type === 'field' && candidate.fieldType &&
-                candidate.startLine >= typeDef.startLine &&
-                candidate.startLine <= typeDef.endLine) {
-                out.push(String(candidate.fieldType).trim());
-            }
-        }
+    if (!resolved || resolved.kind === 'unknown') return 'review';
+    const owner = def.className || (def.receiver ? String(def.receiver).replace(/^\*/, '') : null);
+    if (resolved.kind === 'namespace') {
+        if (owner) return null;
+        return (resolved.resolvedNamespace || resolved.namespace) === effectiveNamespace(index, def) ? 'edit' : null;
     }
-    return out;
-}
-
-/**
- * Complete method requirements for one project Go interface. A qualified or
- * unresolved embedded interface makes the set open, so the caller abstains.
- */
-function goInterfaceRequirements(index, interfaceDef, memo, visiting = new Set()) {
-    const key = `${interfaceDef.file}\0${interfaceDef.name}`;
-    if (memo.has(key)) return memo.get(key);
-    if (visiting.has(key) || interfaceDef.generics) return null;
-    visiting.add(key);
-    const requirements = new Map();
-    for (const member of goInterfaceMembers(index, interfaceDef)) {
-        const fingerprint = goMethodFingerprint(member);
-        if (!fingerprint) { visiting.delete(key); memo.set(key, null); return null; }
-        const previous = requirements.get(member.name);
-        if (previous && previous.fingerprint !== fingerprint) {
-            visiting.delete(key); memo.set(key, null); return null;
-        }
-        requirements.set(member.name, { fingerprint, defs: [member] });
-    }
-    for (const rawParent of goEmbeddedTypes(index, interfaceDef)) {
-        if (rawParent.includes('.')) {
-            visiting.delete(key); memo.set(key, null); return null;
-        }
-        const parent = (index.symbols.get(rawParent) || []).find(candidate =>
-            candidate.type === 'interface' &&
-            require('path').dirname(candidate.file || '') ===
-                require('path').dirname(interfaceDef.file || ''));
-        if (!parent) { visiting.delete(key); memo.set(key, null); return null; }
-        const inherited = goInterfaceRequirements(index, parent, memo, visiting);
-        if (!inherited) { visiting.delete(key); memo.set(key, null); return null; }
-        for (const [name, requirement] of inherited) {
-            const previous = requirements.get(name);
-            if (previous && previous.fingerprint !== requirement.fingerprint) {
-                visiting.delete(key); memo.set(key, null); return null;
-            }
-            if (!previous) requirements.set(name, requirement);
-        }
-    }
-    visiting.delete(key);
-    const result = requirements.size > 0 ? requirements : null;
-    memo.set(key, result);
-    return result;
-}
-
-/**
- * Method set for a project Go named type, including promoted embedded methods.
- * Unknown/external embeddings make the set open and force abstention.
- */
-function goConcreteMethodSet(index, typeDef, memo, visiting = new Set()) {
-    const key = goTypeIdentity(typeDef.name, typeDef.file);
-    if (memo.has(key)) return memo.get(key);
-    if (visiting.has(key) || typeDef.generics) return null;
-    visiting.add(key);
-    const methods = new Map();
-    const directNames = new Set();
-    const dir = require('path').dirname(typeDef.file || '');
-    for (const [name, defs] of index.symbols) {
-        const owned = defs.filter(candidate =>
-            !NON_CALLABLE_TYPES.has(candidate.type) &&
-            candidate.className === typeDef.name && candidate.file &&
-            require('path').dirname(candidate.file) === dir &&
-            candidate.type !== 'method');
-        for (const method of owned) {
-            const fingerprint = goMethodFingerprint(method);
-            if (!fingerprint) { visiting.delete(key); memo.set(key, null); return null; }
-            const previous = methods.get(name);
-            if (previous && previous.fingerprint !== fingerprint) {
-                visiting.delete(key); memo.set(key, null); return null;
-            }
-            if (!previous) methods.set(name, { fingerprint, defs: [method] });
-            else previous.defs.push(method);
-            directNames.add(name);
-        }
-    }
-    for (const rawParent of goEmbeddedTypes(index, typeDef)) {
-        if (rawParent.includes('.')) {
-            visiting.delete(key); memo.set(key, null); return null;
-        }
-        const parent = goTypeDefinition(index, rawParent.replace(/^\*/, ''), typeDef.file);
-        if (!parent) { visiting.delete(key); memo.set(key, null); return null; }
-        const promoted = goConcreteMethodSet(index, parent, memo, visiting);
-        if (!promoted) { visiting.delete(key); memo.set(key, null); return null; }
-        for (const [name, method] of promoted) {
-            // A direct method shadows a promoted one. Two promoted methods of
-            // the same name are ambiguous in Go; abstain instead of coupling.
-            if (methods.has(name)) {
-                if (directNames.has(name)) continue;
-                visiting.delete(key); memo.set(key, null); return null;
-            }
-            methods.set(name, method);
-        }
-    }
-    visiting.delete(key);
-    memo.set(key, methods);
-    return methods;
-}
-
-function goMethodSetSatisfies(methods, requirements) {
-    if (!methods || !requirements) return false;
-    for (const [name, requirement] of requirements) {
-        if (methods.get(name)?.fingerprint !== requirement.fingerprint) return false;
+    if (resolved.kind === 'type') {
+        if (!owner) return null;
+        const classes = resolved.classes || [];
+        if (classes.length === 0) return 'review';
+        return classes.some(cls => cls.name === String(owner).replace(/<.*$/, '')) ? 'edit' : null;
     }
-    return true;
+    return 'review';
 }
 
 function goMethodArityCompatible(def, argCount) {
@@ -1935,125 +2457,500 @@ function goSlotCoversMethodAmbiguity(index, name, slot, raw) {
         slot.memberIdentity.has(`${require('path').resolve(definition.file)}\0${definition.startLine}`));
 }
 
-/**
- * Compute the Go method/interface rename component containing the pinned
- * member. Go satisfaction is implicit, so this is a bipartite fixed point:
- * concrete types join interfaces whose complete method sets they satisfy,
- * and every satisfier of a joined interface joins the same compiler slot.
- */
-function goInterfaceRenameClosure(index, targetDef) {
-    if (!targetDef.className || goMethodFingerprint(targetDef) == null) return null;
-    const pathMod = require('path');
-    const interfaceMemo = new Map();
-    const methodMemo = new Map();
-    const interfaces = [];
-    for (const defs of index.symbols.values()) {
-        for (const candidate of defs) {
-            if (candidate.type !== 'interface') continue;
-            const requirements = goInterfaceRequirements(index, candidate, interfaceMemo);
-            const directTarget = goInterfaceMembers(index, candidate).find(member =>
-                member.name === targetDef.name &&
-                goMethodFingerprint(member) === goMethodFingerprint(targetDef));
-            if (requirements && directTarget) {
-                interfaces.push({
-                    key: `${candidate.file}\0${candidate.name}`,
-                    def: candidate,
-                    requirements,
-                    targetDefs: [directTarget],
-                });
-            }
-        }
-    }
-    if (interfaces.length === 0) return null;
+const IMPORT_STATEMENT_TYPES = new Set(['import_statement', 'import_from_statement',
+    'future_import_statement', 'use_declaration', 'import_declaration', 'using_directive', 'export_statement']);
 
-    const concreteByKey = new Map();
-    for (const definition of index.symbols.get(targetDef.name) || []) {
-        if (!definition.className || definition.type === 'method' ||
-            NON_CALLABLE_TYPES.has(definition.type)) continue;
-        const typeDef = goTypeDefinition(index, definition.className, definition.file);
-        if (!typeDef) continue;
-        const key = goTypeIdentity(typeDef.name, typeDef.file);
-        const node = concreteByKey.get(key) || {
-            key, def: typeDef, methods: goConcreteMethodSet(index, typeDef, methodMemo),
-            targetDefs: [],
-        };
-        node.targetDefs.push(definition);
-        concreteByKey.set(key, node);
+/** The first line of the import statement holding the token at
+ * line/column (1-based line, 0-based column), or `line` when none does. */
+function importStatementLine(index, filePath, line, column) {
+    const entry = index.files.get(filePath);
+    if (!entry || !Number.isInteger(column)) return line;
+    let tree;
+    try {
+        const content = index._readFile(filePath);
+        tree = index._getParsedTree?.(filePath, content, entry.language) ||
+            safeParse(getParser(entry.language), content);
+    } catch {
+        tree = null;
     }
+    let node = tree?.rootNode?.descendantForPosition({ row: line - 1, column });
+    while (node && !IMPORT_STATEMENT_TYPES.has(node.type)) node = node.parent;
+    return node ? node.startPosition.row + 1 : line;
+}
 
-    const startInterface = interfaces.find(node =>
-        node.def.file === targetDef.file && node.def.name === targetDef.className);
-    const startConcreteKey = goTypeIdentity(targetDef.className, targetDef.file);
-    if (!startInterface && !concreteByKey.has(startConcreteKey)) return null;
+/** Is a Go site file compiled under another build constraint than the
+ * pin's file (fix #400)? A file every build compiles is in every
+ * configuration. */
+function goOtherConfiguration(index, pinFile, siteFile) {
+    const { _goFileConstraint } = require('./callers');
+    const site = siteFile ? _goFileConstraint(index, siteFile) : '';
+    return !!site && site !== _goFileConstraint(index, pinFile);
+}
 
-    const joinedInterfaces = new Set(startInterface ? [startInterface.key] : []);
-    const joinedConcrete = new Set(startInterface ? [] : [startConcreteKey]);
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const interfaceNode of interfaces) {
-            for (const concrete of concreteByKey.values()) {
-                if (!goMethodSetSatisfies(concrete.methods, interfaceNode.requirements)) continue;
-                if (joinedInterfaces.has(interfaceNode.key) && !joinedConcrete.has(concrete.key)) {
-                    joinedConcrete.add(concrete.key); changed = true;
-                }
-                if (joinedConcrete.has(concrete.key) && !joinedInterfaces.has(interfaceNode.key)) {
-                    joinedInterfaces.add(interfaceNode.key); changed = true;
-                }
-            }
-        }
+/**
+ * fix #396: other external-linkage definitions of a C/C++ free function
+ * `def` in other files (same C++ namespace and parameter types, same
+ * language branch). `defines`: a declaration in the pin's identity group is
+ * in the definition's include closure (both define the declared function);
+ * `unrelated`: none is.
+ */
+function cLinkAlternatives(index, def, definitions) {
+    const none = { defines: [], unrelated: [] };
+    const language = index.files.get(def.file)?.language;
+    if (!langTraits(language)?.textualIncludes || def.className || def.receiver || def.isSignature ||
+        def.type !== 'function' || def.modifiers?.includes('static') || def.friendOf) return none;
+    const { _closeCallableIdentityGroup, _cFamilySignatureKey, _textualIncludeClosures } = require('./callers');
+    const { effectiveNamespace } = require('./cpp-scope');
+    const group = new Set(_closeCallableIdentityGroup(index, [def], definitions));
+    const prototypes = [...group].filter(member => member.isSignature);
+    const overloads = langTraits(language)?.hasArityOverloads;
+    const key = d => `${overloads ? effectiveNamespace(index, d) : ''}\0${overloads ? _cFamilySignatureKey(d) : ''}\0${d.languageBranch || ''}`;
+    const pinKey = key(def);
+    const out = { defines: [], unrelated: [] };
+    for (const other of definitions) {
+        if (other === def || group.has(other) || other.file === def.file || other.type !== 'function' ||
+            other.isSignature || other.className || other.receiver || other.friendOf ||
+            other.modifiers?.includes('static') || other.generatedByMacro ||
+            !langTraits(index.files.get(other.file)?.language)?.textualIncludes || key(other) !== pinKey) continue;
+        const closure = _textualIncludeClosures(index, other.file).all;
+        const declared = prototypes.some(prototype => prototype.file === other.file || closure.has(prototype.file));
+        (declared ? out.defines : out.unrelated).push(other);
     }
-    if (joinedInterfaces.size === 0) return null;
+    return out;
+}
 
-    const memberDefs = [];
-    const interfaceNames = new Set();
-    for (const node of interfaces) {
-        if (!joinedInterfaces.has(node.key)) continue;
-        interfaceNames.add(node.def.name);
-        memberDefs.push(...node.targetDefs);
-    }
-    for (const node of concreteByKey.values()) {
-        if (joinedConcrete.has(node.key)) memberDefs.push(...node.targetDefs);
-    }
-    const seen = new Set();
-    const uniqueMembers = memberDefs.filter(member => {
-        const key = `${pathMod.resolve(member.file)}\0${member.startLine}`;
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-    });
-    return {
-        interfaceNames,
-        memberDefs: uniqueMembers,
-        memberIdentity: new Set(uniqueMembers.map(member =>
-            `${pathMod.resolve(member.file)}\0${member.startLine}`)),
-    };
+// C: plain identifiers of one spelling at file scope name one entity
+// (no overloading, no namespaces).
+function cExternalReferenceLanguage(index, file) {
+    const traits = langTraits(index.files.get(file)?.language);
+    return !!traits?.textualIncludes && !traits.hasArityOverloads;
 }
 
-function plan(index, name, options = {}) {
-    index._beginOp();
-    try {
-    const definitions = index.symbols.get(name);
-    if (!definitions || definitions.length === 0) {
-        return { found: false, function: name };
-    }
+/**
+ * fix #396: where a file-scope C reference to NAME in another file than the
+ * pin resolves. The file's own definitions or declarations of the name that
+ * are not the pin decide first (a static function or object of its own);
+ * otherwise the external-linkage function the unit links is the pin when the
+ * link verdict keeps it and a declaration of it is visible ('edit'), several
+ * link candidates or no visible declaration review, another definition is
+ * not the pin.
+ */
+function cExternalReferenceVerdict(index, ref, def, pinIdentity, definitions) {
+    if (def.className || def.receiver || def.modifiers?.includes('static')) return null;
+    const own = (index.files.get(ref.file)?.symbols || []).filter(symbol => symbol.name === def.name);
+    if (own.some(symbol => !pinIdentity.has(symbol))) return null;
+    const { _textualLinkVerdict, _textualIncludeClosures } = require('./callers');
+    const verdict = _textualLinkVerdict(index, ref.file, [...pinIdentity], definitions, ref.line);
+    if (verdict === 'other') return null;
+    if (verdict && verdict.ambiguous) return 'review';
+    const { strong } = _textualIncludeClosures(index, ref.file);
+    const declared = own.length > 0 || [...pinIdentity].some(member => strong.has(member.file));
+    return declared ? 'edit' : 'review';
+}
 
-    const resolved = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
-    const def = resolved.def || definitions[0];
-    // BUG-BY: enrich types for typed-arrow-fn declarations.
-    const arrowTypes = extractArrowTypesFromVarDecl(index, def);
-    // Class target: the signature being planned is the CONSTRUCTOR's
-    // (fix #230, same rule as verify) — single-ctor classes only; with
-    // overloads the class def's own (empty) list stays, since plan cannot
-    // know which overload the user means.
-    const planLang = index.files.get(def.file)?.language;
-    const planCtorLists = _constructorParamLists(index, def, planLang);
-    const currentParams = (planCtorLists && planCtorLists.length === 1 && planCtorLists[0]) ||
-        (arrowTypes?.paramsStructured) || def.paramsStructured || [];
-    // BUG-BV: render with TS-correct param formatting (`opt?: number`).
-    const currentSignature = formatTypedSignature(def,
-        (planCtorLists && planCtorLists.length === 1)
-            ? { paramsStructured: currentParams }
+/**
+ * Type-reference completion of a type rename (fix #386). Every name token on
+ * the ground lines is decided by core/type-references.js; this merges the
+ * decisions into the plan's changes:
+ *   - edits join an existing token edit on the line, replace a manual
+ *     review item another pass left on a line whose tokens are all decided,
+ *     or become new reference edits;
+ *   - tokens the lookup cannot settle make the line a review item with
+ *     their reason (a mixed line keeps its certain edits and is flagged);
+ *   - a line holding the name outside every parsed token and outside
+ *     comments/strings (macro bodies, unparsed regions) is a review item;
+ *   - reference-review items of other passes on lines whose tokens provably
+ *     name something else are dropped, and unverified call candidates on
+ *     decided lines leave the band (claimed by the account instead).
+ */
+function applyTypeReferencePass(index, ctx) {
+    const { def, name, renameTo, changes, reviewItems, planUnverified } = ctx;
+    const { typeReferenceSites } = require('./type-references');
+    const { files } = typeReferenceSites(index, def, name, ctx.groundSet);
+    const decided = new Map(); // rel:line -> { abs, edited }
+    const reviewed = new Map(); // rel:line -> { abs, reason }
+    const stringEdited = new Set();
+    const target = `${def.relativePath || def.file}:${def.nameLine || def.startLine}`;
+    const reasonText = reason => String(reason || 'unresolved').replace(/-/g, ' ');
+    const special = change => change.contractDependency || change.templateDependency ||
+        change.editKind === 'example' || change.editKind === 'macro-expansion';
+    // Rebuild a line edit from code-unit token columns.
+    const lineEdit = (raw, columns) => {
+        const sorted = [...columns].sort((a, b) => b - a);
+        let renamed = raw;
+        for (const column of sorted) {
+            if (renamed.slice(column, column + name.length) !== name) continue;
+            renamed = renamed.slice(0, column) + renameTo + renamed.slice(column + name.length);
+        }
+        return {
+            source: raw.trim(), renamed: renamed.trim(), count: sorted.length,
+            columns: sorted, rawSource: raw, oldName: name, newName: renameTo,
+        };
+    };
+    for (const [abs, info] of files) {
+        const rel = info.relativePath;
+        const fileLines = index._getFileLines(abs);
+        for (const [line, slot] of [...info.lines].sort((a, b) => a[0] - b[0])) {
+            const key = `${rel}:${line}`;
+            const at = changes.findIndex(change => change.file === rel && change.line === line);
+            const existing = at >= 0 ? changes[at] : null;
+            const raw = fileLines[line - 1] || '';
+            const source = raw.trim();
+            if (slot.tokens === 0 && slot.reviews.length === 0) {
+                if (slot.text && !slot.macroBody) continue;
+                if (existing) continue;
+                const reason = slot.unparsedReason || (slot.macroBody ? 'macro-body' : 'unparsed-occurrence');
+                reviewed.set(key, { abs, reason });
+                changes.push({
+                    file: rel,
+                    line,
+                    expression: source,
+                    suggestion: `"${name}" appears here outside the parsed code (${reasonText(reason)}); ` +
+                        `rename it if it names ${name} at ${target}`,
+                    needsReview: true,
+                    reviewReason: reason,
+                    editKind: 'reference',
+                });
+                continue;
+            }
+            const units = columns => columns.map(column => tokenColumn(raw, column, name))
+                .filter(Number.isInteger);
+            const editUnits = units(slot.edits);
+            const skipUnits = new Set(units(slot.skipColumns || []));
+            const reviewList = slot.reviews.map(review => ({
+                ...review,
+                unit: Number.isInteger(review.column) ? tokenColumn(raw, review.column, name) : null,
+            }));
+            // An existing edit of this line: the type lookup decides every
+            // token spelling the name. A token the other pass edits and the
+            // lookup cannot settle stays edited and is flagged; one the
+            // lookup proves to name another declaration (or a macro argument
+            // its replacement list uses in another role) leaves the edit,
+            // unless the edit is the pin's own declaration or one a
+            // dedicated pass proved.
+            if (existing && existing.newExpression !== undefined && !special(existing)) {
+                const prior = existing._edit && existing._edit.rawSource === raw ? existing._edit.columns
+                    : renameIdentifierTokens(index, abs, line, name, renameTo).columns || [];
+                const trusted = (existing.isDefinition || existing._evidence) &&
+                    !reviewList.some(review => review.reason === 'macro-argument-other-use');
+                const hardUnits = new Set(reviewList.filter(review => review.reason === 'macro-argument-other-use')
+                    .map(review => review.unit).filter(Number.isInteger));
+                const keep = trusted ? prior
+                    : prior.filter(column => !skipUnits.has(column) && !hardUnits.has(column));
+                const final = new Set([...keep, ...editUnits]);
+                const open = reviewList.filter(review => review.unit == null || !(trusted && final.has(review.unit)));
+                if (final.size === 0) {
+                    if (open.length === 0) {
+                        changes.splice(at, 1);
+                        decided.set(key, { abs, edited: false });
+                        continue;
+                    }
+                    delete existing.newExpression;
+                    existing.needsReview = true;
+                    existing.reviewReason = open[0].reason;
+                    existing.suggestion = `Verify whether "${name}" here names ${name} at ${target} ` +
+                        `(${reasonText(open[0].reason)}) and rename it if it does`;
+                    reviewed.set(key, { abs, reason: open[0].reason });
+                    continue;
+                }
+                const edit = lineEdit(raw, final);
+                const previous = existing.newExpression;
+                existing.expression = edit.source;
+                existing.newExpression = edit.renamed;
+                if (typeof existing.suggestion === 'string' && previous && existing.suggestion.includes(previous)) {
+                    existing.suggestion = existing.suggestion.replace(previous, edit.renamed);
+                }
+                tagTokenEdit(existing, edit);
+                if (open.length > 0) {
+                    existing.needsReview = true;
+                    existing.reviewReason = existing.reviewReason || open[0].reason;
+                    existing.suggestion += `; verify the "${name}" token(s) UCN could not resolve ` +
+                        `(${reasonText(open[0].reason)})`;
+                    reviewed.set(key, { abs, reason: open[0].reason });
+                } else {
+                    // A manual flag another pass left because it could not
+                    // place a token is settled once every token is decided.
+                    if (existing.needsReview && !existing.reviewReason &&
+                        final.size + skipUnits.size >= slot.tokens) delete existing.needsReview;
+                    decided.set(key, { abs, edited: true });
+                    if (slot.stringAnnotation) stringEdited.add(key);
+                }
+                continue;
+            }
+            const certain = reviewList.length === 0;
+            const edit = editUnits.length > 0 ? lineEdit(raw, editUnits) : null;
+            const hasEdit = !!edit && edit.renamed !== edit.source;
+            if (certain) {
+                decided.set(key, { abs, edited: hasEdit });
+                if (slot.stringAnnotation && hasEdit) stringEdited.add(key);
+            } else {
+                reviewed.set(key, { abs, reason: reviewList[0].reason });
+            }
+            const reviewNote = certain ? '' : `; verify the "${name}" token(s) UCN could not resolve ` +
+                `(${reasonText(reviewList[0].reason)})`;
+            if (existing) {
+                // A manual review item another pass left on this line.
+                if (existing.newExpression === undefined && existing.needsReview && !special(existing)) {
+                    if (certain && hasEdit) {
+                        const kind = existing.editKind === 'call' ? 'call' : 'reference';
+                        for (const field of Object.keys(existing)) delete existing[field];
+                        Object.assign(existing, {
+                            file: rel,
+                            line,
+                            expression: edit.source,
+                            suggestion: `${kind === 'call' ? 'Rename to' : 'Update type reference'}: ${edit.renamed}`,
+                            newExpression: edit.renamed,
+                            editKind: kind,
+                        });
+                        tagTokenEdit(existing, edit);
+                    } else if (certain) {
+                        // Every token here provably names another declaration.
+                        changes.splice(at, 1);
+                    } else if (typeof existing.suggestion === 'string' && !existing.suggestion.includes(reviewNote)) {
+                        existing.reviewReason = existing.reviewReason || reviewList[0].reason;
+                        existing.suggestion += reviewNote;
+                    }
+                }
+                continue;
+            }
+            if (hasEdit) {
+                changes.push(tagTokenEdit({
+                    file: rel,
+                    line,
+                    expression: edit.source,
+                    suggestion: `Update type reference: ${edit.renamed}${reviewNote}`,
+                    newExpression: edit.renamed,
+                    editKind: 'reference',
+                    ...(!certain && { needsReview: true, reviewReason: reviewList[0].reason }),
+                }, edit));
+            } else if (!certain) {
+                changes.push({
+                    file: rel,
+                    line,
+                    expression: source,
+                    suggestion: `Verify whether "${name}" here names ${name} at ${target} ` +
+                        `(${reasonText(reviewList[0].reason)}) and rename it if it does`,
+                    needsReview: true,
+                    reviewReason: reviewList[0].reason,
+                    editKind: 'reference',
+                });
+            }
+        }
+    }
+    // C# applies `XAttribute` as `[X]` (fix #386).
+    const { csharpAttributeShortSites } = require('./type-references');
+    const suffix = 'Attribute';
+    for (const site of csharpAttributeShortSites(index, def, name)) {
+        if (site.verdict === 'no') continue;
+        const short = name.slice(0, -suffix.length);
+        const newShort = renameTo.endsWith(suffix) && renameTo.length > suffix.length
+            ? renameTo.slice(0, -suffix.length) : renameTo;
+        const raw = index._getFileLines(site.file)[site.line - 1] || '';
+        const column = tokenColumn(raw, site.column, short);
+        const existing = changes.find(change => change.file === site.relativePath && change.line === site.line);
+        if (site.verdict === 'yes' && Number.isInteger(column) && !existing) {
+            const renamed = raw.slice(0, column) + newShort + raw.slice(column + short.length);
+            changes.push({
+                file: site.relativePath,
+                line: site.line,
+                expression: raw.trim(),
+                suggestion: `Update attribute usage: ${renamed.trim()}`,
+                newExpression: renamed.trim(),
+                editKind: 'reference',
+            });
+            continue;
+        }
+        const reason = site.verdict === 'yes' ? 'attribute-short-name' : site.reason || 'attribute-short-name';
+        if (existing) {
+            existing.needsReview = true;
+            existing.reviewReason = existing.reviewReason || reason;
+            continue;
+        }
+        changes.push({
+            file: site.relativePath,
+            line: site.line,
+            expression: raw.trim(),
+            suggestion: `Verify whether [${short}] applies ${name} at ${target} and rename it to [${newShort}] if it does`,
+            needsReview: true,
+            reviewReason: reason,
+            editKind: 'reference',
+        });
+    }
+    // String annotations the pass edited are no longer text-only review.
+    if (stringEdited.size > 0) {
+        for (let i = reviewItems.length - 1; i >= 0; i--) {
+            const item = reviewItems[i];
+            if (item.textDependency && stringEdited.has(`${item.file}:${item.line}`)) reviewItems.splice(i, 1);
+        }
+    }
+    // Unverified call candidates on decided lines are settled.
+    const removed = [];
+    const kept = [];
+    for (const site of planUnverified) {
+        const key = `${site.file}:${site.line}`;
+        if (decided.has(key)) removed.push(site);
+        else kept.push(site);
+    }
+    if (removed.length > 0) {
+        planUnverified.length = 0;
+        planUnverified.push(...kept);
+    }
+    return { decided, reviewed, removed };
+}
+
+/**
+ * Object identity of a one-hop member-assignment definition (fix #359, ky-
+ * measured): `response.json = async () => {...}` patches a property of the
+ * object `response` names. It is a project declaration only when that object
+ * is itself a project binding: a module-scope declaration or import of the
+ * file (`const api = {}; api.get = ...`, `exports.h = ...`). A receiver bound
+ * inside an enclosing function (parameter or local) or not declared at all
+ * (a runtime global) names an object whose property contract belongs to its
+ * own type, typically external (a Fetch `Response`); renaming it is not a
+ * mechanical project rename. Returns 'module' | 'local' | 'external', or null
+ * when the definition is not a receiver-named member assignment.
+ */
+const FUNCTION_SCOPE_TYPES = new Set([
+    'function_declaration', 'function_expression', 'function', 'arrow_function',
+    'method_definition', 'generator_function', 'generator_function_declaration',
+]);
+function memberAssignmentOwnerScope(index, def) {
+    if (!def || !def.memberAssigned || def.className || !def.assignedReceiver) return null;
+    const receiver = def.assignedReceiver;
+    if (receiver === 'exports' || receiver === 'module') return 'module';
+    const language = index.files.get(def.file)?.language;
+    const parser = language && getParser(language);
+    if (!parser) return null;
+    const content = index._readFile(def.file);
+    const tree = index._getParsedTree?.(def.file, content, language) || safeParse(parser, content);
+    if (!tree) return null;
+    const row = def.startLine - 1;
+    // The assignment node at the definition line.
+    let assignment = null;
+    const stack = [tree.rootNode];
+    while (stack.length > 0 && !assignment) {
+        const node = stack.pop();
+        if (node.endPosition.row < row || node.startPosition.row > row) continue;
+        if (node.type === 'assignment_expression' && node.startPosition.row === row) {
+            const left = node.childForFieldName('left');
+            const obj = left && left.type === 'member_expression'
+                ? left.childForFieldName('object') : null;
+            const prop = left && left.childForFieldName('property');
+            if (obj && obj.type === 'identifier' && obj.text === receiver &&
+                prop && prop.text === def.name) {
+                assignment = node;
+                break;
+            }
+        }
+        stack.push(...(node.namedChildren || []));
+    }
+    if (!assignment) return null;
+    const declaresName = (node) => {
+        // Binding identifiers introduced by a pattern / declarator subtree.
+        const out = [];
+        const walk = (n) => {
+            if (!n) return;
+            if ((n.type === 'identifier' || n.type === 'shorthand_property_identifier_pattern') &&
+                n.text === receiver) { out.push(n); return; }
+            if (n.type === 'default_value' || n.type === 'assignment_pattern') {
+                walk(n.childForFieldName('left'));
+                return;
+            }
+            for (const c of n.namedChildren || []) {
+                if (c.type === 'type_annotation') continue;
+                walk(c);
+            }
+        };
+        walk(node);
+        return out.length > 0;
+    };
+    const scopeDeclares = (scope) => {
+        if (FUNCTION_SCOPE_TYPES.has(scope.type)) {
+            const params = scope.childForFieldName('parameters') ||
+                scope.childForFieldName('parameter');
+            if (params && declaresName(params)) return true;
+        }
+        const body = FUNCTION_SCOPE_TYPES.has(scope.type)
+            ? scope.childForFieldName('body') : scope;
+        if (!body) return false;
+        const stmts = [body];
+        while (stmts.length > 0) {
+            const n = stmts.pop();
+            for (const c of n.namedChildren || []) {
+                if (FUNCTION_SCOPE_TYPES.has(c.type) || c.type === 'class_declaration' ||
+                    c.type === 'class') {
+                    const nm = c.childForFieldName('name');
+                    if (nm && nm.text === receiver && c.type !== 'function_expression' &&
+                        c.type !== 'arrow_function' && c.type !== 'class') return true;
+                    continue;
+                }
+                if (c.type === 'variable_declarator') {
+                    if (declaresName(c.childForFieldName('name'))) return true;
+                    continue;
+                }
+                if (c.type === 'import_statement') {
+                    if (declaresName(c.namedChildren.find(x => x.type === 'import_clause'))) return true;
+                    continue;
+                }
+                if (c.type === 'catch_clause') {
+                    if (declaresName(c.childForFieldName('parameter'))) return true;
+                }
+                if (c.type === 'for_in_statement') {
+                    if (declaresName(c.childForFieldName('left'))) return true;
+                }
+                stmts.push(c);
+            }
+        }
+        return false;
+    };
+    for (let scope = assignment.parent; scope; scope = scope.parent) {
+        if (FUNCTION_SCOPE_TYPES.has(scope.type)) {
+            if (scopeDeclares(scope)) return 'local';
+        } else if (scope.type === 'program') {
+            return scopeDeclares(scope) ? 'module' : 'external';
+        }
+    }
+    return 'external';
+}
+
+function plan(index, name, options = {}) {
+    index._beginOp();
+    // Every slot member of a rename is swept over the same files: their call
+    // sites are analyzed on one tree per file for the whole plan (fix #395).
+    const ownsTreeCache = !index._treeCache;
+    if (ownsTreeCache) index._treeCache = new Map();
+    try {
+    const definitions = index.symbols.get(name);
+    if (!definitions || definitions.length === 0) {
+        return { found: false, function: name };
+    }
+
+    const resolved = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
+    let def = resolved.def || definitions[0];
+    // A constructor or destructor carries its class's name (Java, C#, C++):
+    // renaming it is renaming the class (fix #386).
+    // (A C# member can never carry its type's name except the finalizer.)
+    if (options.renameTo && def.className === def.name && !isTypeRenamePin(def) &&
+        (def.type === 'constructor' || def.memberType === 'constructor' ||
+            (def.type === 'method' && index.files.get(def.file)?.language === 'csharp'))) {
+        const owner = definitions.find(d => isTypeRenamePin(d) && d.file === def.file &&
+            d.startLine <= def.startLine && d.endLine >= def.endLine);
+        if (owner) def = owner;
+    }
+    // BUG-BY: enrich types for typed-arrow-fn declarations.
+    const arrowTypes = extractArrowTypesFromVarDecl(index, def);
+    // Class target: the signature being planned is the CONSTRUCTOR's
+    // (fix #230, same rule as verify) — single-ctor classes only; with
+    // overloads the class def's own (empty) list stays, since plan cannot
+    // know which overload the user means.
+    const planLang = index.files.get(def.file)?.language;
+    const planCtorLists = _constructorParamLists(index, def, planLang);
+    const currentParams = (planCtorLists && planCtorLists.length === 1 && planCtorLists[0]) ||
+        (arrowTypes?.paramsStructured) || def.paramsStructured || [];
+    // BUG-BV: render with TS-correct param formatting (`opt?: number`).
+    const currentSignature = formatTypedSignature(def,
+        (planCtorLists && planCtorLists.length === 1)
+            ? { paramsStructured: currentParams }
             : arrowTypes ? {
                 paramsStructured: arrowTypes.paramsStructured,
                 returnType: arrowTypes.returnType
@@ -2063,8 +2960,13 @@ function plan(index, name, options = {}) {
     // run contractedCallerSweep (v4 tiered contract), so plan and verify stay
     // in lock-step by construction. Unverified candidates are NOT planned
     // (they may target another symbol) but stay visible with reasons.
-    const { sites: planCallSites, unverifiedSites: planUnverified, account: planAccount,
-        groundSet: planGroundSet } = computePlanCallSites(index, name, def);
+    const { sites: planCallSites, unverifiedSites: planUnverified, account: pinAccount,
+        groundSet: planGroundSet, accountParts: planAccountParts } = computePlanCallSites(index, name, def,
+        { analyzeArgs: !options.renameTo });
+    let planAccount = pinAccount;
+    // Call sites a slot member's sweep contributed to this plan (fix #376):
+    // the plan's ACCOUNT is rebuilt over the same sites it lists.
+    const slotAccountSites = [];
     const impactScopeWarning = computePlanScopeWarning(index, name, def, options);
 
     // Reject ambiguous multi-op invocations rather than silently coalescing.
@@ -2110,6 +3012,12 @@ function plan(index, name, options = {}) {
     let operation = null;
     let changes = [];
     const reviewItems = [];
+    // Contract membership (fix #360): project slot roots the rename closed
+    // over, and Go satisfaction sites the closure could not complete.
+    const contractRootDefs = [];
+    const goContractReviews = [];
+    // Hierarchy slot closure of a rename (fix #376), for the contract check.
+    let hierarchySlot = null;
     let unchangedSites = 0;
 
     if (options.addParam) {
@@ -2229,7 +3137,8 @@ function plan(index, name, options = {}) {
         const lang = fileEntry?.language;
         let selfOffset = 0;
         const planSelfParams = langTraits(lang)?.selfParam;
-        if (planSelfParams && currentParams.length > 0 && planSelfParams.includes(currentParams[0].name)) {
+        if (planSelfParams && currentParams.length > 0 && planSelfParams.includes(
+            String(currentParams[0].name || '').replace(/'[A-Za-z_]\w*\s*/g, '').trim())) {
             selfOffset = 1;
         }
         const callerArgIndex = paramIndex - selfOffset;
@@ -2266,6 +3175,8 @@ function plan(index, name, options = {}) {
         }
     }
 
+    // The rename's usage records, shared with the method-group pass below.
+    let planUsages = null;
     if (options.renameTo) {
         operation = 'rename';
         newSignature = currentSignature.replace(new RegExp('\\b' + escapeRegExp(name) + '\\b'), options.renameTo);
@@ -2280,9 +3191,95 @@ function plan(index, name, options = {}) {
         // exact token on the SAME line (`a.Run() || b.Run() || other.Run()`)
         // and update one edit instead of losing it to line-level deduplication.
         const emittedRenameCalls = new Map();
+        // A definition edit on a line another change already edits joins
+        // that change's token edit instead of being dropped (fix #376).
+        const lineTaken = (member, rel, line) => {
+            const existing = changes.find(change => change.file === rel && change.line === line);
+            if (!existing) return false;
+            if (existing.newExpression !== undefined && existing._edit) {
+                const edit = renameIdentifierTokens(index, member.file, line, name,
+                    options.renameTo, null, null, { definitionNameOnly: true, definition: member });
+                if (edit.renamed !== edit.source && mergeTokenEdit(existing, edit)) {
+                    existing.isDefinition = true;
+                    existing.editKind = 'definition';
+                    existing.suggestion = `Update definition: ${existing.newExpression}`;
+                }
+            }
+            return true;
+        };
+        const emittedPatternKeys = new Set();
+        const emitPatternKeyEdit = (absoluteFile, relativeFile, pattern) => {
+            const key = `${relativeFile}:${pattern.line}:${pattern.column}`;
+            if (emittedPatternKeys.has(key)) return;
+            emittedPatternKeys.add(key);
+            const replacement = pattern.shorthand
+                ? `${options.renameTo}: ${pattern.local}` : options.renameTo;
+            const edit = renameIdentifierTokens(index, absoluteFile, pattern.line, name,
+                replacement, [pattern.column], 1);
+            if (edit.renamed === edit.source) {
+                if (!reviewItems.some(item => item.file === relativeFile && item.line === pattern.line)) {
+                    reviewItems.push({
+                        file: relativeFile,
+                        line: pattern.line,
+                        expression: edit.source,
+                        suggestion: `Rename the destructured property "${name}" to "${options.renameTo}" ` +
+                            'manually, keeping the local binding',
+                        needsReview: true,
+                        editKind: 'reference',
+                    });
+                }
+                return;
+            }
+            const concrete = tagTokenEdit({
+                file: relativeFile,
+                line: pattern.line,
+                expression: edit.source,
+                suggestion: `Rename the destructured property: ${edit.renamed}`,
+                newExpression: edit.renamed,
+                editKind: 'reference',
+            }, edit);
+            const lineOwner = changes.find(change => change.file === relativeFile &&
+                change.line === pattern.line && change.newExpression !== undefined && change._edit);
+            if (!lineOwner || !mergeTokenEdit(lineOwner, edit)) changes.push(concrete);
+        };
         const emitRenameCallSites = (siteList) => {
         const touched = new Set();
         for (const incoming of siteList) {
+            // A target-typed `new(..)` spells no name: the type written at
+            // its declaration site is what the rename edits (fix #393).
+            if (incoming.targetTyped) continue;
+            // A call of a name destructured from the member (`const { run }
+            // = make(); run()`) spells the member at the pattern key (fix
+            // #397): the key is renamed and the local binding kept
+            // (`{ run }` -> `{ runZ: run }`), so the call line is unchanged.
+            if (incoming.destructured) {
+                emitPatternKeyEdit(incoming.absoluteFile || incoming.file, incoming.file, incoming.destructured);
+                continue;
+            }
+            // A call spelled by an aliased import's local name keeps it; the
+            // import's source side and the export chain carry the rename.
+            if (incoming.importAliasSpelling) continue;
+            // A pasted call target (`fs__##lc` with `XX(STAT, stat)`) is
+            // not spelled on the invocation line: no token edit exists here,
+            // and the rename is incomplete until the macro's arguments or
+            // replacement list change with it (fix #362).
+            if (incoming.macroExpansion?.origin === 'paste') {
+                if (!reviewItems.some(item => item.file === incoming.file && item.line === incoming.line)) {
+                    reviewItems.push({
+                        file: incoming.file,
+                        line: incoming.line,
+                        expression: incoming.expression,
+                        suggestion: `Macro ${incoming.macroExpansion.macro} builds "${name}" by token pasting at this ` +
+                            'invocation; change the macro arguments or definition so the expansion spells ' +
+                            `"${options.renameTo}"`,
+                        needsReview: true,
+                        templateDependency: true,
+                        reviewReason: 'macro-expansion',
+                        editKind: 'macro-expansion',
+                    });
+                }
+                continue;
+            }
             const lineKey = `${incoming.file}:${incoming.line}`;
             const site = emittedRenameCalls.get(lineKey) || {
                 file: incoming.file,
@@ -2297,7 +3294,10 @@ function plan(index, name, options = {}) {
             };
             if (site.calledAs !== incoming.calledAs) site.calledAs = null;
             site.callCount++;
-            if (Number.isInteger(incoming.column)) site.columns.push(incoming.column);
+            const column = Number.isInteger(incoming.column) ? incoming.column
+                : callTokenColumn(index, incoming.absoluteFile || incoming.file, incoming.siteRange,
+                    name, incoming.line);
+            if (Number.isInteger(column)) site.columns.push(column);
             else site.missingColumn = true;
             emittedRenameCalls.set(lineKey, site);
             touched.add(lineKey);
@@ -2308,7 +3308,9 @@ function plan(index, name, options = {}) {
             // `{ old: local }`). The caller engine carries the authored name
             // in calledAs; that token must remain unchanged while the import's
             // source-side identifier is edited below.
-            if (site.calledAs && site.calledAs !== name) continue;
+            // `calledAs: 'bound'` labels a bind/call/apply site
+            // (`obj.m.bind(obj)`), which spells the name (fix #397).
+            if (site.calledAs && site.calledAs !== name && site.calledAs !== 'bound') continue;
             let edit = renameIdentifierTokens(index,
                 site.absoluteFile || site.file, site.line, name,
                 options.renameTo, site.missingColumn ? [] : site.columns,
@@ -2334,7 +3336,7 @@ function plan(index, name, options = {}) {
                 // Missing parser columns mean UCN can prove the edit is
                 // required but cannot safely synthesize it. Never fall back
                 // to whole-line regex replacement.
-                if (site.missingColumn) {
+                if (site.missingColumn && site.calledAs !== 'bound') {
                     const manual = {
                         file: site.file,
                         line: site.line,
@@ -2353,17 +3355,25 @@ function plan(index, name, options = {}) {
                 }
                 continue;
             }
-            const concrete = {
+            const concrete = tagTokenEdit({
                 file: site.file,
                 line: site.line,
                 expression: edit.source,
                 suggestion: `Rename to: ${newExpression}`,
                 newExpression,
                 editKind: 'call',
-            };
-            if (site.change) {
+            }, edit);
+            // Another pass already edits this line (a slot member's
+            // one-line declaration): add the call tokens to that edit.
+            const lineOwner = site.mergedInto || (!site.change && changes.find(change =>
+                change.file === site.file && change.line === site.line &&
+                change.newExpression !== undefined && change._edit));
+            if (lineOwner && mergeTokenEdit(lineOwner, edit)) {
+                site.mergedInto = lineOwner;
+            } else if (site.change) {
                 for (const key of Object.keys(site.change)) delete site.change[key];
                 Object.assign(site.change, concrete);
+                tagTokenEdit(site.change, edit);
             } else {
                 site.change = concrete;
                 changes.push(concrete);
@@ -2394,22 +3404,95 @@ function plan(index, name, options = {}) {
             includeTests: true,
             internalEvidence: true,
         });
+        planUsages = usages;
         const importUsages = usages.filter(u => u.usageType === 'import' && !u.isDefinition);
+        // Import identity (fix #359, starlette-measured): an import binds a
+        // module-level name. A MEMBER pin (method/field of a class, struct,
+        // trait or impl) is never what `import json` binds, so renaming
+        // Request.json must not rewrite the stdlib `import json` in its own
+        // file. Languages whose bare names can denote members through a
+        // member import (Java `import static a.D.head`) keep the edit only
+        // when the binding provably reaches the pinned file.
+        const pinIsMember = !!def.className && !!(def.isMethod || def.memberType);
+        const memberImportable = pinIsMember &&
+            !!langTraits(planLang)?.bareCallReachesMethods;
+        const importMayBindPin = (file) => {
+            // A source-side import token need not be exposed by its importing
+            // file: `from core import transform as xf` binds only `xf` there.
+            // The statement's source module decides ownership below.
+            if (!pinIsMember) return true;
+            return memberImportable &&
+                _nameBindingReaches(index, file, name, renameTargetFiles) === 'yes';
+        };
+        // Import SOURCE identity (fix #376): an import statement's source-side
+        // name is edited only when the module it imports from binds the
+        // renamed definition. `import { flag as baseFlag } from './utils'`
+        // inside the pin's own file imports ANOTHER module's flag; a module
+        // never imports its own definition, so in the pin's file an import of
+        // the name from any other (or unresolvable) module is never this
+        // rename's import.
+        const importSourceBindsPin = (filePath, line, column = null) => {
+            const fileEntry = index.files.get(filePath);
+            // Bindings carry their statement's first line: a token on a later
+            // line of a multi-line import (`import {\n  a,\n} from './m'`,
+            // `from m import (\n    a,\n)`) belongs to that statement (fix #400).
+            const onLine = (fileEntry?.importBindings || []).some(binding => binding.line === line &&
+                (binding.name === name || binding.alias === name));
+            const statementLine = onLine ? line : importStatementLine(index, filePath, line, column);
+            const bindings = (fileEntry?.importBindings || []).filter(binding =>
+                (binding.line === line || binding.line === statementLine) &&
+                binding.name === name && binding.module);
+            // The name is only the LOCAL alias of another imported name on
+            // this line (`import { g as f }`, `const f = require('m').g`,
+            // fix #397): an import alias keeps its local name, and the
+            // source-side name is not the renamed definition's.
+            if (bindings.length === 0 && (fileEntry?.importBindings || []).some(binding =>
+                (binding.line === line || binding.line === statementLine) &&
+                binding.alias === name && binding.name !== name)) return false;
+            if (bindings.length === 0) return true;
+            return bindings.some(binding => {
+                const rel = fileEntry.moduleResolved?.[binding.module];
+                const abs = rel ? (require('path').isAbsolute(rel) ? rel
+                    : require('path').join(index.root, rel)) : null;
+                // An import from a module outside the project (`const parse =
+                // require('parseurl')`, fix #397) binds that module's value,
+                // never the renamed definition; a resolver gap keeps the edit.
+                if (!abs && !require('./callers')._unresolvedModuleIsGap(index, binding.module, binding)) return false;
+                if (!abs) return filePath !== def.file;
+                if (abs === filePath) return false;
+                // A module binding the name through one alternative of a
+                // configuration item (fix #398F) keeps its item name: the
+                // importer's token names the item, not the renamed pin.
+                const verdict = _nameBindingReaches(index, abs, name, renameTargetFiles, 4,
+                    { configurationVerdict: true });
+                return verdict !== 'no' && verdict !== 'configuration';
+            });
+        };
+        // An unaliased import that is one alternative of a configuration
+        // item in its own scope (fix #398F: `try: from ._speedups import f` /
+        // `except ImportError: def f`) keeps the item's local name.
+        const importKeepsItemName = (filePath, line) => {
+            const { itemsNamed } = require('./configuration-items');
+            return itemsNamed(index, filePath, name).some(item =>
+                item.sites.some(site => site.kind === 'import' && site.line === line));
+        };
         for (const imp of importUsages) {
             // Skip if already covered by a call site change in the same file:line
             const alreadyCovered = changes.some(c =>
                 c.file === (imp.relativePath || imp.file) && c.line === imp.line
             );
             if (alreadyCovered) continue;
-            if (imp.file && def.file &&
-                _nameBindingReaches(index, imp.file, name, renameTargetFiles) === 'no') {
-                continue;
-            }
+            // The token is the importer's own local alias (fix #397): an
+            // import alias keeps its local name.
+            if (imp.importAlias) continue;
+            if (imp.file && def.file && !importMayBindPin(imp.file)) continue;
+            if (imp.file && !importSourceBindsPin(imp.file, imp.line, imp.column)) continue;
             const edit = renameIdentifierTokens(index, imp.file,
-                imp.line, name, options.renameTo);
+                imp.line, name, imp.file && importKeepsItemName(imp.file, imp.line)
+                    ? `${options.renameTo} as ${name}` : options.renameTo);
             const newImport = edit.renamed;
             if (newImport === edit.source) continue;
-            changes.push({
+            changes.push(tagTokenEdit({
                 file: imp.relativePath || imp.file,
                 line: imp.line,
                 expression: edit.source,
@@ -2417,7 +3500,7 @@ function plan(index, name, options = {}) {
                 newExpression: newImport,
                 isImport: true,
                 editKind: 'import',
-            });
+            }, edit));
         }
 
         // Renamed CJS/Python imports are intentionally surfaced as reference
@@ -2429,8 +3512,8 @@ function plan(index, name, options = {}) {
                     .find(alias => alias.original === binding.name)?.local;
                 if (binding.name !== name || !localAlias ||
                     localAlias === name || !binding.line) continue;
-                if (_nameBindingReaches(index, filePath, name,
-                    renameTargetFiles) === 'no') continue;
+                if (!importMayBindPin(filePath)) continue;
+                if (!importSourceBindsPin(filePath, binding.line)) continue;
                 const rel = fileEntry.relativePath || filePath;
                 if (changes.some(change =>
                     change.file === rel && change.line === binding.line)) continue;
@@ -2485,18 +3568,27 @@ function plan(index, name, options = {}) {
                 const pinnedAtExportLine = defsAtExportLine.some(d =>
                     d.file === def.file && d.startLine === def.startLine);
                 if (defsAtExportLine.length > 0 && !pinnedAtExportLine) continue;
+                // A member pin's export surface is its own declaration line
+                // only; a same-named module-level export belongs to another
+                // binding (fix #359).
+                if (pinIsMember && !pinnedAtExportLine) continue;
                 const exportFile = targetEntry.relativePath || exportPath;
                 if (changes.some(change =>
                     change.file === exportFile && change.line === exported.line)) {
                     continue;
                 }
+                // The pinned definition's own line is an export surface of
+                // THAT declaration (`export function head(head: string)`):
+                // rename only the declaration's name token (fix #359).
                 const edit = renameIdentifierTokens(index, exportPath,
-                    exported.line, name, options.renameTo);
+                    exported.line, name, options.renameTo, null, null,
+                    pinnedAtExportLine
+                        ? { definitionNameOnly: true, definition: def } : {});
                 const sourceLine = edit.source;
                 const occurrences = edit.count;
                 const newExpression = edit.renamed;
                 if (newExpression === sourceLine) continue;
-                changes.push({
+                changes.push(tagTokenEdit({
                     file: exportFile,
                     line: exported.line,
                     expression: sourceLine,
@@ -2505,7 +3597,7 @@ function plan(index, name, options = {}) {
                     isExport: true,
                     editKind: 'export',
                     ...(occurrences > 1 && { needsReview: true }),
-                });
+                }, edit));
             }
         }
 
@@ -2594,82 +3686,290 @@ function plan(index, name, options = {}) {
                 if (member === def) continue;
                 const line = member.nameLine || member.startLine;
                 const rel = member.relativePath || member.file;
-                if (changes.some(change =>
-                    change.file === rel && change.line === line)) continue;
+                if (lineTaken(member, rel, line)) continue;
                 const edit = renameIdentifierTokens(index, member.file,
                     line, name, options.renameTo,
-                    null, null, { definitionNameOnly: true });
+                    null, null, { definitionNameOnly: true, definition: member });
                 if (edit.renamed === edit.source) continue;
-                changes.push({
+                changes.push(tagTokenEdit({
                     file: rel,
                     line,
                     expression: edit.source,
-                    suggestion: `Update overload signature: ${edit.renamed}`,
+                    suggestion: langTraits(index.files.get(member.file)?.language)?.textualIncludes
+                        ? `Update declaration: ${edit.renamed}`
+                        : isAccessorDefinition(member) && isAccessorDefinition(def)
+                        ? `Update accessor: ${edit.renamed}`
+                        : `Update overload signature: ${edit.renamed}`,
                     newExpression: edit.renamed,
                     isDefinition: true,
                     editKind: 'definition',
-                });
+                }, edit));
+            }
+        }
+
+        // Configuration alternatives (fix #376): in a language where a
+        // definition cannot be repeated in one scope except under
+        // conditional compilation (traits.conditionalDefinitions: Rust
+        // `#[cfg]`, C/C++/C# `#if`), a same-file definition of the same name,
+        // owner and signature is the SAME item in another build
+        // configuration. Only one is compiled at a time, so the caller engine
+        // binds calls to one of them; the rename must change every
+        // alternative and every alternative's call sites.
+        const conditionalStyle = langTraits(planLang)?.conditionalDefinitions;
+        // Other external definitions of a C/C++ free function in other files
+        // (fix #396: platform variants `net_open` in net.c and net_win.c):
+        // each defines the function its shared declaration declares, so the
+        // rename changes them all; one no shared declaration ties to the pin
+        // (a separate program's own definition) is a review item.
+        const linkAlternatives = cLinkAlternatives(index, def, definitions);
+        for (const other of linkAlternatives.unrelated) {
+            reviewItems.push({
+                file: other.relativePath || path.relative(index.root, other.file),
+                line: other.nameLine || other.startLine,
+                expression: (index.getLineContent(other.file, other.nameLine || other.startLine) || '').trim(),
+                suggestion: `Another external definition of "${name}" that no declaration of the renamed ` +
+                    'function reaches (a separate program or platform build); rename it too if it is the same function',
+                needsReview: true,
+                editKind: 'definition',
+            });
+        }
+        if (conditionalStyle && !def.isSignature) {
+            const { _cFamilySignatureKey, _isCrossFileConfigurationMember, _sameOwnerPath,
+                _isConfigurationAlternative } = require('./callers');
+            const hasCfg = d => (d.attributesWithArgs || []).some(a => a.name === 'cfg') ||
+                (d.modifiers || []).includes('cfg');
+            const alternatives = definitions.filter(other => other !== def && ((
+                // Runtime configuration items (fix #398F, Python): the
+                // parser-recorded alternatives of the item, whatever their
+                // parameters.
+                conditionalStyle === 'branch' ? _isConfigurationAlternative(index, def, other) :
+                other.file === def.file && !other.isSignature &&
+                !NON_CALLABLE_TYPES.has(other.type) &&
+                (other.className || null) === (def.className || null) &&
+                (other.traitName || null) === (def.traitName || null) &&
+                (other.namespace || null) === (def.namespace || null) &&
+                (other.explicitInterface || null) === (def.explicitInterface || null) &&
+                !(other.startLine === def.startLine && other.endLine === def.endLine) &&
+                // Members of two same-name classes declared in different
+                // scopes (a function-local class) are two items (fix #389).
+                !distinctOwnerDefinitions(index, other, def) &&
+                // One full owner path (fix #395): same-name nested types of
+                // two outer classes are two items.
+                _sameOwnerPath(index, other, def) &&
+                _cFamilySignatureKey(other) === _cFamilySignatureKey(def) &&
+                (conditionalStyle !== 'attribute' || hasCfg(def) || hasCfg(other))) ||
+                // The same class defined again in a file no translation unit
+                // includes beside this one (fix #385: `#ifdef _WIN32
+                // #include "client-windows.h" #else #include "client.h"`).
+                (!other.isSignature && _isCrossFileConfigurationMember(index, def, other)) ||
+                linkAlternatives.defines.includes(other)));
+            const alternativeSites = [];
+            for (const other of alternatives) {
+                const line = other.nameLine || other.startLine;
+                const rel = other.relativePath || other.file;
+                if (!lineTaken(other, rel, line)) {
+                    const edit = renameIdentifierTokens(index, other.file, line, name,
+                        options.renameTo, null, null, { definitionNameOnly: true, definition: other });
+                    if (edit.renamed !== edit.source) {
+                        changes.push(tagTokenEdit({
+                            file: rel,
+                            line,
+                            expression: edit.source,
+                            suggestion: linkAlternatives.defines.includes(other)
+                                ? `Update another definition of the declared function: ${edit.renamed}`
+                                : `Update configuration alternative: ${edit.renamed}`,
+                            newExpression: edit.renamed,
+                            isDefinition: true,
+                            editKind: 'definition',
+                        }, edit));
+                    }
+                }
+                const sweep = computePlanCallSites(index, name, other, { analyzeArgs: !options.renameTo });
+                const seen = new Set([...planCallSites, ...alternativeSites].map(site =>
+                    `${site.file}:${site.line}:${site.column ?? '*'}`));
+                const lines = new Set([...planCallSites, ...alternativeSites].map(site =>
+                    `${site.file}:${site.line}`));
+                for (const site of sweep.sites) {
+                    const key = `${site.file}:${site.line}:${site.column ?? '*'}`;
+                    if (seen.has(key)) continue;
+                    // One call reached through two alternatives' sweeps, once
+                    // without its column (fix #385: a macro alternative's
+                    // invocation beside the function's own call record).
+                    if (site.column == null && lines.has(`${site.file}:${site.line}`)) continue;
+                    const lineless = alternativeSites.findIndex(existing => existing.column == null &&
+                        existing.file === site.file && existing.line === site.line);
+                    if (lineless >= 0) alternativeSites.splice(lineless, 1);
+                    seen.add(key);
+                    lines.add(`${site.file}:${site.line}`);
+                    alternativeSites.push(site);
+                }
+                for (const site of sweep.unverifiedSites) {
+                    if (planUnverified.some(existing => existing.file === site.file &&
+                        existing.line === site.line)) continue;
+                    // A call another alternative's sweep already edits is that
+                    // edit, not a second (column-less) site of review.
+                    if (lines.has(`${site.file}:${site.line}`)) continue;
+                    planUnverified.push(site);
+                }
+            }
+            // A call the engine left ambiguous only between configuration
+            // alternatives binds one of them whichever configuration builds:
+            // when the rename covers every project body of the name, it is
+            // an edit.
+            if (alternatives.length > 0) {
+                const renamed = new Set([def, ...alternatives]);
+                const coversAll = definitions.every(d => renamed.has(d) || d.isSignature ||
+                    NON_CALLABLE_TYPES.has(d.type) ||
+                    (d.className || null) !== (def.className || null));
+                if (coversAll) {
+                    const promoted = planUnverified.filter(site =>
+                        site.reason === 'link-ambiguous' || site.reason === 'macro-definition-ambiguous' ||
+                        site.reason === 'overload-ambiguous' || site.reason === 'configuration-alternative');
+                    const editedLines = new Set([...planCallSites, ...alternativeSites]
+                        .map(site => `${site.file}:${site.line}`));
+                    for (const site of promoted) {
+                        // Already an edit through an alternative's own sweep.
+                        if (editedLines.has(`${site.file}:${site.line}`)) continue;
+                        alternativeSites.push({
+                            file: site.file,
+                            absoluteFile: require('path').join(index.root, site.file),
+                            line: site.line,
+                            expression: site.expression,
+                        });
+                    }
+                }
+            }
+            if (alternativeSites.length > 0) {
+                emitRenameCallSites(alternativeSites);
+                slotAccountSites.push(...alternativeSites);
+                const changedLines = new Set(changes.map(change => `${change.file}:${change.line}`));
+                const kept = planUnverified.filter(site => !changedLines.has(`${site.file}:${site.line}`));
+                planUnverified.length = 0;
+                planUnverified.push(...kept);
+                planUnverified.sort((a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line);
+            }
+        }
+
+        // Run-time alternative bindings of the same scope variable (fix
+        // #376): a language whose adapter reports them (Python) binds a name
+        // per executed statement, so `if ...: f = lib.f` / `else: def f()`,
+        // try/except import fallbacks and a class body's `close = release`
+        // are one variable with the pin. Definitions and assignment targets
+        // are renamed with it, an unaliased import alternative gains an
+        // alias, and class-body reads of a member are references.
+        {
+            let adapter = null;
+            try { adapter = getLanguageAdapter(planLang); } catch { adapter = null; }
+            if (typeof adapter?.findScopeAlternativeBindings === 'function') {
+                let tree = null;
+                try {
+                    const content = index._readFile(def.file);
+                    const parser = getParser(planLang);
+                    tree = parser && (index._getParsedTree?.(def.file, content, planLang) ||
+                        safeParse(parser, content));
+                } catch { tree = null; }
+                const bindings = tree
+                    ? adapter.findScopeAlternativeBindings(tree, def.nameLine || def.startLine, name)
+                    : [];
+                const rel = def.relativePath || def.file;
+                for (const binding of bindings) {
+                    if (changes.some(change => change.file === rel && change.line === binding.line)) continue;
+                    const replacement = binding.kind === 'import-name'
+                        ? `${name} as ${options.renameTo}` : options.renameTo;
+                    const edit = renameIdentifierTokens(index, def.file, binding.line, name,
+                        replacement, [binding.column]);
+                    if (edit.renamed === edit.source) continue;
+                    const isReference = binding.kind === 'reference';
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line: binding.line,
+                        expression: edit.source,
+                        suggestion: isReference
+                            ? `Update class-scope reference: ${edit.renamed}`
+                            : `Update alternative binding: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        ...(!isReference && { isDefinition: true }),
+                        editKind: isReference ? 'reference' : 'definition',
+                    }, edit));
+                }
             }
         }
 
         // Renaming a virtual/overridden member is one hierarchy-wide change.
         // Leaving descendant declarations behind either fails compilation
         // (Java/C#/TS override) or silently changes dispatch (Python/JS).
-        if (def.className) {
-            // Inheritance identity is (class name, defining file), not just
-            // the spelling. Repositories routinely contain two Handler/Base
-            // classes in unrelated packages. Follow only children whose base
-            // resolves from the child's scope to this exact parent file.
-            const identityKey = (className, file) => `${file || ''}\0${className}`;
-
-            // The pinned member may itself be an override: the dispatch slot
-            // is rooted at the TOPMOST project ancestor defining the name
-            // (flask PassList.check → JSONTag.check → every sibling
-            // override; outcome-eval 2026-08-18). Climb the extends chain
-            // with the same identity discipline, emit each ancestor definer,
-            // then walk DOWN from the root so sibling overrides join too.
-            // Arity-overload languages require the ancestor's signature to
-            // be the same virtual slot (a same-name different-arity Java
-            // method is a sibling, never the root).
-            let slotRoot = { name: def.className, file: def.file };
+        // A typed object-literal member (`const h: Handler = { handle() {} }`)
+        // fills the slot of its declared interface the same way (fix #360).
+        const literalContract = typedLiteralContract(index, def);
+        if (def.className || literalContract?.projectInterface) {
+            // Slot closure by class DEFINITION identity (fix #376): the
+            // renamed member's slot spans every transitive ancestor that
+            // declares it - including through intermediate classes that do
+            // not redeclare it (jackson WriterBasedJsonGenerator.writeName
+            // -> JsonGeneratorBase -> GeneratorBase -> JsonGenerator) - and
+            // every transitive descendant of those declaring classes that
+            // overrides it. Parents resolve from the declaring file
+            // (qualified and nested spellings included), children only when
+            // their own base resolves back to the same definition; languages
+            // with overloads by parameter list keep only the same-signature
+            // slot. Declared `implements` clauses are slot edges for members
+            // declared in the class body.
+            let slotStartRef = null;
+            if (!def.className && literalContract?.projectInterface) {
+                const iface = literalContract.projectInterface;
+                const entry = classDefsNamed(index, iface.name).entries
+                    .find(e => e.def.file === iface.file);
+                if (entry) slotStartRef = { name: iface.name, key: entry.key, def: entry.def };
+            }
+            const hierarchy = (def.className || slotStartRef)
+                ? hierarchySlotClosure(index, def, slotStartRef) : null;
             const slotAncestors = [];
-            const climbed = new Set([identityKey(slotRoot.name, slotRoot.file)]);
-            for (let hop = 0; hop < 8; hop++) {
-                const parents = index._getInheritanceParents(
-                    slotRoot.name, slotRoot.file) || [];
-                let moved = false;
-                for (const parentName of parents) {
-                    const parentFile = index._resolveClassFile(parentName, slotRoot.file);
-                    if (!parentFile) continue;
-                    const parentDef = (index.symbols.get(name) || []).find(symbol =>
-                        symbol.className === parentName && symbol.file === parentFile &&
-                        !NON_CALLABLE_TYPES.has(symbol.type));
-                    if (!parentDef) continue;
-                    if (langTraits(planLang)?.hasArityOverloads &&
-                        (parentDef.paramsStructured || []).length !==
-                        (def.paramsStructured || []).length) continue;
-                    const key = identityKey(parentName, parentFile);
-                    if (climbed.has(key)) break;
-                    climbed.add(key);
-                    slotRoot = { name: parentName, file: parentFile };
-                    slotAncestors.push({ className: parentName, file: parentFile, def: parentDef });
-                    moved = true;
-                    break;
-                }
-                if (!moved) break;
+            for (const ancestor of hierarchy?.ancestors || []) {
+                for (const member of ancestor.members) {
+                    if (member.file === def.file && member.startLine === def.startLine) continue;
+                    slotAncestors.push({ className: ancestor.ref.name, file: member.file, def: member });
+                }
             }
+            hierarchySlot = hierarchy;
             const slotMemberDefs = [];
+            // fix #379: a C/C++ slot member declared in its class and
+            // defined out of line (`void Derived::f() {}` in another file)
+            // is one callable; renaming the declaration alone leaves a
+            // definition that matches nothing.
+            const { _closeCallableIdentityGroup: closeIdentity } = require('./callers');
+            const renameSlotPartners = (member, suggestion) => {
+                for (const partner of closeIdentity(index, [member], definitions)) {
+                    if (partner === member ||
+                        (partner.file === def.file && partner.startLine === def.startLine)) continue;
+                    const line = partner.nameLine || partner.startLine;
+                    const rel = partner.relativePath || partner.file;
+                    if (lineTaken(partner, rel, line)) continue;
+                    const edit = renameIdentifierTokens(index, partner.file,
+                        line, name, options.renameTo,
+                        null, null, { definitionNameOnly: true, definition: partner });
+                    if (edit.renamed === edit.source) continue;
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line,
+                        expression: edit.source,
+                        suggestion: `${suggestion}: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        isDefinition: true,
+                        editKind: 'definition',
+                    }, edit));
+                    slotMemberDefs.push(partner);
+                }
+            };
             for (const ancestor of slotAncestors) {
                 slotMemberDefs.push(ancestor.def);
                 const line = ancestor.def.nameLine || ancestor.def.startLine;
                 const rel = ancestor.def.relativePath || ancestor.def.file;
-                if (changes.some(change =>
-                    change.file === rel && change.line === line)) continue;
+                if (lineTaken(ancestor.def, rel, line)) continue;
                 const edit = renameIdentifierTokens(index, ancestor.def.file,
                     line, name, options.renameTo,
-                    null, null, { definitionNameOnly: true });
+                    null, null, { definitionNameOnly: true, definition: ancestor.def });
                 if (edit.renamed === edit.source) continue;
-                changes.push({
+                changes.push(tagTokenEdit({
                     file: rel,
                     line,
                     expression: edit.source,
@@ -2677,59 +3977,112 @@ function plan(index, name, options = {}) {
                     newExpression: edit.renamed,
                     isDefinition: true,
                     editKind: 'definition',
-                });
+                }, edit));
             }
-
-            const descendants = new Map();
-            const queue = [{ name: slotRoot.name, file: slotRoot.file }];
-            const visited = new Set([identityKey(slotRoot.name, slotRoot.file)]);
-            while (queue.length > 0 && descendants.size < 5000) {
-                const parent = queue.shift();
-                for (const child of index.extendedByGraph.get(parent.name) || []) {
-                    const childName = typeof child === 'string' ? child : child.name;
-                    const childFile = typeof child === 'string'
-                        ? index._resolveClassFile(childName, parent.file)
-                        : child.file;
-                    if (!childName || !childFile) continue;
-                    const parentFile = index._resolveClassFile(parent.name, childFile);
-                    if (parentFile !== parent.file) continue;
-                    const key = identityKey(childName, childFile);
-                    if (visited.has(key)) continue;
-                    visited.add(key);
-                    descendants.set(key, { name: childName, file: childFile });
-                    queue.push({ name: childName, file: childFile });
-                }
-            }
-            for (const override of index.symbols.get(name) || []) {
-                if (!override.className ||
-                    !descendants.has(identityKey(override.className, override.file))) continue;
-                // Slot-rooting can put the pin's OWN class in the descendant
-                // set. The pin handles itself; same-class siblings (Java
-                // arity overloads, TS/Python signature stubs) belong to the
-                // identity-group pass, never the hierarchy walk.
-                if (override.className === def.className &&
-                    override.file === def.file &&
-                    override.startLine !== def.startLine) continue;
-                const line = override.nameLine || override.startLine;
-                const rel = override.relativePath || override.file;
-                if (changes.some(change => change.file === rel && change.line === line)) continue;
-                const edit = renameIdentifierTokens(index, override.file,
-                    line, name, options.renameTo,
-                    null, null, { definitionNameOnly: true });
-                const sourceLine = edit.source;
-                const newExpression = edit.renamed;
-                if (newExpression === sourceLine) continue;
-                changes.push({
+            for (const ancestor of slotAncestors) renameSlotPartners(ancestor.def, 'Update base definition');
+
+            const pinOwnerKey = hierarchy?.pinRef?.key || null;
+            for (const descendant of hierarchy?.descendants || []) {
+                for (const override of descendant.members) {
+                    // The pin handles itself; same-class siblings (Java
+                    // arity overloads, TS/Python signature stubs) belong to
+                    // the identity-group pass, never the hierarchy walk.
+                    if (pinOwnerKey && descendant.ref.key === pinOwnerKey) continue;
+                    if (override.file === def.file && override.startLine === def.startLine) continue;
+                    const line = override.nameLine || override.startLine;
+                    const rel = override.relativePath || override.file;
+                    if (lineTaken(override, rel, line)) continue;
+                    const edit = renameIdentifierTokens(index, override.file,
+                        line, name, options.renameTo,
+                        null, null, { definitionNameOnly: true, definition: override });
+                    const sourceLine = edit.source;
+                    const newExpression = edit.renamed;
+                    if (newExpression === sourceLine) continue;
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line,
+                        expression: sourceLine,
+                        suggestion: `Update overriding definition: ${newExpression}`,
+                        newExpression,
+                        isDefinition: true,
+                        editKind: 'definition',
+                    }, edit));
+                    slotMemberDefs.push(override);
+                }
+            }
+            for (const descendant of hierarchy?.descendants || []) {
+                if (pinOwnerKey && descendant.ref.key === pinOwnerKey) continue;
+                for (const override of descendant.members) {
+                    renameSlotPartners(override, 'Update overriding definition');
+                }
+            }
+            const slotOwners = [
+                ...(hierarchy ? [hierarchy.pinRef, ...hierarchy.ancestors.map(a => a.ref),
+                    ...hierarchy.descendants.map(d => d.ref)] : []),
+            ].filter(ref => ref?.def?.file).map(ref => ({ name: ref.name, file: ref.def.file }));
+            // Typed object literals declared against the root or any
+            // descendant interface fill the same slot.
+            for (const owner of slotOwners) {
+                for (const member of typedLiteralMembers(index, name, owner.name, owner.file)) {
+                    if (member.file === def.file && member.startLine === def.startLine) continue;
+                    const line = member.nameLine || member.startLine;
+                    const rel = member.relativePath || member.file;
+                    if (lineTaken(member, rel, line)) continue;
+                    const edit = renameIdentifierTokens(index, member.file,
+                        line, name, options.renameTo,
+                        null, null, { definitionNameOnly: true, definition: member });
+                    if (edit.renamed === edit.source) continue;
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line,
+                        expression: edit.source,
+                        suggestion: `Update typed object-literal member: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        isDefinition: true,
+                        editKind: 'definition',
+                    }, edit));
+                    slotMemberDefs.push(member);
+                }
+            }
+            // Anonymous subclasses (fix #390): a Java `new Listener() {
+            // @Override void run() {} }` or a JS/TS class expression that
+            // extends a slot owner overrides the member without being an
+            // indexed class.
+            for (const site of anonymousSlotMembers(index, name, planGroundSet?.perFile, hierarchy, def)) {
+                const rel = require('path').relative(index.root, site.file);
+                if (site.verdict === 'review') {
+                    if (!changes.some(change => change.file === rel && change.line === site.line)) {
+                        changes.push({
+                            file: rel,
+                            line: site.line,
+                            expression: (index._getFileLines(site.file)[site.line - 1] || '').trim(),
+                            suggestion: `Verify whether this anonymous class member overrides ${name} and rename it to ${options.renameTo} if it does`,
+                            needsReview: true,
+                            reviewReason: site.reason,
+                            editKind: 'definition',
+                        });
+                    }
+                    continue;
+                }
+                const existing = changes.find(change => change.file === rel && change.line === site.line);
+                const edit = renameIdentifierTokens(index, site.file, site.line, name, options.renameTo,
+                    [site.column]);
+                if (edit.renamed === edit.source) continue;
+                if (existing) {
+                    if (existing.newExpression !== undefined && existing._edit) mergeTokenEdit(existing, edit);
+                    continue;
+                }
+                changes.push(tagTokenEdit({
                     file: rel,
-                    line,
-                    expression: sourceLine,
-                    suggestion: `Update overriding definition: ${newExpression}`,
-                    newExpression,
+                    line: site.line,
+                    expression: edit.source,
+                    suggestion: `Update anonymous class override: ${edit.renamed}`,
+                    newExpression: edit.renamed,
                     isDefinition: true,
                     editKind: 'definition',
-                });
-                slotMemberDefs.push(override);
+                }, edit));
             }
+            contractRootDefs.push(...slotAncestors.map(ancestor => ancestor.def));
 
             // Go interface slots are implicit (fix #302, mux Match): there is
             // no implements edge for the hierarchy walk above. Compute the
@@ -2739,20 +4092,20 @@ function plan(index, name, options = {}) {
             // signatures) abstain in goInterfaceRenameClosure — absence is
             // never treated as proof.
             const goInterfaceSlot = planLang === 'go'
-                ? goInterfaceRenameClosure(index, def)
+                ? goContractClosure(index, def)
                 : null;
+            if (goInterfaceSlot) goContractReviews.push(...goInterfaceSlot.reviews);
             if (goInterfaceSlot) {
                 for (const member of goInterfaceSlot.memberDefs) {
                     if (member.file === def.file && member.startLine === def.startLine) continue;
                     const line = member.nameLine || member.startLine;
                     const rel = member.relativePath || member.file;
-                    if (!changes.some(change =>
-                        change.file === rel && change.line === line)) {
+                    if (!lineTaken(member, rel, line)) {
                         const edit = renameIdentifierTokens(index, member.file,
                             line, name, options.renameTo,
-                            null, null, { definitionNameOnly: true });
+                            null, null, { definitionNameOnly: true, definition: member });
                         if (edit.renamed !== edit.source) {
-                            changes.push({
+                            changes.push(tagTokenEdit({
                                 file: rel,
                                 line,
                                 expression: edit.source,
@@ -2760,7 +4113,7 @@ function plan(index, name, options = {}) {
                                 newExpression: edit.renamed,
                                 isDefinition: true,
                                 editKind: 'definition',
-                            });
+                            }, edit));
                         }
                     }
                     slotMemberDefs.push(member);
@@ -2776,38 +4129,44 @@ function plan(index, name, options = {}) {
             // it, with file-identity discipline (two crates may define
             // same-named traits — a member joins only when its trait
             // resolves to the pin's trait FILE).
-            const slotTraitNames = new Set();
-            let pinTraitFile = null;
+            // Trait identity is the trait DEFINITION (fix #376): impl
+            // headers spell generic traits with arguments (`impl<T> Ctx<T>
+            // for Option<T>`) and paths (`crate::Ctx`), so a member joins
+            // when its impl's trait resolves to the pin's trait definition.
+            const traitKey = d => `${d.file}\0${d.startLine}`;
+            let pinTraitDefs = [];
             if (def.traitName) {
-                slotTraitNames.add(def.traitName);
-                pinTraitFile = index._resolveClassFile(def.traitName, def.file) || null;
+                pinTraitDefs = rustProjectTraits(index, def.traitName, def.file, def.startLine);
             } else if ((index.symbols.get(def.className) || []).some(d =>
                 d.type === 'trait' && d.file === def.file)) {
-                slotTraitNames.add(def.className);
-                pinTraitFile = def.file;
+                pinTraitDefs = (index.symbols.get(def.className) || []).filter(d =>
+                    d.type === 'trait' && d.file === def.file &&
+                    d.startLine <= def.startLine && (d.endLine || d.startLine) >= def.startLine);
             }
-            if (slotTraitNames.size > 0 && pinTraitFile) {
-                const traitName = [...slotTraitNames][0];
+            if (pinTraitDefs.length === 1) {
+                const pinTrait = pinTraitDefs[0];
                 for (const member of index.symbols.get(name) || []) {
                     if (member.file === def.file && member.startLine === def.startLine) continue;
                     if (NON_CALLABLE_TYPES.has(member.type)) continue;
                     let inSlot = false;
-                    if (member.traitName === traitName) {
-                        inSlot = index._resolveClassFile(traitName, member.file) === pinTraitFile;
-                    } else if (member.className === traitName && member.file === pinTraitFile &&
-                        (index.symbols.get(traitName) || []).some(d =>
-                            d.type === 'trait' && d.file === member.file)) {
+                    if (member.traitName) {
+                        const traits = rustProjectTraits(index, member.traitName, member.file,
+                            member.startLine);
+                        inSlot = traits.length === 1 && traitKey(traits[0]) === traitKey(pinTrait);
+                    } else if (member.className === pinTrait.name && member.file === pinTrait.file &&
+                        member.startLine >= pinTrait.startLine &&
+                        member.startLine <= (pinTrait.endLine || pinTrait.startLine)) {
                         inSlot = true; // the trait's own declaration member
                     }
                     if (!inSlot) continue;
                     const line = member.nameLine || member.startLine;
                     const rel = member.relativePath || member.file;
-                    if (!changes.some(change => change.file === rel && change.line === line)) {
+                    if (!lineTaken(member, rel, line)) {
                         const edit = renameIdentifierTokens(index, member.file,
                             line, name, options.renameTo,
-                            null, null, { definitionNameOnly: true });
+                            null, null, { definitionNameOnly: true, definition: member });
                         if (edit.renamed !== edit.source) {
-                            changes.push({
+                            changes.push(tagTokenEdit({
                                 file: rel,
                                 line,
                                 expression: edit.source,
@@ -2815,80 +4174,11 @@ function plan(index, name, options = {}) {
                                 newExpression: edit.renamed,
                                 isDefinition: true,
                                 editKind: 'definition',
-                            });
+                            }, edit));
                         }
                     }
                     slotMemberDefs.push(member);
                 }
-                // Macro-generated impls are invisible to the index (the
-                // as_cast_impl! family: the `fn` lives in a macro_rules body,
-                // no impl_item node exists). A definition-shaped ground line
-                // no indexed def claims, sitting inside a macro_rules body
-                // whose token tree names `impl … <Trait>`, implements the
-                // renamed slot — compiler-connected via the impl header, so
-                // the edit is synthesized mechanically.
-                // The sweep already computed the ground set for this exact
-                // name (contractedCallerSweep) — reuse it instead of a second
-                // full-repo text scan (read-only by contract).
-                const macroGround = planGroundSet;
-                const fnRe = new RegExp(`\\bfn\\s+${escapeRegExp(name)}\\b`);
-                const implRe = new RegExp(
-                    `\\bimpl\\b[^;{}]{0,160}\\b${escapeRegExp(traitName)}\\b`);
-                for (const [macroFile, lineNos] of macroGround.perFile) {
-                    const macroEntry = index.files.get(macroFile);
-                    if (!macroEntry || macroEntry.language !== 'rust') continue;
-                    const claimed = new Set((index.symbols.get(name) || [])
-                        .filter(d => d.file === macroFile)
-                        .map(d => d.nameLine || d.startLine));
-                    let macroTree = null;
-                    let macroNodes = null;
-                    for (const lineNo of lineNos) {
-                        if (claimed.has(lineNo)) continue;
-                        const rel = macroEntry.relativePath || macroFile;
-                        if (changes.some(change =>
-                            change.file === rel && change.line === lineNo)) continue;
-                        const content = index._readFile(macroFile);
-                        if (!fnRe.test(content.split('\n')[lineNo - 1] || '')) continue;
-                        if (macroTree === null) {
-                            const parser = getParser('rust');
-                            macroTree = (parser &&
-                                (index._getParsedTree?.(macroFile, content, 'rust') ||
-                                    safeParse(parser, content))) || false;
-                            macroNodes = [];
-                            if (macroTree) {
-                                const stack = [macroTree.rootNode];
-                                while (stack.length > 0) {
-                                    const node = stack.pop();
-                                    if (node.type === 'macro_definition') {
-                                        macroNodes.push(node);
-                                        continue;
-                                    }
-                                    for (let i = 0; i < node.namedChildCount; i++) {
-                                        stack.push(node.namedChild(i));
-                                    }
-                                }
-                            }
-                        }
-                        if (!macroTree || !macroNodes) continue;
-                        const mac = macroNodes.find(m =>
-                            m.startPosition.row + 1 <= lineNo &&
-                            m.endPosition.row + 1 >= lineNo);
-                        if (!mac || !implRe.test(mac.text)) continue;
-                        const edit = renameIdentifierTokens(index, macroFile,
-                            lineNo, name, options.renameTo,
-                            null, null, { definitionNameOnly: true });
-                        if (edit.renamed === edit.source) continue;
-                        changes.push({
-                            file: rel,
-                            line: lineNo,
-                            expression: edit.source,
-                            suggestion: `Update macro-generated trait implementation: ${edit.renamed}`,
-                            newExpression: edit.renamed,
-                            isDefinition: true,
-                            editKind: 'definition',
-                        });
-                    }
-                }
             }
 
             // A slot rename must also carry every member's CALL sites — the
@@ -2903,8 +4193,15 @@ function plan(index, name, options = {}) {
                 `${site.file}:${site.line}:${Number.isInteger(site.column) ? site.column : '*'}`;
             const seenSiteTokens = new Set(planCallSites.map(site => siteTokenKey(site)));
             const slotMemberSites = [];
-            for (const memberDef of slotMemberDefs.slice(0, SLOT_SWEEP_CAP)) {
-                const memberSweep = computePlanCallSites(index, name, memberDef);
+            // Members a macro generated (fix #374) are swept after, and
+            // capped apart from, the written ones: a macro instantiated for
+            // many types must not crowd written members out of the sweep.
+            const writtenMembers = slotMemberDefs.filter(member => !member.macroExpansion);
+            const generatedMembers = slotMemberDefs.filter(member => member.macroExpansion);
+            const sweptMembers = [...writtenMembers.slice(0, SLOT_SWEEP_CAP),
+                ...generatedMembers.slice(0, SLOT_SWEEP_CAP)];
+            for (const memberDef of sweptMembers) {
+                const memberSweep = computePlanCallSites(index, name, memberDef, { analyzeArgs: !options.renameTo });
                 for (const site of memberSweep.sites) {
                     const key = siteTokenKey(site);
                     if (seenSiteTokens.has(key)) continue;
@@ -2918,9 +4215,16 @@ function plan(index, name, options = {}) {
                 for (const raw of memberSweep.rawUnverified || []) {
                     const exactInterfaceReceiver = goInterfaceSlot &&
                         raw.reason === 'possible-dispatch' &&
-                        goInterfaceSlot.interfaceNames.has(raw.dispatchVia);
+                        goInterfaceSlot.interfaceNames.has(
+                            String(raw.dispatchVia || '').split('.').pop());
+                    // A closed ambiguity holds where its receiver is a
+                    // project value: in a file of another build
+                    // configuration than the pin's, names may resolve to
+                    // other declarations (an import there, a variable here),
+                    // so the site stays a review item (fix #400).
                     const closedAmbiguity = goSlotCoversMethodAmbiguity(
-                        index, name, goInterfaceSlot, raw);
+                        index, name, goInterfaceSlot, raw) &&
+                        !goOtherConfiguration(index, def.file, raw.file);
                     if ((!exactInterfaceReceiver && !closedAmbiguity) ||
                         raw.externalContract) continue;
                     const relativePath = raw.relativePath ||
@@ -2964,14 +4268,16 @@ function plan(index, name, options = {}) {
                     });
                 }
             }
-            if (slotMemberDefs.length > SLOT_SWEEP_CAP) {
+            if (writtenMembers.length > SLOT_SWEEP_CAP || generatedMembers.length > SLOT_SWEEP_CAP) {
                 resolved.warnings.push({
                     message: `Dispatch slot has ${slotMemberDefs.length} member ` +
                         `definitions; call sites were swept for the first ` +
-                        `${SLOT_SWEEP_CAP} — review the rest manually.`,
+                        `${SLOT_SWEEP_CAP}${generatedMembers.length > 0
+                            ? ' written and first ' + SLOT_SWEEP_CAP + ' macro-generated' : ''} — review the rest manually.`,
                 });
             }
             emitRenameCallSites(slotMemberSites);
+            slotAccountSites.push(...slotMemberSites);
             // A site a slot member's sweep CONFIRMED is a planned edit now —
             // it no longer belongs in the pin's "may need this change" band.
             const changedLines = new Set(changes.map(change =>
@@ -3004,12 +4310,12 @@ function plan(index, name, options = {}) {
                     !new Set(['c', 'cpp']).has(siblingLang)) continue;
                 const line = sibling.nameLine || sibling.startLine;
                 const rel = sibling.relativePath || sibling.file;
-                if (changes.some(change => change.file === rel && change.line === line)) continue;
+                if (lineTaken(sibling, rel, line)) continue;
                 const edit = renameIdentifierTokens(index, sibling.file,
                     line, name, options.renameTo,
-                    null, null, { definitionNameOnly: true });
+                    null, null, { definitionNameOnly: true, definition: sibling });
                 if (edit.renamed === edit.source) continue;
-                changes.push({
+                changes.push(tagTokenEdit({
                     file: rel,
                     line,
                     expression: edit.source,
@@ -3017,23 +4323,151 @@ function plan(index, name, options = {}) {
                     newExpression: edit.renamed,
                     isDefinition: true,
                     editKind: 'definition',
-                });
+                }, edit));
             }
         }
 
-        // Reference-position usages are rename edits too (outcome-eval
-        // flask, 2026-08-18): `return decorator`, `callback=handler`,
-        // `cls.method` values. Call syntax flows through the tiered sweep;
-        // references never did — a plan-following rename left them on the
-        // old name and the toolchain rejected the result. Evidence
-        // discipline mirrors the caller engine:
-        //   - same-file, non-method pin: nearest-binder containment — the
-        //     innermost same-name def whose scope container holds the line
-        //     must be the pin (a sibling nested `decorator` keeps its own
-        //     references; ties bind nothing);
-        //   - same-file, method pin: self/cls/this-received inside the
-        //     pin's class range (receiver evidence read from the line);
-        //   - cross-file, non-method pin: the #217 import-ownership chase —
+        // Macro templates (fix #360, bytes-measured): identifiers inside a
+        // macro_rules! transcriber bind at every expansion site, so the
+        // AST never shows them as definitions or calls of the pin - and a
+        // rename that leaves them behind breaks every expansion. Each token
+        // spelling the name is classified by its token shape; a site is
+        // edited only when its identity is proven from the pin:
+        //   `fn NAME` whose every owner (an `impl Trait for ..` header inside
+        //     the template, or the impl blocks that invoke the macro) is the
+        //     pin's own trait slot;
+        //   `.NAME(` / `Self::NAME(` forwarding inside such a template fn;
+        //   `NAME(` for a free-function pin whose binding reaches the pin in
+        //     the macro's file.
+        // Every other token that can denote the pin is listed for review,
+        // never omitted; tokens that provably denote another item (a `fn`
+        // under a different trait, a dot-call against a free function) are
+        // skipped.
+        // A renamed TYPE's template tokens are decided by the type-reference
+        // pass (fix #386).
+        if (langTraits(planLang)?.macroTemplateBodies && planGroundSet?.perFile && !isTypeRenamePin(def)) {
+            const pinTraitDefs = def.traitName
+                ? rustProjectTraits(index, def.traitName, def.file, def.startLine)
+                : (def.className ? (index.symbols.get(def.className) || []).filter(d =>
+                    d.type === 'trait' && d.file === def.file) : []);
+            const pinTraitKeys = new Set(pinTraitDefs.map(d => `${d.file}\0${d.startLine}`));
+            const ownerIsPinTrait = (owner, macroFile) => owner.kind === 'impl' && owner.trait &&
+                rustProjectTraits(index, owner.trait, macroFile)
+                    .some(d => pinTraitKeys.has(`${d.file}\0${d.startLine}`));
+            // Files that can hold template tokens of this name: a ground
+            // line inside an indexed macro definition's range. The AST pass
+            // decides every token; this only avoids parsing other files.
+            const templateFiles = [...planGroundSet.perFile.entries()].filter(([file, lineNos]) => {
+                const entry = index.files.get(file);
+                if (entry?.language !== planLang) return false;
+                const macros = (entry.symbols || []).filter(symbol => symbol.type === 'macro');
+                return macros.length > 0 && [...lineNos].some(lineNo => macros.some(macro =>
+                    macro.startLine <= lineNo && (macro.endLine || macro.startLine) >= lineNo));
+            }).map(([file]) => file);
+            const sites = rustMacroTemplateSites(index, name, templateFiles);
+            const decisions = new Map(); // site -> 'edit' | 'review' | 'skip'
+            const editedTemplateFns = new Set(); // file\0macro
+            for (const site of sites.filter(item => item.shape === 'definition')) {
+                let decision;
+                if (pinTraitKeys.size > 0) {
+                    const matches = site.owners.filter(owner => ownerIsPinTrait(owner, site.file));
+                    if (site.owners.length > 0 && matches.length === site.owners.length) decision = 'edit';
+                    else if (matches.length === 0 && site.owners.length > 0 &&
+                        site.owners.every(owner => owner.kind === 'impl' && owner.trait)) decision = 'skip';
+                    else decision = 'review';
+                } else if (def.className) {
+                    decision = site.owners.length > 0 && site.owners.every(owner =>
+                        owner.kind === 'impl' && owner.trait) ? 'skip' : 'review';
+                } else {
+                    decision = site.owners.length > 0 && site.owners.every(owner =>
+                        owner.kind === 'impl') ? 'skip' : 'review';
+                }
+                decisions.set(site, decision);
+                if (decision === 'edit') editedTemplateFns.add(`${site.file}\0${site.macroName}`);
+            }
+            for (const site of sites.filter(item => item.shape !== 'definition')) {
+                let decision = 'review';
+                const forwarding = site.enclosingFn === name &&
+                    editedTemplateFns.has(`${site.file}\0${site.macroName}`);
+                if (site.shape === 'method-call') {
+                    decision = !def.className ? 'skip' : forwarding ? 'edit' : 'review';
+                } else if (site.shape === 'path-call') {
+                    decision = forwarding && site.pathQualifier === 'Self' ? 'edit' : 'review';
+                } else if (site.shape === 'call') {
+                    if (def.className) decision = 'skip'; // bare calls never denote methods
+                    else {
+                        decision = _nameBindingReaches(index, site.file, name, renameTargetFiles) === 'yes'
+                            ? 'edit' : 'review';
+                    }
+                }
+                decisions.set(site, decision);
+            }
+            const editsByLine = new Map();
+            const unverifiedTemplateLines = new Set(planUnverified.map(site =>
+                `${site.file}:${site.line}`));
+            for (const [site, decision] of decisions) {
+                if (decision === 'skip') continue;
+                const key = `${site.file}\0${site.line}`;
+                if (decision === 'edit') {
+                    if (!editsByLine.has(key)) editsByLine.set(key, { site, columns: [], definition: false });
+                    const entry = editsByLine.get(key);
+                    entry.columns.push(site.column);
+                    if (site.shape === 'definition') entry.definition = true;
+                    continue;
+                }
+                if (unverifiedTemplateLines.has(`${site.relativePath}:${site.line}`)) continue;
+                if (reviewItems.some(item => item.file === site.relativePath &&
+                    item.line === site.line && item.templateDependency)) continue;
+                reviewItems.push({
+                    file: site.relativePath,
+                    line: site.line,
+                    expression: (index.getLineContent(site.file, site.line) || '').trim(),
+                    suggestion: `Macro ${site.macroName || 'template'} spells "${name}" as a ` +
+                        `${site.shape.replace('-', ' ')} token; it binds at each expansion - ` +
+                        'rename it with the pin if the expansions reach it',
+                    needsReview: true,
+                    templateDependency: true,
+                    reviewReason: 'macro-template',
+                    editKind: 'macro-template',
+                });
+            }
+            for (const { site, columns, definition } of editsByLine.values()) {
+                if (changes.some(change => change.file === site.relativePath &&
+                    change.line === site.line)) continue;
+                const edit = renameIdentifierTokens(index, site.file, site.line, name,
+                    options.renameTo, columns.sort((a, b) => a - b));
+                if (edit.renamed === edit.source) continue;
+                changes.push(tagTokenEdit({
+                    file: site.relativePath,
+                    line: site.line,
+                    expression: edit.source,
+                    suggestion: `Update macro template ${site.macroName || ''}: ${edit.renamed}`.replace('  ', ' '),
+                    newExpression: edit.renamed,
+                    ...(definition && { isDefinition: true }),
+                    editKind: definition ? 'definition' : 'call',
+                }, edit));
+            }
+            if (editsByLine.size > 0) {
+                const changedLines = new Set(changes.map(change => `${change.file}:${change.line}`));
+                const kept = planUnverified.filter(site => !changedLines.has(`${site.file}:${site.line}`));
+                planUnverified.length = 0;
+                planUnverified.push(...kept);
+            }
+        }
+
+        // Reference-position usages are rename edits too (outcome-eval
+        // flask, 2026-08-18): `return decorator`, `callback=handler`,
+        // `cls.method` values. Call syntax flows through the tiered sweep;
+        // references never did — a plan-following rename left them on the
+        // old name and the toolchain rejected the result. Evidence
+        // discipline mirrors the caller engine:
+        //   - same-file, non-method pin: nearest-binder containment — the
+        //     innermost same-name def whose scope container holds the line
+        //     must be the pin (a sibling nested `decorator` keeps its own
+        //     references; ties bind nothing);
+        //   - same-file, method pin: self/cls/this-received inside the
+        //     pin's class range (receiver evidence read from the line);
+        //   - cross-file, non-method pin: the #217 import-ownership chase —
         //     'yes' edits, 'unknown' surfaces needsReview (no synthesized
         //     edit), 'no' skips;
         //   - cross-file method references are receiver-blind here:
@@ -3071,10 +4505,18 @@ function plan(index, name, options = {}) {
                 }
                 return best; // null = module scope
             };
+            // A prototype and its definition (C/C++ forward declarations,
+            // overload signatures) are one callable (fix #396): each binds
+            // the name as the pin.
+            const pinIdentity = new Set(require('./callers')._closeCallableIdentityGroup(
+                index, [def], definitions));
             const binders = definitions
                 .filter(candidate => candidate.file === def.file &&
                     !NON_CALLABLE_TYPES.has(candidate.type))
-                .map(candidate => ({ def: candidate, container: containerOf(candidate) }));
+                .map(candidate => ({
+                    def: pinIdentity.has(candidate) ? def : candidate,
+                    container: containerOf(candidate),
+                }));
             const classKinds = new Set(['class', 'struct', 'interface', 'trait',
                 'record', 'enum', 'namespace']);
             const pinClassRange = def.className
@@ -3095,92 +4537,236 @@ function plan(index, name, options = {}) {
                     (symbol.endLine || symbol.startLine) >= line);
             };
             const pinContainer = containerOf(def);
-            for (const ref of usages) {
-                if (ref.usageType !== 'reference' || ref.isDefinition) continue;
-                const rel = ref.relativePath || ref.file;
-                if (changes.some(change =>
-                    change.file === rel && change.line === ref.line)) continue;
-                if (unverifiedLines.has(`${rel}:${ref.line}`)) continue;
-                let verdict = null;
+            const methodGroupPin = !!langTraits(planLang)?.methodGroupReferences &&
+                (def.type === 'method' || def.memberType === 'method' || !!def.isMethod);
+            // Where each bare reference resolves (fix #392): the parser
+            // records the language's own lexical scoping on the usage
+            // (`scopeBinding`), so a reference inside a function body or on a
+            // decorator line is decided instead of reviewed. The pin must be
+            // declared at file scope for a file-scope resolution to reach it
+            // (a Rust inline module is its own scope).
+            const pinNameLine = def.nameLine || def.startLine;
+            const pinAtFileScope = !pinContainer && !fileSymbols.some(symbol =>
+                symbol.type === 'module' && symbol !== def &&
+                symbol.startLine <= pinNameLine &&
+                (symbol.endLine || symbol.startLine) >= pinNameLine &&
+                !(symbol.startLine === def.startLine && symbol.name === def.name));
+            const fileScopeBinders = binders.filter(binder => !binder.container);
+            const pinIsFileBinding = pinAtFileScope && fileScopeBinders.length >= 1 &&
+                fileScopeBinders.every(binder => binder.def === def);
+            // One record's verdict: 'edit', 'review' or null (not the pin).
+            const verdictFor = (ref) => {
+                // A C++ qualified reference (`template auto ns::f(float)
+                // -> R;`, `&Cls::m`, fix #393) names what its qualifier
+                // resolves to from the reference's own scope.
+                if (ref.receiver && index.files.get(ref.file)?.language === 'cpp') {
+                    return cppQualifiedReferenceVerdict(index, ref, def);
+                }
+                // A function declared in a function body (a C# local
+                // function, a nested def) is in scope only in its block:
+                // never from another file, and never as the member of an
+                // object (`profile.Items`, fix #395).
+                if (pinContainer && !def.className && (ref.file !== def.file || ref.receiver)) return null;
+                // A property of an object (an object-literal member, `obj.f =
+                // fn`) is reached through a receiver, never as a bare
+                // binding: member accesses are decided by the call-site and
+                // accessor passes (fix #397).
+                if (ref.receiver && def.memberAssigned && !def.className) return null;
                 if (ref.file === def.file) {
+                    // C# method groups are decided by the language's lookup
+                    // in their own pass (fix #395).
+                    if (def.className && methodGroupPin) return null;
                     if (def.className) {
                         const lineText = ref.content ||
                             index.getLineContent(def.file, ref.line) || '';
-                        if (pinClassRange && ref.line >= pinClassRange.startLine &&
-                            ref.line <= (pinClassRange.endLine || Infinity) &&
+                        // `this` names the innermost enclosing class (fix
+                        // #390: `this.size = size` in a nested class's
+                        // constructor is its own field), and where fields
+                        // and methods are separate namespaces a paren-less
+                        // `this.m` is never the method (Java, Rust).
+                        const innermostClass = fileSymbols.filter(symbol =>
+                            classKinds.has(symbol.type) && symbol.startLine <= ref.line &&
+                            (symbol.endLine || symbol.startLine) >= ref.line)
+                            .sort((a, b) => ((a.endLine || a.startLine) - a.startLine) -
+                                ((b.endLine || b.startLine) - b.startLine))[0] || null;
+                        if (pinClassRange && innermostClass === pinClassRange &&
+                            !langTraits(planLang)?.fieldsAndMethodsSeparate &&
                             selfReceived.test(lineText)) {
-                            verdict = 'edit';
-                        }
-                    } else {
-                        let winner = null;
-                        let ambiguous = false;
-                        for (const binder of binders) {
-                            const contains = !binder.container ||
-                                (binder.container.start <= ref.line &&
-                                    binder.container.end >= ref.line);
-                            if (!contains) continue;
-                            const size = binder.container
-                                ? binder.container.end - binder.container.start
-                                : Infinity;
-                            if (!winner || size < winner.size) {
-                                winner = { def: binder.def, size };
-                                ambiguous = false;
-                            } else if (size === winner.size &&
-                                binder.def !== winner.def) {
-                                ambiguous = true;
-                            }
-                        }
-                        if (winner && !ambiguous && winner.def === def) {
-                            if (pinContainer) {
-                                verdict = 'edit'; // nested pin binds its container
-                            } else if (!insideFunctionLike(def.file, ref.line)) {
-                                verdict = 'edit'; // module-scope row, module pin
-                            } else {
-                                verdict = 'review'; // possible local shadow
-                            }
+                            return 'edit';
                         }
+                        return null;
+                    }
+                    if (!ref.receiver && ref.scopeBinding === 'module') {
+                        // Resolves at file scope: the pin when it is the
+                        // file's only binding of the name there (a nested pin
+                        // is not visible there).
+                        if (pinIsFileBinding) return 'edit';
+                        if (!pinAtFileScope) return null;
+                    } else if (!ref.receiver && ref.scopeBinding === 'local') {
+                        // An enclosing function or block binds the name: the
+                        // pin only when that binding is the pin's own def.
+                        return Array.isArray(ref.scopeDefLines) &&
+                            ref.scopeDefLines.includes(pinNameLine) ? 'edit' : null;
                     }
-                } else if (!def.className) {
-                    // Module-attribute references carry stronger evidence
-                    // than a bare name: `import requests; requests.put` binds
-                    // through requests' export chain even inside a function.
-                    // Parser-side local-shadow evidence is a hard guard — a
-                    // parameter/assignment named requests defeats the import.
-                    const moduleOwnership = ref.receiver &&
-                        !ref.receiverLocalBinding
-                        ? _moduleAttributeBindingReaches(
-                            index, ref.file, ref.receiver, name,
-                            renameTargetFiles)
-                        : null;
-                    if (moduleOwnership === 'yes') {
-                        verdict = 'edit';
-                    } else if (moduleOwnership === 'unknown') {
-                        verdict = 'review';
-                    } else if (!ref.receiver) {
-                        const ownership = _nameBindingReaches(
-                            index, ref.file, name, renameTargetFiles);
-                        if (ownership === 'yes' &&
-                            !insideFunctionLike(ref.file, ref.line)) {
-                            verdict = 'edit';
-                        } else if (ownership !== 'no') {
-                            verdict = 'review';
+                    let winner = null;
+                    let ambiguous = false;
+                    for (const binder of binders) {
+                        const contains = !binder.container ||
+                            (binder.container.start <= ref.line &&
+                                binder.container.end >= ref.line);
+                        if (!contains) continue;
+                        const size = binder.container
+                            ? binder.container.end - binder.container.start
+                            : Infinity;
+                        if (!winner || size < winner.size) {
+                            winner = { def: binder.def, size };
+                            ambiguous = false;
+                        } else if (size === winner.size &&
+                            binder.def !== winner.def) {
+                            ambiguous = true;
                         }
                     }
+                    if (winner && !ambiguous && winner.def === def) {
+                        if (pinContainer) return 'edit'; // nested pin binds its container
+                        if (!insideFunctionLike(def.file, ref.line)) return 'edit'; // module-scope row
+                        return 'review'; // possible local shadow
+                    }
+                    return null;
+                }
+                if (def.className) return null;
+                // Module-attribute references carry stronger evidence
+                // than a bare name: `import requests; requests.put` binds
+                // through requests' export chain even inside a function.
+                // Parser-side local-shadow evidence is a hard guard — a
+                // parameter/assignment named requests defeats the import.
+                const moduleOwnership = ref.receiver &&
+                    !ref.receiverLocalBinding
+                    ? _moduleAttributeBindingReaches(
+                        index, ref.file, ref.receiver, name,
+                        renameTargetFiles)
+                    : null;
+                if (moduleOwnership === 'yes') return 'edit';
+                if (moduleOwnership === 'unknown') return 'review';
+                if (ref.receiver) return null;
+                // A local binding of the name is never the pin (fix #392); a
+                // file-scope resolution follows the file's binding of the name.
+                if (ref.scopeBinding === 'local') return null;
+                // C (fix #396): a file-scope reference names the file's own
+                // function of that name, else the external-linkage function
+                // its translation unit links, as a call does.
+                if (ref.scopeBinding === 'module' && cExternalReferenceLanguage(index, ref.file)) {
+                    return cExternalReferenceVerdict(index, ref, def, pinIdentity, definitions);
+                }
+                const ownership = _nameBindingReaches(
+                    index, ref.file, name, renameTargetFiles);
+                if (ownership === 'yes' &&
+                    (ref.scopeBinding === 'module' ||
+                        !insideFunctionLike(ref.file, ref.line))) {
+                    return 'edit';
                 }
+                return ownership !== 'no' ? 'review' : null;
+            };
+            const eligible = (ref) => {
+                if (ref.usageType !== 'reference' || ref.isDefinition) return false;
+                // Keyword-argument names, object keys and struct field keys
+                // are not references to a non-member binding (a member pin
+                // reads its receiver tokens from the line below).
+                if (!def.className && !ref.receiver && ref.scopeBinding === 'none') return false;
+                // An attribute path or derive entry names a macro (fix #377):
+                // never a reference to a same-named fn or value.
+                if (ref.namespace === 'macro' && !isMacroNamespaceDefinition(def)) return false;
+                return true;
+            };
+            for (const first of usages) {
+                if (first.usageType !== 'reference' || first.isDefinition) continue;
+                // Every record of the line is decided (fix #392): two
+                // references on one line are two tokens.
+                const records = [first, ...(first.sameLine || [])].filter(eligible);
+                if (records.length === 0) continue;
+                const ref = records[0];
+                const rel = ref.relativePath || ref.file;
+                if (unverifiedLines.has(`${rel}:${ref.line}`)) continue;
+                const existing = changes.find(change =>
+                    change.file === rel && change.line === ref.line);
+                const verdicts = records.map(verdictFor);
+                let verdict = verdicts.includes('review') ? 'review'
+                    : verdicts.includes('edit') ? 'edit' : null;
                 if (!verdict) continue;
+                // A same-file member pin is referenced through its receiver
+                // (fix #376): edit exactly the `this.NAME` / `self.NAME`
+                // member tokens on the line (both in `this.m =
+                // this.m.bind(this)`), never an object-literal key or other
+                // same-spelled property (`{ m: this.m }` keeps its key).
+                let refColumns = records.filter((record, i) => verdicts[i] === 'edit')
+                    .map(record => record.column);
+                if (!refColumns.every(Number.isInteger)) refColumns = null;
+                if (verdict === 'edit' && ref.file === def.file && def.className) {
+                    const selfColumns = selfMemberTokenColumns(index, def.file, ref.line, name);
+                    if (selfColumns.length === 0) verdict = 'review';
+                    else refColumns = selfColumns;
+                }
+                // An object-literal shorthand `{ name }` keeps its key (fix
+                // #397, immer-measured: `{ applyPatches_ }` passed where a
+                // Plugin object is expected): the value is spelled out,
+                // `{ name: renamed }`.
+                const shorthandEdits = verdict === 'edit' ? records.filter((record, i) =>
+                    verdicts[i] === 'edit' && record.shorthandProperty) : [];
+                if (shorthandEdits.length > 0) {
+                    const mixed = shorthandEdits.length !== records.filter((record, i) =>
+                        verdicts[i] === 'edit').length;
+                    if (existing || mixed || !refColumns) {
+                        if (!existing?.needsReview) {
+                            reviewItems.push({
+                                file: rel,
+                                line: ref.line,
+                                expression: (ref.content || '').trim(),
+                                suggestion: `Shorthand property "${name}" names the renamed binding: ` +
+                                    `write it as "${name}: ${options.renameTo}" (the key stays)`,
+                                needsReview: true,
+                                editKind: 'reference',
+                            });
+                        }
+                        continue;
+                    }
+                    const edit = renameIdentifierTokens(index, ref.file, ref.line, name,
+                        `${name}: ${options.renameTo}`, refColumns);
+                    if (edit.renamed === edit.source) continue;
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line: ref.line,
+                        expression: edit.source,
+                        suggestion: `Update reference: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        editKind: 'reference',
+                    }, edit));
+                    continue;
+                }
+                if (existing) {
+                    // A line another pass already edits (a call beside the
+                    // reference) gains the reference tokens.
+                    // A member pin's own `this.m` tokens join a bound call's
+                    // edit on the line (`this.m = this.m.bind(this)`, fix #397).
+                    if (verdict === 'edit' && (!def.className || ref.file === def.file) &&
+                        existing.newExpression !== undefined &&
+                        !existing.needsReview && refColumns) {
+                        const edit = renameIdentifierTokens(index, ref.file,
+                            ref.line, name, options.renameTo, refColumns);
+                        mergeTokenEdit(existing, edit);
+                    }
+                    continue;
+                }
                 if (verdict === 'edit') {
                     const edit = renameIdentifierTokens(index, ref.file,
-                        ref.line, name, options.renameTo,
-                        Number.isInteger(ref.column) ? [ref.column] : null);
+                        ref.line, name, options.renameTo, refColumns);
                     if (edit.renamed === edit.source) continue;
-                    changes.push({
+                    changes.push(tagTokenEdit({
                         file: rel,
                         line: ref.line,
                         expression: edit.source,
                         suggestion: `Update reference: ${edit.renamed}`,
                         newExpression: edit.renamed,
                         editKind: 'reference',
-                    });
+                    }, edit));
                 } else {
                     changes.push({
                         file: rel,
@@ -3214,8 +4800,26 @@ function plan(index, name, options = {}) {
                 const ref = refs[0];
                 const columns = refs.map(item => item.column)
                     .filter(Number.isInteger);
+                // A shorthand destructuring key (`const { body } = this`)
+                // reads the property into a local of the same name: the key
+                // is renamed and the local kept (`{ bodyZ: body }`, fix #397).
+                const shorthandKeys = refs.filter(item => item.patternKey?.shorthand);
+                if (shorthandKeys.length > 0 && (shorthandKeys.length !== refs.length ||
+                    columns.length !== refs.length)) {
+                    changes.push({
+                        file: ref.file,
+                        line: ref.line,
+                        expression: ref.expression,
+                        suggestion: `Rename the destructured property "${name}" to "${options.renameTo}" ` +
+                            'manually, keeping the local binding',
+                        needsReview: true,
+                        editKind: 'reference',
+                    });
+                    continue;
+                }
                 const edit = renameIdentifierTokens(index, ref.absoluteFile,
-                    ref.line, name, options.renameTo,
+                    ref.line, name, shorthandKeys.length > 0
+                        ? `${options.renameTo}: ${name}` : options.renameTo,
                     columns.length === refs.length ? columns : null);
                 if (edit.renamed === edit.source) continue;
                 const concrete = {
@@ -3232,7 +4836,11 @@ function plan(index, name, options = {}) {
                 if (existing) Object.assign(existing, concrete);
                 else changes.push(concrete);
             }
+            const listedAccess = new Set();
             for (const ref of accessorReferences.unverified) {
+                const lineKey = `${ref.file}:${ref.line}`;
+                if (listedAccess.has(lineKey)) continue;
+                listedAccess.add(lineKey);
                 changes.push({
                     file: ref.file,
                     line: ref.line,
@@ -3276,15 +4884,36 @@ function plan(index, name, options = {}) {
     const definitionSource = index.getLineContent(def.file, definitionLine).trim();
     const existingDefinitionLine = changes.find(change =>
         change.file === definitionFile && change.line === definitionLine);
-    if (existingDefinitionLine) {
+    // A definition a macro_rules! transcriber generated (fix #374) is
+    // spelled in the macro's template, never at the invocation: the
+    // template pass below edits or lists it; the invocation line is only
+    // pointed at for review.
+    if (def.macroExpansion?.origin === 'template') {
+        reviewItems.push({
+            file: definitionFile,
+            line: definitionLine,
+            expression: definitionSource,
+            suggestion: `Generated by macro ${def.macroExpansion.macro} (${def.macroExpansion.definition}); ` +
+                'the declaration is written in the macro template',
+            needsReview: true,
+            templateDependency: true,
+            editKind: 'macro-generated-definition',
+        });
+    } else if (existingDefinitionLine) {
         existingDefinitionLine.isDefinition = true;
         existingDefinitionLine.editKind = 'definition';
         if (options.renameTo) {
-            const renamed = renameIdentifierTokens(index, def.file,
+            const defEdit = renameIdentifierTokens(index, def.file,
                 definitionLine, name, options.renameTo,
-                null, null, { definitionNameOnly: true }).renamed;
-            existingDefinitionLine.newExpression = renamed;
-            existingDefinitionLine.suggestion = `Update definition: ${renamed}`;
+                null, null, { definitionNameOnly: true, definition: def });
+            // Keep the tokens the line's other edit renames (a recursive or
+            // delegating call on the declaration line) (fix #376).
+            if (!(existingDefinitionLine.newExpression !== undefined &&
+                mergeTokenEdit(existingDefinitionLine, defEdit))) {
+                existingDefinitionLine.newExpression = defEdit.renamed;
+                tagTokenEdit(existingDefinitionLine, defEdit);
+            }
+            existingDefinitionLine.suggestion = `Update definition: ${existingDefinitionLine.newExpression}`;
         }
     } else {
         const definitionChange = {
@@ -3295,11 +4924,13 @@ function plan(index, name, options = {}) {
             editKind: 'definition',
         };
         if (options.renameTo) {
-            const renamed = renameIdentifierTokens(index, def.file,
+            const defEdit = renameIdentifierTokens(index, def.file,
                 definitionLine, name, options.renameTo,
-                null, null, { definitionNameOnly: true }).renamed;
+                null, null, { definitionNameOnly: true, definition: def });
+            const renamed = defEdit.renamed;
             definitionChange.newExpression = renamed;
             definitionChange.suggestion = `Update definition: ${renamed}`;
+            tagTokenEdit(definitionChange, defEdit);
         } else {
             definitionChange.suggestion =
                 `Update declaration signature to: ${newSignature}`;
@@ -3311,6 +4942,674 @@ function plan(index, name, options = {}) {
         changes.unshift(definitionChange);
     }
 
+    // Members a macro invocation declares (fix #385: `ERROR_DEF(Base, Name)`
+    // in the class body expands to Name's constructors) are spelled by the
+    // invocation's argument: renaming the class renames that token too, or
+    // the expansion declares members of the old name.
+    if (options.renameTo && ['class', 'struct', 'union'].includes(def.type) &&
+        langTraits(planLang)?.textualIncludes) {
+        const invocationLines = new Set();
+        for (const member of index.files.get(def.file)?.symbols || []) {
+            if (!member.generatedByMacro || member.className !== def.name || member.name !== name ||
+                member.startLine < def.startLine || member.endLine > def.endLine) continue;
+            invocationLines.add(member.startLine);
+        }
+        for (const line of [...invocationLines].sort((a, b) => a - b)) {
+            if (changes.some(change => change.file === definitionFile && change.line === line)) continue;
+            const edit = renameIdentifierTokens(index, def.file, line, name, options.renameTo);
+            if (edit.renamed === edit.source) continue;
+            changes.push(markEvidence(tagTokenEdit({
+                file: definitionFile,
+                line,
+                expression: edit.source,
+                suggestion: `Rename the macro argument that declares members of ${name}: ${edit.renamed}`,
+                newExpression: edit.renamed,
+                editKind: 'reference',
+            }, edit)));
+        }
+    }
+
+    // C++ using-declarations that name the renamed entity (fix #385, the
+    // spdlog rename harness's silent breaks: `using details::os::
+    // filename_to_str;` before bare calls the plan already edits). The
+    // written qualifier resolves from the declaration's enclosing
+    // namespaces (macro-opened ones included); one that names the pin's
+    // namespace (or its class, for `using Base::m;`) is edited, one that
+    // only ends like it is listed for review.
+    if (options.renameTo && langTraits(planLang)?.textualIncludes) {
+        const { effectiveNamespace } = require('./cpp-scope');
+        const pinNamespace = def.className ? null : effectiveNamespace(index, def);
+        for (const [file, entry] of index.files) {
+            for (const fact of entry.cppUsings || []) {
+                if (fact.kind !== 'declaration' || fact.name !== name) continue;
+                const rel = entry.relativePath;
+                if (changes.some(change => change.file === rel && change.line === fact.line)) continue;
+                const absolute = fact.target.startsWith('::');
+                const qualifier = fact.target.replace(/^::/, '').split('::').slice(0, -1).join('::');
+                let exact = false;
+                let near = false;
+                if (def.className) {
+                    const owner = qualifier.split('::').pop();
+                    exact = owner === def.className;
+                } else {
+                    const site = effectiveNamespace(index, { file, startLine: fact.line, namespace: fact.namespace });
+                    const scopes = [];
+                    if (!absolute) {
+                        const parts = site ? site.split('::') : [];
+                        for (let i = parts.length; i > 0; i--) scopes.push(parts.slice(0, i).join('::'));
+                    }
+                    scopes.push('');
+                    exact = scopes.some(scope => (scope && qualifier ? `${scope}::${qualifier}` : scope || qualifier) === pinNamespace);
+                    near = !exact && (pinNamespace === qualifier || pinNamespace.endsWith(`::${qualifier}`));
+                }
+                if (!exact && !near) continue;
+                const edit = renameIdentifierTokens(index, file, fact.line, name, options.renameTo);
+                if (exact && edit.renamed !== edit.source) {
+                    changes.push(markEvidence(tagTokenEdit({
+                        file: rel,
+                        line: fact.line,
+                        expression: edit.source,
+                        suggestion: `Rename the using-declaration: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        editKind: 'reference',
+                    }, edit)));
+                } else {
+                    reviewItems.push({
+                        file: rel,
+                        line: fact.line,
+                        expression: index.getLineContent(file, fact.line).trim(),
+                        suggestion: `A using-declaration names "${name}" through a qualifier UCN cannot resolve to the renamed declaration; rename it with the declaration if it names it`,
+                        needsReview: true,
+                        editKind: 'reference',
+                    });
+                }
+            }
+        }
+    }
+
+    // Every token that names a renamed TYPE (fix #386): base clauses,
+    // field/parameter/return/local and generic-argument types, casts and
+    // type tests, static member qualifiers, constructor and destructor
+    // names, member initializers, qualified spellings and imports. Tokens
+    // are resolved by the language's own name lookup; a token UCN cannot
+    // resolve to exactly the renamed declaration is a review item.
+    let typePass = null;
+    const fileRenames = [];
+    if (options.renameTo && isTypeRenamePin(def) && planGroundSet &&
+        !def.macroExpansion) {
+        typePass = applyTypeReferencePass(index, {
+            def, name, renameTo: options.renameTo, changes, reviewItems,
+            planUnverified, groundSet: planGroundSet,
+        });
+        // javac requires a public top-level type in a file named after it:
+        // the file is renamed with the type.
+        const pathMod = require('path');
+        const extension = pathMod.extname(def.file);
+        if (langTraits(planLang)?.typeNamedSourceFile && !def.enclosingType && !def.isNested &&
+            pathMod.basename(def.file, extension) === name) {
+            const from = def.relativePath || pathMod.relative(index.root, def.file);
+            fileRenames.push({
+                from,
+                to: pathMod.join(pathMod.dirname(from), `${options.renameTo}${extension}`),
+            });
+        }
+    }
+
+    // Token pasting can spell the renamed name without writing it (fix
+    // #396: `struct sdshdr##T` in SDS_HDR_VAR, invoked as SDS_HDR_VAR(8, s)):
+    // the pasting macro and each invocation that produces the name are
+    // review items; nothing there spells the name to edit.
+    if (options.renameTo && langTraits(planLang)?.macroInvocationSyntax === 'call' && !def.macroExpansion) {
+        const { pastedNameSites } = require('./macro-expansion');
+        const pasted = pastedNameSites(index, name);
+        const taken = new Set([...changes, ...reviewItems].map(change => `${change.file}:${change.line}`));
+        const push = (file, line, suggestion) => {
+            const rel = path.relative(index.root, file);
+            if (taken.has(`${rel}:${line}`)) return;
+            taken.add(`${rel}:${line}`);
+            reviewItems.push({
+                file: rel,
+                line,
+                expression: (index.getLineContent(file, line) || '').trim(),
+                suggestion,
+                needsReview: true,
+                templateDependency: true,
+                reviewReason: 'macro-paste',
+                editKind: 'macro-expansion',
+            });
+        };
+        // A paste of parameters only (`a ## b`) can spell any name: its
+        // invocations decide, not its definition.
+        for (const macro of pasted.macros.filter(item =>
+            item.chains.some(chain => chain.some(op => op.literal != null)))) {
+            push(macro.symbol.file, macro.symbol.startLine,
+                `Macro ${macro.symbol.name} pastes \`${macro.spelling}\`, which can spell "${name}" at its ` +
+                'invocations; review the macro and its invocations');
+        }
+        for (const site of pasted.sites) {
+            push(site.file, site.line,
+                `Macro ${site.macro} pastes "${name}" at this invocation; change the macro arguments or ` +
+                `definition so the expansion spells "${options.renameTo}"`);
+        }
+    }
+
+    // A call site excluded inside a region the parser could not read (fix
+    // #396: a decoration macro defined in another header broke the member
+    // around it) was decided from a partial tree: listed for review, never
+    // dropped silently.
+    if (options.renameTo && planAccountParts?.excludedEntries?.length > 0) {
+        const taken = new Set([...changes, ...reviewItems].map(change => `${change.file}:${change.line}`));
+        const seen = new Set();
+        for (const entry of planAccountParts.excludedEntries) {
+            const regions = index.files.get(entry.file)?.parseErrorRegions;
+            if (!Array.isArray(regions) || !regions.some(([start, end]) => start <= entry.line && entry.line <= end)) continue;
+            const rel = path.relative(index.root, entry.file);
+            const key = `${rel}:${entry.line}`;
+            if (taken.has(key) || seen.has(key)) continue;
+            seen.add(key);
+            reviewItems.push({
+                file: rel,
+                line: entry.line,
+                expression: (index.getLineContent(entry.file, entry.line) || '').trim(),
+                suggestion: `This line sits in a region the parser could not fully read, where the call was ` +
+                    `excluded (${entry.reason}) from a partial tree; rename it too if it names this "${name}"`,
+                needsReview: true,
+                reviewReason: 'parse-recovery',
+                editKind: 'call',
+            });
+        }
+    }
+
+    // Documentation references the compiler resolves (fix #390): C# `cref`
+    // attributes naming the renamed member are edited (CS1574 fails the
+    // build once the member is gone); ones the lookup cannot settle are
+    // listed for review, not left as comment text.
+    if (options.renameTo && langTraits(planLang)?.docCrefReferences) {
+        const renamedDefs = [];
+        const sameNameDefs = index.symbols.get(name) || [];
+        for (const change of changes) {
+            if (change.editKind !== 'definition' || change.newExpression === undefined) continue;
+            for (const candidate of sameNameDefs) {
+                if ((candidate.relativePath || candidate.file) === change.file &&
+                    (candidate.nameLine || candidate.startLine) === change.line &&
+                    !renamedDefs.includes(candidate)) renamedDefs.push(candidate);
+            }
+        }
+        if (!renamedDefs.includes(def)) renamedDefs.push(def);
+        _docCrefMemberPass(index, name, options.renameTo, renamedDefs, changes, reviewItems);
+    }
+
+    // Method groups (fix #395): C# simple names and `this.`/`base.`/type
+    // accesses in value position that the language's lookup resolves to the
+    // renamed method (delegates, events, LINQ arguments, `nameof`).
+    if (options.renameTo && def.className && langTraits(planLang)?.methodGroupReferences &&
+        (def.type === 'method' || def.memberType === 'method' || def.isMethod)) {
+        const renamedDefs = [];
+        const sameNameDefs = index.symbols.get(name) || [];
+        for (const change of changes) {
+            if (change.editKind !== 'definition' || change.newExpression === undefined) continue;
+            for (const candidate of sameNameDefs) {
+                if ((candidate.relativePath || candidate.file) === change.file &&
+                    (candidate.nameLine || candidate.startLine) === change.line &&
+                    !renamedDefs.includes(candidate)) renamedDefs.push(candidate);
+            }
+        }
+        if (!renamedDefs.includes(def)) renamedDefs.push(def);
+        _methodGroupPass(index, name, options.renameTo, renamedDefs, changes,
+            planUsages || index.usages(name, { codeOnly: false, includeTests: true, internalEvidence: true }));
+    }
+
+    // Test functions the toolchain binds to a renamed declaration by NAME
+    // (fix #383): Go examples `Example<Type>_<Method>` fail go vet once the
+    // method is renamed alone. They are renamed with it (their definition
+    // token), or listed for review when the binding is ambiguous.
+    if (options.renameTo && langTraits(planLang)?.nameBoundTestFunctions) {
+        const renamedDefs = [];
+        const sameNameDefs = index.symbols.get(name) || [];
+        for (const change of changes) {
+            if (change.editKind !== 'definition' || change.newExpression === undefined) continue;
+            for (const candidate of sameNameDefs) {
+                if ((candidate.relativePath || candidate.file) === change.file &&
+                    (candidate.nameLine || candidate.startLine) === change.line &&
+                    !renamedDefs.includes(candidate)) renamedDefs.push(candidate);
+            }
+        }
+        const { nameBoundTestFunctions } = require('./test-name-bindings');
+        for (const bound of nameBoundTestFunctions(index, renamedDefs, name, options.renameTo)) {
+            const example = bound.def;
+            const rel = example.relativePath || example.file;
+            const line = example.nameLine || example.startLine;
+            if (changes.some(change => change.file === rel && change.line === line)) continue;
+            const edit = renameIdentifierTokens(index, example.file, line, example.name, bound.newName,
+                null, null, { definitionNameOnly: true, definition: example });
+            const reason = bound.binding === 'member'
+                ? `go vet binds ${example.name} to the renamed member`
+                : `go vet binds ${example.name} to the renamed identifier`;
+            if (bound.status === 'edit' && edit.renamed !== edit.source) {
+                // Keep the file's changes in line order.
+                const sameFile = changes.map((change, at) => ({ change, at }))
+                    .filter(item => item.change.file === rel);
+                const after = sameFile.find(item => item.change.line > line);
+                const at = after ? after.at
+                    : (sameFile.length > 0 ? sameFile[sameFile.length - 1].at + 1 : changes.length);
+                changes.splice(at, 0, tagTokenEdit({
+                    file: rel,
+                    line,
+                    expression: edit.source,
+                    newExpression: edit.renamed,
+                    suggestion: `Rename example (${reason}): ${edit.renamed}`,
+                    editKind: 'example',
+                }, edit));
+            } else {
+                reviewItems.push({
+                    file: rel,
+                    line,
+                    expression: edit.source,
+                    suggestion: bound.reason === 'example-referenced'
+                        ? `${reason}; it is also referenced as a function, so rename it to ${bound.newName} with its references`
+                        : `${example.name} may name the renamed declaration or a same-name declaration of another imported package; rename it to ${bound.newName} if it names this one`,
+                    needsReview: true,
+                    testBinding: true,
+                    reviewReason: bound.reason,
+                    editKind: 'example',
+                });
+            }
+        }
+    }
+
+    // A member assignment onto a function-local or undeclared object is not
+    // a project declaration (fix #359): its property name belongs to that
+    // object's own type, so the edit is withheld and routed to review.
+    if (options.renameTo) {
+        const ownerScope = memberAssignmentOwnerScope(index, def);
+        if (ownerScope === 'local' || ownerScope === 'external') {
+            const defChange = changes.find(change =>
+                change.file === definitionFile && change.line === definitionLine &&
+                change.editKind === 'definition');
+            if (defChange) {
+                delete defChange.newExpression;
+                defChange.needsReview = true;
+                defChange.reviewReason = ownerScope === 'local'
+                    ? 'member-assignment-local-object' : 'member-assignment-external-object';
+                defChange.suggestion = `Property assignment on ${ownerScope === 'local'
+                    ? 'function-local' : 'undeclared (runtime/global)'} object ` +
+                    `"${def.assignedReceiver}": "${name}" is that object's property, ` +
+                    'not a project declaration; rename only if you own its type';
+            }
+        }
+    }
+
+    // Contract membership (fix #360). A member that fills the slot of a
+    // contract outside the project cannot be renamed by editing project code:
+    // a definite membership (external trait impl, marked override with no
+    // project definer, language protocol or universal-supertype member)
+    // withholds every edit; a possible one (the owner declares out-of-project
+    // supertypes) keeps the edits and requires review at the definition and
+    // the declaration a compiler would reject. Go satisfaction sites the
+    // structural closure could not complete are listed where Go reports them.
+    // Single-element annotations (fix #389): `@Marker(x)` sets the element
+    // `value` without naming it. When the site's annotation type is the
+    // renamed element's owner, the rename names the element there
+    // (`@Marker(renamed = x)`); an undecided owner stays listed for review.
+    if (options.renameTo && planUnverified.some(site => site.annotationShorthand?.certain)) {
+        const pathMod = require('path');
+        const kept = [];
+        for (const site of planUnverified) {
+            const shorthand = site.annotationShorthand;
+            const abs = pathMod.isAbsolute(site.file) ? site.file : pathMod.join(index.root, site.file);
+            const text = shorthand?.certain && Number.isInteger(shorthand.column)
+                ? (index._getFileLines(abs)[site.line - 1] || '') : '';
+            if (!text || shorthand.column > text.length ||
+                changes.some(change => change.file === site.file && change.line === site.line)) {
+                kept.push(site);
+                continue;
+            }
+            const renamed = `${text.slice(0, shorthand.column)}${options.renameTo} = ${text.slice(shorthand.column)}`;
+            changes.push({
+                file: site.file,
+                line: site.line,
+                expression: text.trim(),
+                newExpression: renamed.trim(),
+                suggestion: `Name the element in the single-element annotation: ${renamed.trim()}`,
+                editKind: 'reference',
+            });
+        }
+        planUnverified.length = 0;
+        planUnverified.push(...kept);
+    }
+
+    // One source of truth for the plan's ACCOUNT (fix #376): a line the plan
+    // edits as a call is confirmed and a line it lists as unverified is
+    // unverified, whichever slot member's sweep contributed it; the pin's own
+    // exclusions only keep the lines no listed site claims.
+    if (options.renameTo && planAccountParts && planGroundSet &&
+        (slotAccountSites.length > 0 || planUnverified.length > 0 || typePass)) {
+        const pathMod = require('path');
+        const absoluteOf = file => (pathMod.isAbsolute(file) ? file : pathMod.join(index.root, file));
+        const editedCallLines = new Set(changes.filter(change =>
+            change.editKind === 'call').map(change => `${change.file}:${change.line}`));
+        const { buildAccount } = require('./account');
+        // A type rename decides the call-shaped lines of its references too
+        // (fix #386): edited ones are confirmed, the ones that provably name
+        // another declaration are excluded, and the ones left for review are
+        // listed with the unverified sites.
+        const typeDecided = typePass?.decided || new Map();
+        const relOf = file => pathMod.relative(index.root, file);
+        const typeClaims = (keys) => {
+            const confirmed = [];
+            const excluded = [];
+            for (const key of keys) {
+                const hit = typeDecided.get(key);
+                if (!hit) continue;
+                const line = Number(key.slice(key.lastIndexOf(':') + 1));
+                if (hit.edited) confirmed.push({ file: hit.abs, line });
+                else excluded.push({ file: hit.abs, line, reason: 'other-declaration' });
+            }
+            return { confirmed, excluded };
+        };
+        const build = (extra) => buildAccount(index, name, {
+            groundSet: planGroundSet,
+            confirmedEntries: [
+                ...planAccountParts.confirmedEntries,
+                ...slotAccountSites.filter(site => editedCallLines.has(`${site.file}:${site.line}`))
+                    .map(site => ({ file: site.absoluteFile || absoluteOf(site.file), line: site.line })),
+                ...extra.confirmed,
+            ],
+            unverifiedEntries: [
+                ...planAccountParts.unverifiedEntries.filter(entry =>
+                    !typeDecided.has(`${relOf(entry.file)}:${entry.line}`)),
+                ...planUnverified.map(site => ({ file: absoluteOf(site.file), line: site.line })),
+            ],
+            excludedEntries: [...extra.excluded, ...planAccountParts.excludedEntries],
+        });
+        let extra = typeClaims((typePass?.removed || []).map(site => `${site.file}:${site.line}`));
+        planAccount = build(extra);
+        if (typePass && planAccount.callNotResolved?.length > 0) {
+            // Call-shaped lines no engine candidate claimed: settled by the
+            // type pass, or listed with the unverified sites for review.
+            const keys = planAccount.callNotResolved.map(site =>
+                `${site.relativePath || relOf(site.file)}:${site.line}`);
+            const more = typeClaims(keys);
+            let listedMore = false;
+            for (const key of keys) {
+                const review = typePass.reviewed.get(key);
+                if (!review || planUnverified.some(site => `${site.file}:${site.line}` === key)) continue;
+                const line = Number(key.slice(key.lastIndexOf(':') + 1));
+                planUnverified.push({
+                    file: key.slice(0, key.lastIndexOf(':')),
+                    line,
+                    expression: (index._getFileLines(review.abs)[line - 1] || '').trim(),
+                    reason: `type-reference-${review.reason}`,
+                });
+                listedMore = true;
+            }
+            if (listedMore) {
+                planUnverified.sort((a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line);
+            }
+            if (more.confirmed.length > 0 || more.excluded.length > 0 || listedMore) {
+                extra = { confirmed: [...extra.confirmed, ...more.confirmed],
+                    excluded: [...extra.excluded, ...more.excluded] };
+                planAccount = build(extra);
+            }
+        }
+    }
+    let contract = null;
+    if (options.renameTo) {
+        const findings = [];
+        const seenMembers = new Set();
+        for (const member of [def, ...contractRootDefs]) {
+            const key = `${member.file}\0${member.startLine}`;
+            if (seenMembers.has(key)) continue;
+            seenMembers.add(key);
+            const finding = externalContractOf(index, member) ||
+                typedLiteralContract(index, member)?.external || null;
+            if (finding) findings.push({ member, ...finding });
+        }
+        // Hierarchy slot the closure could not complete (fix #376): a member
+        // marked as an override whose declaring ancestor was not located in
+        // the project cannot be renamed alone (the compiler rejects the
+        // marker, or dispatch silently changes); an ancestor spelling that
+        // resolves to no single project class may declare the slot too.
+        if (options.renameTo && def.className && !def.traitName &&
+            !findings.some(finding => finding.member === def)) {
+            const defSite = {
+                file: def.file,
+                relativePath: def.relativePath,
+                line: def.nameLine || def.startLine,
+            };
+            const ownerDecl = hierarchySlot?.pinRef?.def;
+            const classSites = ownerDecl && ownerDecl.file === def.file ? [{
+                file: ownerDecl.file,
+                relativePath: ownerDecl.relativePath || def.relativePath,
+                line: ownerDecl.startLine,
+            }] : [];
+            const unresolvedDeclaring = (hierarchySlot?.unresolved || []).filter(owner =>
+                (index.symbols.get(name) || []).some(member => member.className === owner));
+            if (isOverrideMarked(def) && !(hierarchySlot?.ancestors.length > 0)) {
+                findings.push({
+                    member: def,
+                    certainty: 'definite',
+                    via: unresolvedDeclaring.length > 0 ? unresolvedDeclaring
+                        : (hierarchySlot?.external.length > 0 ? hierarchySlot.external
+                            : [langTraits(planLang)?.universalSupertype || 'supertype']),
+                    reason: 'overrides-unlocated-member',
+                    sites: [defSite, ...classSites],
+                });
+            } else if (unresolvedDeclaring.length > 0) {
+                findings.push({
+                    member: def,
+                    certainty: 'possible',
+                    via: unresolvedDeclaring,
+                    reason: 'ancestor-unresolved',
+                    sites: [defSite, ...classSites],
+                });
+            }
+        }
+        // A decorator that replaces the callable receives its name too
+        // (fix #392): pytest fixtures, CLI commands, endpoints and registries
+        // bind the function by it. Decorators proven to keep the name out
+        // (standard ones, property accessors, project decorators that only
+        // call/return/wrap it) need nothing more.
+        {
+            const { nameBindingDecorators } = require('./decorator-binding');
+            const decoratorMemo = new Map();
+            const decorated = new Set();
+            // A pytest fixture is requested by name (fix #402): the
+            // parameters pytest injects it into are renamed with it, each
+            // with the uses that bind that parameter, and what pytest's
+            // resolution leaves open is listed for review.
+            const fixtureSites = options.renameTo && planLang === 'python'
+                ? require('./pytest-fixtures').fixtureParameterSites(index, def) : null;
+            if (fixtureSites) {
+                for (const site of fixtureSites.edits) {
+                    const rel = path.relative(index.root, site.file);
+                    const edit = renameIdentifierTokens(index, site.file, site.line, name,
+                        options.renameTo, site.byteColumns);
+                    if (edit.renamed === edit.source) continue;
+                    const existing = changes.find(change => change.file === rel && change.line === site.line);
+                    if (existing) {
+                        if (existing.newExpression !== undefined && !existing.needsReview) mergeTokenEdit(existing, edit);
+                        continue;
+                    }
+                    changes.push(tagTokenEdit({
+                        file: rel,
+                        line: site.line,
+                        expression: edit.source,
+                        suggestion: `Update fixture parameter: ${edit.renamed}`,
+                        newExpression: edit.renamed,
+                        editKind: 'reference',
+                    }, edit));
+                }
+                const reasonText = {
+                    'not-collected': 'pytest does not collect this module by default; if it is collected or imported into a test module, the parameter requests the fixture',
+                    'parametrized': 'the parameter is also a parametrize argument name',
+                    'plugin-fixture': 'the fixture is registered as a plugin and no project fixture of this name precedes it here',
+                    'class-fixtures': 'its class declares several fixtures of this name',
+                    'class-binding': 'its class binds the name',
+                    'class-bases': 'its class has bases whose fixtures are not resolved',
+                    'module-binding': 'the module binds the name otherwise than by one fixture definition',
+                    'module-import': 'the module imports the name from elsewhere',
+                    'module-namespace': 'the module may bind the name through a star import or a dynamically named fixture',
+                    'unreadable': 'a module on its fixture lookup path could not be read',
+                };
+                for (const site of fixtureSites.reviews) {
+                    const rel = path.relative(index.root, site.file);
+                    if (reviewItems.some(item => item.file === rel && item.line === site.line)) continue;
+                    reviewItems.push({
+                        file: rel,
+                        line: site.line,
+                        expression: (index.getLineContent(site.file, site.line) || '').trim(),
+                        suggestion: `pytest may inject fixture "${name}" here by name: ` +
+                            `${reasonText[site.reason] || site.reason}; rename the parameter if it requests this fixture`,
+                        needsReview: true,
+                        editKind: 'reference',
+                    });
+                }
+            }
+            for (const member of [def, ...contractRootDefs]) {
+                const key = `${member.file}\0${member.startLine}`;
+                if (decorated.has(key)) continue;
+                decorated.add(key);
+                let unproven = nameBindingDecorators(index, member, decoratorMemo);
+                // The fixture pass above settled pytest's name binding.
+                if (fixtureSites && !fixtureSites.dynamic && member === def) {
+                    const fileEntry = index.files.get(member.file);
+                    const vocab = langTraits(planLang)?.callableDecorators || {};
+                    const { resolveDecorator } = require('./async-producers');
+                    unproven = unproven.filter(text => resolveDecorator(text, fileEntry, vocab)?.name !== 'pytest.fixture');
+                }
+                if (unproven.length === 0) continue;
+                // Point at each decorator line the declaration spans.
+                const nameLine = member.nameLine || member.startLine;
+                const lines = index._getFileLines(member.file) || [];
+                const sites = [];
+                for (let line = Math.max(1, member.startLine); line < nameLine; line++) {
+                    const text = (lines[line - 1] || '').trim();
+                    if (unproven.some(deco => text.startsWith(`@${deco.split('(')[0]}`))) {
+                        sites.push({ file: member.file, relativePath: member.relativePath, line });
+                    }
+                }
+                if (sites.length === 0) {
+                    sites.push({ file: member.file, relativePath: member.relativePath, line: nameLine });
+                }
+                findings.push({
+                    member,
+                    certainty: 'possible',
+                    via: unproven.map(text => `@${text}`),
+                    reason: 'decorator-name-binding',
+                    sites,
+                });
+            }
+        }
+        const definite = findings.find(finding => finding.certainty === 'definite');
+        const defChange = changes.find(change =>
+            change.file === definitionFile && change.line === definitionLine &&
+            change.editKind === 'definition');
+        const describe = finding => {
+            const owner = finding.member.className || finding.member.registryContainer || finding.member.name;
+            const via = finding.via.join(', ');
+            switch (finding.reason) {
+                case 'implements-external-trait':
+                    return `${owner}.${name} implements external trait ${via}; the trait fixes the name`;
+                case 'language-protocol-member':
+                    return `${name} is a ${via} protocol member dispatched by name`;
+                case 'possible-protocol-member':
+                    return `${owner} derives from ${via} (outside the project), which may carry a runtime protocol that uses ${name} by name`;
+                case 'overrides-universal-supertype':
+                    return `${owner}.${name} overrides ${via}.${name}`;
+                case 'overrides-external-member':
+                    return `${owner}.${name} overrides a member of ${via} (outside the project)`;
+                case 'overrides-unlocated-member':
+                    return `${owner}.${name} is marked as an override, but the member it overrides (via ${via}) was not located in the project`;
+                case 'ancestor-unresolved':
+                    return `${owner} extends ${via}, which does not resolve to one project class; it may declare ${name} too`;
+                case 'implements-cfg-external-trait':
+                    return `${owner}.${name} implements ${via}, which is an external trait under some build configurations; the external trait fixes the name`;
+                case 'compiler-protocol-type':
+                    return `${via} is a type the compiler references by its full name for a language feature the project uses`;
+                case 'macro-generated-name':
+                    return `${name} is the callable the ${via} invocation defines; its name is generated by the macro, not written in the source`;
+                case 'macro-invocation':
+                    return `${name} is a function-like macro (${via}) in effect where it is declared; this declaration is an invocation of the macro, not a function`;
+                case 'standard-namespace-declaration':
+                    return `${name} is declared in the standard-library namespace ${via}; where the platform declares it, references bind the platform's`;
+                case 'typed-literal-external-member':
+                    return `${owner}.${name} is a member of an object typed ${via} (outside the project)`;
+                case 'decorator-name-binding':
+                    return `${via} receives ${name} and may bind it by its name (fixtures, commands, endpoints, registries); check what uses that name`;
+                default:
+                    return `${owner} declares ${via} (outside the project); ${name} may implement or override a member of it`;
+            }
+        };
+        const pushContractItem = (site, suggestion, reason) => {
+            const rel = site.relativePath || site.file;
+            if (reviewItems.some(item => item.file === rel && item.line === site.line &&
+                item.contractDependency)) return;
+            reviewItems.push({
+                file: rel,
+                line: site.line,
+                expression: (index.getLineContent(site.file, site.line) || '').trim(),
+                suggestion,
+                needsReview: true,
+                contractDependency: true,
+                reviewReason: reason,
+                editKind: 'contract',
+            });
+        };
+        if (definite) {
+            for (const change of changes) {
+                if (change.newExpression === undefined) continue;
+                delete change.newExpression;
+                change.needsReview = true;
+                change.reviewReason = change.reviewReason || 'contract-blocked';
+            }
+            if (defChange) {
+                defChange.needsReview = true;
+                defChange.reviewReason = definite.reason;
+                defChange.suggestion = `Rename blocked: ${describe(definite)}. ` +
+                    (definite.reason === 'macro-generated-name'
+                        ? 'Change the invocation that generates it instead'
+                        : definite.reason === 'macro-invocation' ? 'Rename the macro instead'
+                        : 'Renaming it here breaks the implementation; change the contract, not this member');
+            }
+        } else if (findings.length > 0 && defChange) {
+            defChange.needsReview = true;
+            defChange.reviewReason = findings[0].reason;
+            defChange.suggestion = `${defChange.suggestion}. Review: ${describe(findings[0])}`;
+        }
+        for (const finding of findings) {
+            for (const site of finding.sites) {
+                const siteRel = site.relativePath || site.file;
+                if (siteRel === definitionFile && site.line === definitionLine) continue;
+                pushContractItem(site, describe(finding), finding.reason);
+            }
+        }
+        for (const review of goContractReviews) {
+            pushContractItem(review, review.message, review.reason);
+        }
+        if (goContractReviews.length > 0 && defChange && !definite) {
+            defChange.needsReview = true;
+            defChange.reviewReason = defChange.reviewReason || 'contract-incomplete';
+        }
+        if (findings.length > 0 || goContractReviews.length > 0) {
+            contract = {
+                blocked: !!definite,
+                external: findings.map(finding => ({
+                    member: `${finding.member.relativePath || finding.member.file}:` +
+                        `${finding.member.nameLine || finding.member.startLine}`,
+                    certainty: finding.certainty,
+                    reason: finding.reason,
+                    via: finding.via,
+                })),
+                incomplete: goContractReviews.map(review => ({
+                    file: review.relativePath,
+                    line: review.line,
+                    reason: review.reason,
+                })),
+            };
+        }
+    }
+
     const changeSummary = {
         // editKind is a partition: a public declaration that is also an
         // export remains one definition edit, never two summary buckets.
@@ -3320,7 +5619,11 @@ function plan(index, name, options = {}) {
         imports: changes.filter(change => change.editKind === 'import').length,
         exports: changes.filter(change => change.editKind === 'export').length,
         references: changes.filter(change => change.editKind === 'reference').length,
-        textReferences: reviewItems.length,
+        examples: changes.filter(change => change.editKind === 'example').length,
+        textReferences: reviewItems.filter(item =>
+            !item.contractDependency && !item.templateDependency && !item.testBinding).length,
+        contracts: reviewItems.filter(item => item.contractDependency).length,
+        templates: reviewItems.filter(item => item.templateDependency).length,
         reviewRequired: changes.filter(change => change.needsReview).length +
             reviewItems.length,
     };
@@ -3344,11 +5647,13 @@ function plan(index, name, options = {}) {
         },
         totalChanges: changes.length,
         filesAffected: new Set([...changes, ...reviewItems].map(c => c.file)).size,
+        ...(fileRenames.length > 0 && { fileRenames }),
         changeSummary,
         changes,
         reviewItems,
         totalReviewItems: reviewItems.length,
         ...(unchangedSites > 0 && { unchangedSites }),
+        ...(contract && { contract }),
         // v4 tiered contract: sites that MAY also need this change but lack
         // binding/receiver evidence — review manually before refactoring.
         unverifiedCount: planUnverified.length,
@@ -3364,7 +5669,10 @@ function plan(index, name, options = {}) {
         }),
         ...(resolved.warnings.length > 0 && { warnings: resolved.warnings }),
     };
-    } finally { index._endOp(); }
+    } finally {
+        if (ownsTreeCache) clearTreeCache(index);
+        index._endOp();
+    }
 }
 
 /**
@@ -3441,4 +5749,384 @@ function analyzeCallSiteAST(index, filePath, lineNum, funcName) {
     return result;
 }
 
-module.exports = { verify, plan, analyzeCallSite, analyzeCallSiteAST, analyzeCallShape, classifyArgNode, findCallNode, clearTreeCache, identifyCallPatterns };
+/**
+ * C# XML documentation `cref` references to a renamed MEMBER (fix #390).
+ * Each `cref` spelling of the name is resolved the way the compiler resolves
+ * it: unqualified in the scope of the documented declaration (its type, the
+ * type's ancestors, then enclosing types), qualified through the named type.
+ * A cref reaching a renamed member is edited; one reaching another member,
+ * or naming a type or namespace, stays a comment-text item; one the lookup
+ * cannot settle (an unresolved type, part of an overload group without a
+ * parameter list) is a review item.
+ */
+function _docCrefMemberPass(index, name, renameTo, renamedDefs, changes, reviewItems) {
+    const pathMod = require('path');
+    const { ownerRefOf, resolveClassRef, findDeclaringClass } = require('./class-identity');
+    const renamed = new Set(renamedDefs);
+    const members = (index.symbols.get(name) || []).filter(d => d.className &&
+        !IDENTITY_TYPE_KINDS_FOR_CREF.has(d.type));
+    if (members.length === 0) return;
+    const classRefOf = (fileEntry, cls) => {
+        const entry = classDefsNamed(index, cls.name).entries.find(e => e.def === cls);
+        return entry ? { name: cls.name, key: entry.key, def: cls } : null;
+    };
+    const scopeOf = (abs, fileEntry, line) => {
+        // The documented declaration: the first one after the comment.
+        let next = null;
+        for (const symbol of fileEntry.symbols || []) {
+            if (symbol.startLine <= line) continue;
+            if (!next || symbol.startLine < next.startLine) next = symbol;
+        }
+        if (!next) return [];
+        const chain = [];
+        let ref = IDENTITY_TYPE_KINDS_FOR_CREF.has(next.type)
+            ? classRefOf(fileEntry, next) : ownerRefOf(index, next);
+        const seen = new Set();
+        while (ref && !seen.has(ref.key || ref.name)) {
+            seen.add(ref.key || ref.name);
+            chain.push(ref);
+            const outer = ref.def?.enclosingType;
+            ref = outer ? resolveClassRef(index, outer, abs, { namespace: ref.def.namespace || null }) : null;
+        }
+        return chain;
+    };
+    const paramKey = text => String(text || '').replace(/\b(?:ref|out|in|params|this)\b/g, '')
+        .replace(/[{<].*$/s, '').replace(/\s+/g, '').split('.').pop();
+    // 'edit' | 'skip' | 'review' for a member found through `declaring`.
+    const verdictFor = (declaring, paramsText) => {
+        if (!declaring) return 'skip';
+        if (declaring.uncertain) return 'review';
+        const found = declaring.members;
+        const hit = found.filter(member => renamed.has(member));
+        if (hit.length === 0) return 'skip';
+        if (hit.length === found.length) return 'edit';
+        if (paramsText == null) return 'review';
+        const wanted = paramsText.split(',').map(paramKey).filter(Boolean);
+        const selected = found.filter(member => {
+            const params = (member.paramsStructured || []).map(p => paramKey(p?.type));
+            return params.length === wanted.length && params.every((p, i) => p === wanted[i]);
+        });
+        if (selected.length !== 1) return 'review';
+        return renamed.has(selected[0]) ? 'edit' : 'skip';
+    };
+    const crefRe = /\bcref\s*=\s*"([^"]*)"/g;
+    const idRe = new RegExp(`(^|[^A-Za-z0-9_])(${escapeRegExp(name)})(?![A-Za-z0-9_])`, 'g');
+    for (let i = reviewItems.length - 1; i >= 0; i--) {
+        const item = reviewItems[i];
+        if (!item.textDependency) continue;
+        const abs = pathMod.join(index.root, item.file);
+        const fileEntry = index.files.get(abs);
+        if (!fileEntry || !langTraits(fileEntry.language)?.docCrefReferences) continue;
+        const text = index._getFileLines(abs)[item.line - 1] || '';
+        if (!/^\s*\/\/\//.test(text)) continue;
+        const edits = [];
+        let review = false;
+        let scope = null;
+        crefRe.lastIndex = 0;
+        let match;
+        while ((match = crefRe.exec(text)) !== null) {
+            const value = match[1];
+            const valueStart = match.index + match[0].indexOf('"') + 1;
+            const body = value.replace(/^[A-Za-z]:/, '  ');
+            idRe.lastIndex = 0;
+            let id;
+            while ((id = idRe.exec(body)) !== null) {
+                const start = id.index + id[1].length;
+                const after = body.slice(start + name.length);
+                // A qualifier segment (`Name.Member`) or generic type name.
+                if (/^\s*[.{<]/.test(after)) continue;
+                const paramsMatch = /^\s*\(([^)]*)\)/.exec(after);
+                const paramsText = paramsMatch ? paramsMatch[1] : null;
+                const qualifierText = body.slice(0, start).replace(/\.\s*$/, '');
+                const qualified = /\.\s*$/.test(body.slice(0, start));
+                let verdict;
+                if (qualified) {
+                    const segment = qualifierText.split('.').pop().trim();
+                    const generic = /\{([^}]*)\}\s*$/.exec(segment);
+                    const typeName = segment.replace(/\{.*$/, '').trim();
+                    const arity = generic ? generic[1].split(',').length : 0;
+                    const traits = langTraits(fileEntry.language);
+                    const ref = resolveClassRef(index, typeName, abs, {
+                        ...(traits?.genericArityIsIdentity && { arity }),
+                    });
+                    if (ref.external) verdict = 'skip';
+                    else if (!ref.key) verdict = 'review';
+                    else verdict = verdictFor(findDeclaringClass(index, ref, members), paramsText);
+                } else {
+                    if (!scope) scope = scopeOf(abs, fileEntry, item.line);
+                    if (scope.length === 0) verdict = 'review';
+                    else {
+                        verdict = 'skip';
+                        for (const ref of scope) {
+                            const declaring = findDeclaringClass(index, ref, members);
+                            if (!declaring) continue;
+                            verdict = verdictFor(declaring, paramsText);
+                            break;
+                        }
+                    }
+                }
+                if (verdict === 'edit') edits.push(valueStart + start);
+                else if (verdict === 'review') review = true;
+            }
+        }
+        if (review) {
+            item.textDependency = false;
+            item.reviewReason = 'doc-cref';
+            item.suggestion = `Verify whether this documentation reference names the renamed ${name} ` +
+                `and rename it to ${renameTo} if it does (the compiler resolves cref attributes)`;
+            continue;
+        }
+        if (edits.length === 0) continue;
+        let renamedText = text;
+        for (const column of edits.sort((a, b) => b - a)) {
+            renamedText = renamedText.slice(0, column) + renameTo + renamedText.slice(column + name.length);
+        }
+        reviewItems.splice(i, 1);
+        const change = tagTokenEdit({
+            file: item.file,
+            line: item.line,
+            expression: text.trim(),
+            newExpression: renamedText.trim(),
+            suggestion: `Update documentation reference: ${renamedText.trim()}`,
+            editKind: 'reference',
+        }, { columns: edits, rawSource: text, oldName: name, newName: renameTo, renamed: renamedText.trim() });
+        // Keep the file's changes in line order.
+        const sameFile = changes.map((other, at) => ({ other, at }))
+            .filter(entry => entry.other.file === item.file);
+        const after = sameFile.find(entry => entry.other.line > item.line);
+        const at = after ? after.at
+            : (sameFile.length > 0 ? sameFile[sameFile.length - 1].at + 1 : changes.length);
+        changes.splice(at, 0, change);
+    }
+}
+
+const CSHARP_TYPE_DECLARATION_NODES = new Set(['class_declaration', 'struct_declaration',
+    'record_declaration', 'record_struct_declaration', 'interface_declaration']);
+// Declarations whose `name` field binds a local of the member body.
+const CSHARP_LOCAL_DECLARATION_NODES = new Set(['parameter', 'catch_declaration', 'declaration_pattern',
+    'declaration_expression', 'variable_declarator', 'local_function_statement', 'from_clause',
+    'join_clause', 'query_continuation', 'recursive_pattern', 'var_pattern']);
+
+const CSHARP_BLOCK_SCOPES = new Set(['block', 'switch_section', 'for_statement', 'using_statement',
+    'fixed_statement', 'lambda_expression', 'anonymous_method_expression', 'arrow_expression_clause']);
+
+/**
+ * Where C# scopes a local named like the reference (spec 7.7): 'local' when
+ * a parameter, local variable, local function, pattern, lambda, foreach,
+ * catch or range variable of that name is in scope at `node`, 'none' when
+ * no declaration of the member reaches it, 'unknown' for an unmodelled
+ * declaration shape.
+ */
+function csharpLocalBinding(memberNode, node, name) {
+    const contains = (scope, target) => scope && scope.startIndex <= target.startIndex &&
+        target.endIndex <= scope.endIndex;
+    const nearest = (from, kinds) => {
+        for (let current = from.parent; current && !sameNode(current, memberNode); current = current.parent) {
+            if (kinds.has(current.type)) return current;
+        }
+        return memberNode;
+    };
+    let verdict = 'none';
+    const scopeOf = (declared) => {
+        const parent = declared.parent;
+        switch (parent.type) {
+            case 'parameter': {
+                const owner = parent.parent?.parent;
+                return owner || memberNode;
+            }
+            case 'variable_declarator': case 'local_function_statement':
+            case 'declaration_pattern': case 'declaration_expression': case 'single_variable_designation':
+            case 'recursive_pattern': case 'var_pattern':
+                return nearest(parent, CSHARP_BLOCK_SCOPES);
+            case 'catch_declaration':
+                return parent.parent;
+            case 'foreach_statement':
+                return parent;
+            case 'from_clause': case 'join_clause': case 'let_clause': case 'query_continuation':
+                return nearest(parent, new Set(['query_expression']));
+            default:
+                return null;
+        }
+    };
+    const visit = current => {
+        if (verdict === 'local') return;
+        if ((current.type === 'implicit_parameter' || current.type === 'identifier') && current.text === name &&
+            !sameNode(current, node)) {
+            const parent = current.parent;
+            let declares = current.type === 'implicit_parameter';
+            if (!declares && parent) {
+                declares = (CSHARP_LOCAL_DECLARATION_NODES.has(parent.type) &&
+                    sameNode(parent.childForFieldName('name'), current) && !sameNode(parent, memberNode)) ||
+                    (parent.type === 'foreach_statement' && sameNode(parent.childForFieldName('left'), current)) ||
+                    parent.type === 'single_variable_designation' ||
+                    (parent.type === 'let_clause' && sameNode(parent.namedChild(0), current));
+            }
+            if (declares) {
+                const scope = current.type === 'implicit_parameter' ? parent : scopeOf(current);
+                if (!scope) verdict = 'unknown';
+                else if (contains(scope, node)) verdict = 'local';
+            }
+            return;
+        }
+        for (const child of current.namedChildren || []) visit(child);
+    };
+    for (const child of memberNode.namedChildren || []) visit(child);
+    return verdict;
+}
+
+/**
+ * Method groups in a C# member rename (fix #395): a simple name in value
+ * position (`new(Build, 4)`, `Changed += OnChanged`, `.Select(Build)`,
+ * `Func<int> f = Build`, `nameof(Build)`), a `this.`/`base.` access or a
+ * type-qualified `Host.Build` names a method group, found by C# simple-name
+ * lookup (spec 12.8.4): a local of that name in the enclosing member hides
+ * it (review); then the enclosing class and its ancestry, then each
+ * enclosing class outward. The first class that declares the name decides:
+ * its members of that name are the renamed ones - an edit; the renamed ones
+ * beside others (an overload chosen by the delegate's signature) or an
+ * unresolved ancestry - a review item; none - not the pin.
+ */
+function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
+    const pathMod = require('path');
+    const { resolveClassRef, findDeclaringClass, parentRefsOf } = require('./class-identity');
+    const renamed = new Set(renamedDefs);
+    const members = (index.symbols.get(name) || []).filter(d => d.className &&
+        !IDENTITY_TYPE_KINDS_FOR_CREF.has(d.type));
+    if (!members.some(member => renamed.has(member))) return;
+    const verdictOf = declaring => {
+        if (!declaring) return null;
+        if (declaring.uncertain) return 'review';
+        const hit = declaring.members.filter(member => renamed.has(member));
+        if (hit.length === 0) return 'skip';
+        return hit.length === declaring.members.length ? 'edit' : 'review';
+    };
+    const classRefAt = (file, declNode) => {
+        const nameNode = declNode.childForFieldName('name');
+        if (!nameNode) return null;
+        const line = nameNode.startPosition.row + 1;
+        const entry = classDefsNamed(index, nameNode.text).entries.find(e => e.def.file === file &&
+            (e.def.nameLine || e.def.startLine) <= line && e.def.endLine >= line &&
+            e.def.startLine <= line);
+        return entry ? { name: nameNode.text, key: entry.key, def: entry.def } : null;
+    };
+    const openAncestry = ref => parentRefsOf(index, ref).some(parent => parent.external || !parent.key);
+    const verdictFor = (ref, tree) => {
+        const row = ref.line - 1;
+        const column = Number.isInteger(ref.column) ? ref.column : null;
+        if (column == null || !tree) return 'review';
+        const node = tree.rootNode.descendantForPosition({ row, column });
+        if (!node || node.type !== 'identifier' || node.text !== name) return 'review';
+        const types = [];
+        let member = null;
+        for (let current = node.parent; current; current = current.parent) {
+            if (CSHARP_TYPE_DECLARATION_NODES.has(current.type)) types.push(current);
+            else if (types.length === 0 && current.parent?.type === 'declaration_list') member = current;
+        }
+        if (types.length === 0) return 'review';
+        const receiver = ref.receiver || null;
+        if (receiver && receiver !== 'this' && receiver !== 'base') {
+            // `Host.Build`: a static method group of the named class.
+            if (!/^[A-Z]/.test(receiver)) return null;
+            const typeRef = resolveClassRef(index, receiver, ref.file, { line: ref.line });
+            if (!typeRef?.key) return typeRef?.external ? null : 'review';
+            return verdictOf(findDeclaringClass(index, typeRef, members)) === 'edit' ? 'edit'
+                : verdictOf(findDeclaringClass(index, typeRef, members)) === 'review' ? 'review' : null;
+        }
+        if (!receiver && member) {
+            const local = csharpLocalBinding(member, node, name);
+            if (local === 'local') return null;
+            if (local === 'unknown') return 'review';
+        }
+        for (let i = 0; i < types.length; i++) {
+            const classRef = classRefAt(ref.file, types[i]);
+            if (!classRef) return 'review';
+            const declaring = findDeclaringClass(index, classRef, members,
+                receiver === 'base' ? { parentsOnly: true } : {});
+            const verdict = verdictOf(declaring);
+            if (verdict === 'skip') return null;
+            if (verdict) return verdict;
+            // `this.`/`base.` name the innermost class only; a simple name
+            // continues outward unless an unmodelled base could declare it.
+            if (receiver || openAncestry(classRef)) return receiver ? null : 'review';
+        }
+        return null;
+    };
+    const trees = new Map();
+    const treeOf = file => {
+        if (trees.has(file)) return trees.get(file);
+        let tree;
+        try {
+            const content = index._readFile(file);
+            tree = index._getParsedTree?.(file, content, 'csharp') || safeParse(getParser('csharp'), content);
+        } catch { tree = null; }
+        trees.set(file, tree);
+        return tree;
+    };
+    // Only simple names and `this.`/`base.`/type-qualified accesses can name
+    // the method group; other member accesses are never parsed for.
+    const candidateRecord = record => record.usageType === 'reference' && !record.isDefinition &&
+        (!record.receiver || record.receiver === 'this' || record.receiver === 'base' ||
+            /^[A-Z]/.test(String(record.receiver)));
+    for (const first of usages) {
+        if (first.usageType !== 'reference' || first.isDefinition) continue;
+        const abs = first.file;
+        if (!langTraits(index.files.get(abs)?.language)?.methodGroupReferences) continue;
+        const records = [first, ...(first.sameLine || [])].filter(candidateRecord);
+        if (records.length === 0) continue;
+        const rel = first.relativePath || pathMod.relative(index.root, abs);
+        const edits = [];
+        let review = false;
+        for (const record of records) {
+            const verdict = verdictFor({ ...record, file: abs }, treeOf(abs));
+            if (verdict === 'edit') edits.push(record.column);
+            else if (verdict === 'review') review = true;
+        }
+        if (edits.length === 0 && !review) continue;
+        const existing = changes.find(change => change.file === rel && change.line === first.line);
+        if (existing) {
+            if (edits.length > 0 && existing.newExpression !== undefined && !existing.needsReview) {
+                mergeTokenEdit(existing, renameIdentifierTokens(index, abs, first.line, name, renameTo, edits));
+            }
+            if (review && !existing.needsReview) {
+                existing.needsReview = true;
+                existing.reviewReason = existing.reviewReason || 'method-group';
+            }
+            continue;
+        }
+        let change;
+        if (edits.length > 0 && !review) {
+            const edit = renameIdentifierTokens(index, abs, first.line, name, renameTo, edits);
+            if (edit.renamed === edit.source) continue;
+            change = tagTokenEdit({
+                file: rel,
+                line: first.line,
+                expression: edit.source,
+                suggestion: `Update method group reference: ${edit.renamed}`,
+                newExpression: edit.renamed,
+                editKind: 'reference',
+            }, edit);
+        } else {
+            change = {
+                file: rel,
+                line: first.line,
+                expression: (first.content || index.getLineContent(abs, first.line) || '').trim(),
+                suggestion: `Verify whether this method group names the renamed ${name} ` +
+                    `(an overload chosen by the delegate type, or a local of that name) and rename it to ${renameTo} if it does`,
+                needsReview: true,
+                reviewReason: 'method-group',
+                editKind: 'reference',
+            };
+        }
+        // Keep the file's changes in line order.
+        const sameFile = changes.map((other, at) => ({ other, at }))
+            .filter(entry => entry.other.file === rel);
+        const after = sameFile.find(entry => entry.other.line > first.line);
+        const at = after ? after.at
+            : (sameFile.length > 0 ? sameFile[sameFile.length - 1].at + 1 : changes.length);
+        changes.splice(at, 0, change);
+    }
+}
+
+const IDENTITY_TYPE_KINDS_FOR_CREF = new Set(['class', 'struct', 'interface', 'record', 'enum', 'trait', 'type']);
+
+module.exports = { verify, plan, baseCounterpartOf, sitesReboundByChange, computePlanCallSites, analyzeCallSite, analyzeCallSiteAST, analyzeCallShape, classifyArgNode, findCallNode, clearTreeCache, identifyCallPatterns };