ucn 5.5.1 → 5.5.3

package/core/verify.js

@@ -7,10 +7,12 @@
 
 const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits } = require('../languages');
 const { sameNode } = require('../languages/utils');
-const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES, isOverrideMarked, isMacroNamespaceDefinition } = require('./shared');
-const { classDefsNamed, distinctOwnerDefinitions } = require('./class-identity');
-const { isTypeRenamePin } = require('./type-references');
+const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES, isOverrideMarked, isMacroNamespaceDefinition,
+    isValueDefinition } = require('./shared');
+const { classDefsNamed, ownerDefinitionOf, ownerRefOf, descendsFromTargets } = require('./class-identity');
+const { isTypeRenamePin, referenceRole } = require('./type-references');
 const { findAccessorReferences, isAccessorDefinition } = require('./accessors');
+const { csharpLocalBinding } = require('../languages/csharp-scope');
 const { validateCallMismatch, declarationIdentity } = require('./provenance');
 const { UcnError } = require('./errors');
 const { execFileSync, spawn } = require('child_process');
@@ -140,6 +142,66 @@ function selfMemberTokenColumns(index, filePath, lineNumber, name) {
     return out;
 }
 
+/**
+ * The object-pattern keys `name` on `lineNumber` of declarators that read an
+ * identifier (fix #423): `const { name } = src` / `const { name: local } =
+ * src`, defaults included. Returns [{ line, column, shorthand, local,
+ * source }]; nested patterns read members of members and are not listed.
+ */
+function objectPatternKeysAt(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 text = content.split('\n')[lineNumber - 1] || '';
+    if (!text.includes(name)) return [];
+    const tree = index._getParsedTree?.(absolute, content, language) || safeParse(parser, content);
+    if (!tree) return [];
+    const out = [];
+    for (let at = text.indexOf(name); at !== -1; at = text.indexOf(name, at + 1)) {
+        const node = tree.rootNode.descendantForPosition({ row: lineNumber - 1, column: at });
+        if (!node || node.text !== name || node.startPosition.column !== at) continue;
+        let property = node;
+        let shorthand = false;
+        let local = name;
+        if (node.type === 'shorthand_property_identifier_pattern') {
+            shorthand = true;
+            if (node.parent?.type === 'object_assignment_pattern') property = node.parent;
+        } else if (node.type === 'property_identifier' && node.parent?.type === 'pair_pattern' &&
+            sameNode(node.parent.childForFieldName('key'), node)) {
+            property = node.parent;
+            const value = property.childForFieldName('value');
+            const target = value?.type === 'assignment_pattern' ? value.childForFieldName('left') : value;
+            if (target?.type !== 'identifier') continue;
+            local = target.text;
+        } else continue;
+        const pattern = property.parent;
+        const declarator = pattern?.parent;
+        if (pattern?.type !== 'object_pattern' || declarator?.type !== 'variable_declarator' ||
+            !sameNode(declarator.childForFieldName('name'), pattern)) continue;
+        const source = declarator.childForFieldName('value');
+        if (source?.type !== 'identifier') continue;
+        out.push({ line: lineNumber, column: at, ...(shorthand && { shorthand: true }), local, source: source.text });
+    }
+    return out;
+}
+
+// The embedded-script tree of a file's content (fix #419), the last few
+// contents kept.
+const EMBEDDED_TREES = new Map();
+function embeddedTree(embedded, parser, content) {
+    if (EMBEDDED_TREES.has(content)) return EMBEDDED_TREES.get(content);
+    const scriptParser = parser && getParser(embedded.language);
+    const source = scriptParser ? embedded.source(content, parser) : null;
+    const tree = source ? safeParse(scriptParser, source) : null;
+    if (EMBEDDED_TREES.size >= 8) EMBEDDED_TREES.delete(EMBEDDED_TREES.keys().next().value);
+    EMBEDDED_TREES.set(content, tree);
+    return tree;
+}
+
 /** Replace only AST identifier tokens on one source line. */
 function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
     preferredByteColumns = null, expectedCallCount = null, tokenOptions = {}) {
@@ -150,13 +212,33 @@ function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
     let byteColumns = Array.isArray(preferredByteColumns)
         ? preferredByteColumns.filter(Number.isInteger) : [];
     const defNameByteColumns = [];
+    let syntaxDerived = false;
+    let declarationSyntax = null;
+    if (byteColumns.length === 0 && tokenOptions.definitionNameOnly) {
+        declarationSyntax = require('./rename-token-syntax').declarationTokenSyntax(index, absolute,
+            index.files.get(absolute), content, lineNumber, oldName, tokenOptions.definition,
+            preferredByteColumns == null);
+        if (declarationSyntax?.columns) {
+            byteColumns = declarationSyntax.columns;
+            syntaxDerived = true;
+        }
+    }
 
-    if (byteColumns.length === 0) {
+    if (byteColumns.length === 0 && !syntaxDerived) {
         const language = index.files.get(absolute)?.language ||
             detectLanguage(absolute, index.root);
         const parser = language && getParser(language);
-        const tree = parser && (index._getParsedTree?.(absolute, content, language) ||
-            safeParse(parser, content));
+        // A file whose code is embedded (HTML scripts) is read in the
+        // script's own syntax, rows and columns kept (fix #419).
+        const embedded = langTraits(language)?.embeddedSyntax;
+        let tree = embedded ? embeddedTree(embedded, parser, content) : parser &&
+            (index._getParsedTree?.(absolute, content, language) || safeParse(parser, content));
+        // A row another configuration view reads (fix #426: a C# `#else`
+        // branch of a file whose literal parse was damaged) is blank in the
+        // primary view: its tokens are that view's.
+        const ownerView = tree && langTraits(language)?.queryBodyViews?.(tree)
+            ?.find(view => view.owns?.has(lineNumber - 1));
+        if (ownerView?.tree) tree = ownerView.tree;
         if (tree) {
             const targetRow = lineNumber - 1;
             const stack = [tree.rootNode];
@@ -231,6 +313,7 @@ function renameIdentifierTokens(index, filePath, lineNumber, oldName, newName,
     const columns = [...new Set(byteColumns
         .map(column => tokenColumn(sourceLine, column, oldName))
         .filter(Number.isInteger))].sort((a, b) => b - a);
+    if (!syntaxDerived) declarationSyntax?.save(columns);
     if (expectedCallCount != null && columns.length !== expectedCallCount) {
         return { source: sourceLine.trim(), renamed: sourceLine.trim(), count: 0 };
     }
@@ -256,13 +339,24 @@ 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;
+    const entry = index.files.get(absolute);
+    const language = entry?.language;
     let content;
     try { content = index._readFile(absolute); } catch { return null; }
-    const tree = index._getParsedTree?.(absolute, content, language) || safeParse(parser, content);
-    if (!tree) return null;
+    return require('./rename-token-syntax').callTokenSyntax(index, absolute, entry,
+        content, range, name, line, () => {
+            const parser = language && getParser(language);
+            let tree = parser &&
+                (index._getParsedTree?.(absolute, content, language) || safeParse(parser, content));
+            // A row another configuration view reads (fix #426).
+            const ownerView = tree && langTraits(language)?.queryBodyViews?.(tree)
+                ?.find(view => view.owns?.has(line - 1));
+            if (ownerView?.tree) tree = ownerView.tree;
+            return tree ? callTokenColumnInTree(tree, content, range, name, line) : null;
+        });
+}
+
+function callTokenColumnInTree(tree, content, range, name, line) {
     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;
@@ -273,20 +367,25 @@ function callTokenColumn(index, filePath, range, name, line) {
         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) &&
+    const isPlainName = n => n && n.text === name && /identifier$/.test(n.type) &&
         n.startPosition.row === line - 1;
-    if (isName(node)) return node.startPosition.column;
+    // A generic callee head (`r.Get<int>(2)`, C++ `get<int>(1)`) names the
+    // call by its identifier, the type arguments aside (fix #426).
+    const isName = n => isPlainName(n) || (n && /generic_name$|^template_(?:function|method)$/.test(n.type) &&
+        isPlainName(n.childForFieldName?.('name') || n.namedChild(0)));
+    const nameColumn = n => (isPlainName(n) ? n : (n.childForFieldName?.('name') || n.namedChild(0))).startPosition.column;
+    if (isName(node)) return nameColumn(node);
     // 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;
+    if (isName(callee)) return nameColumn(callee);
     const named = ['property', 'attribute', 'field', 'name'];
     for (const field of named) {
         const part = callee.childForFieldName?.(field);
-        if (isName(part)) return part.startPosition.column;
+        if (isName(part)) return nameColumn(part);
     }
     return null;
 }
@@ -304,20 +403,31 @@ function mergeTokenEdit(change, edit) {
         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 aliasColumns = [...new Set([...(prior.aliasColumns || []), ...(edit.aliasColumns || [])])];
+    const renamed = renameColumns(prior.rawSource, columns, prior.oldName, prior.newName, aliasColumns);
     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 });
+    tagTokenEdit(change, { ...prior, columns, renamed: change.newExpression,
+        ...(aliasColumns.length > 0 && { aliasColumns }) });
     return true;
 }
 
+/** Replace the name at code-unit columns (descending), aliasing the
+ * import bindings among them (`name as newName`). */
+function renameColumns(raw, columns, oldName, newName, aliasColumns = []) {
+    const aliased = new Set(aliasColumns);
+    let renamed = raw;
+    for (const column of [...columns].sort((a, b) => b - a)) {
+        if (renamed.slice(column, column + oldName.length) !== oldName) continue;
+        const replacement = aliased.has(column) ? `${oldName} as ${newName}` : newName;
+        renamed = renamed.slice(0, column) + replacement + renamed.slice(column + oldName.length);
+    }
+    return renamed;
+}
+
 /**
  * Mark a change whose tokens a dedicated pass proved (a macro argument that
  * declares the renamed class, an exactly resolved using-declaration): the
@@ -560,22 +670,47 @@ function _collectCallNodes(node, 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;
+    // A wide node (a file's top level, a class body) keeps its children's
+    // rows for the tree's lifetime: every call site of the file searches
+    // them (fix #436: two native reads per probe, per site).
+    const rows = count > 16 ? _childRowsOf(node) : null;
     let lo = 0;
     let hi = count;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
-        if (node.child(mid).endPosition.row < targetRow) lo = mid + 1;
+        if ((rows ? rows.ends[mid] : node.child(mid).endPosition.row) < targetRow) lo = mid + 1;
         else hi = mid;
     }
     for (let i = lo; i < count; i++) {
+        if (rows && rows.starts[i] > targetRow) break;
         const child = node.child(i);
-        if (child.startPosition.row > targetRow) break;
+        if (!rows && child.startPosition.row > targetRow) break;
         _collectCallNodes(child, callTypes, targetRow, funcName, limit, out);
         if (out.length >= limit) return out;
     }
     return out;
 }
 
+const CHILD_ROWS = new WeakMap(); // tree -> Map(node id -> { starts, ends })
+function _childRowsOf(node) {
+    const tree = node.tree;
+    if (!tree) return null;
+    let byNode = CHILD_ROWS.get(tree);
+    if (!byNode) CHILD_ROWS.set(tree, byNode = new Map());
+    let rows = byNode.get(node.id);
+    if (!rows) {
+        const count = node.childCount;
+        rows = { starts: new Int32Array(count), ends: new Int32Array(count) };
+        for (let i = 0; i < count; i++) {
+            const child = node.child(i);
+            rows.starts[i] = child.startPosition.row;
+            rows.ends[i] = child.endPosition.row;
+        }
+        byNode.set(node.id, rows);
+    }
+    return rows;
+}
+
 /**
  * Clear the AST tree cache (call after batch operations)
  * @param {object} index - ProjectIndex instance
@@ -668,6 +803,34 @@ function computeModifierTokens(def) {
     return tokens;
 }
 
+/**
+ * A parameter list as source text. Python binding-position markers (fix
+ * #281): the bare `*` before the first keyword-only param (unless `*args`
+ * already plays that role) and the `/` after the last positional-only
+ * param, so the signature matches the source contract (fix #424: a changed
+ * list keeps them too).
+ */
+function formatTypedParamList(ps, paramTypes = {}) {
+    const lastPosOnly = ps.reduce(
+        (acc, p, i) => (p && p.positionalOnly ? i : acc), -1);
+    let starShown = false;
+    const parts = [];
+    ps.forEach((p, i) => {
+        // Apply paramTypes mapping when paramsStructured doesn't carry types
+        const merged = { ...p };
+        if (!merged.type && paramTypes?.[p.name]) merged.type = paramTypes[p.name];
+        if (p && p.rest && /^\*(?!\*)/.test(String(p.name))) starShown = true;
+        if (!starShown && p && p.keywordOnly) {
+            parts.push('*');
+            starShown = true;
+        }
+        const tok = formatTypedParam(merged);
+        if (tok) parts.push(tok);
+        if (i === lastPosOnly) parts.push('/');
+    });
+    return parts.join(', ');
+}
+
 /**
  * Build a function signature string from a definition, using
  * TS-correct param formatting (BUG-BV). Local to verify.js to avoid
@@ -686,29 +849,7 @@ function formatTypedSignature(def, overrides = {}) {
     parts.push(name);
     const ps = overrides.paramsStructured != null ? overrides.paramsStructured : def.paramsStructured;
     if (Array.isArray(ps)) {
-        const paramTypes = def.paramTypes || {};
-        // Python binding-position markers (fix #281): re-render the bare `*`
-        // before the first keyword-only param (unless `*args` already plays
-        // that role) and the `/` after the last positional-only param, so the
-        // displayed signature matches the source contract.
-        const lastPosOnly = ps.reduce(
-            (acc, p, i) => (p && p.positionalOnly ? i : acc), -1);
-        let starShown = false;
-        const parts2 = [];
-        ps.forEach((p, i) => {
-            // Apply paramTypes mapping when paramsStructured doesn't carry types
-            const merged = { ...p };
-            if (!merged.type && paramTypes[p.name]) merged.type = paramTypes[p.name];
-            if (p && p.rest && /^\*(?!\*)/.test(String(p.name))) starShown = true;
-            if (!starShown && p && p.keywordOnly) {
-                parts2.push('*');
-                starShown = true;
-            }
-            const tok = formatTypedParam(merged);
-            if (tok) parts2.push(tok);
-            if (i === lastPosOnly) parts2.push('/');
-        });
-        parts.push(`(${parts2.join(', ')})`);
+        parts.push(`(${formatTypedParamList(ps, def.paramTypes)})`);
     } else if (def.params !== undefined) {
         parts.push(`(${def.params})`);
     }
@@ -735,7 +876,7 @@ function formatTypedSignature(def, overrides = {}) {
  */
 function extractArrowTypesFromVarDecl(index, def) {
     if (!def || !def.file || !def.startLine) return null;
-    const lang = detectLanguage(def.file);
+    const lang = index.languageOf(def.file);
     if (lang !== 'typescript' && lang !== 'tsx') return null;
     // Already have types — nothing to enrich.
     const ps = def.paramsStructured;
@@ -853,8 +994,8 @@ function extractArrowTypesFromVarDecl(index, def) {
  * `new Task(id, name)` against 0..0 — a false red on every parameterized
  * constructor, in every language. Sources: indexed constructor members
  * (JS/TS `constructor`, Python `__init__` — emitted with type
- * 'constructor'), or a Java AST walk (constructors are deliberately not
- * indexed as members there). Returns an array of paramsStructured lists —
+ * 'constructor'), or a Java AST walk for an implicit record constructor.
+ * Returns an array of paramsStructured lists —
  * one per constructor overload — or null when the class declares none.
  * @param {object} index - ProjectIndex instance
  * @param {object} def - Resolved definition (any type; non-class returns null)
@@ -864,20 +1005,26 @@ function extractArrowTypesFromVarDecl(index, def) {
 function _constructorParamLists(index, def, lang) {
     if (!def || !def.file || !['class', 'struct', 'enum', 'record'].includes(def.type)) return null;
     const lists = [];
+    const { isConstructor } = require('./constructor-calls');
+    const seen = new Set();
+    const append = d => {
+        if (seen.has(d) || !isConstructor(d, index)) return;
+        seen.add(d); lists.push(d.paramsStructured);
+    };
     const endLine = def.endLine != null ? def.endLine : Infinity;
     const inRange = (d) => d.file === def.file &&
         d.startLine >= def.startLine && d.startLine <= endLine &&
         Array.isArray(d.paramsStructured);
     for (const ctorName of ['constructor', '__init__']) {
         for (const d of (index.symbols.get(ctorName) || [])) {
-            if (d.className === def.name && inRange(d)) lists.push(d.paramsStructured);
+            if (d.className === def.name && inRange(d)) append(d);
         }
     }
     // Java constructor members are named after the CLASS (enum-body
     // constructors carry paramsStructured since fix #230).
     for (const d of (index.symbols.get(def.name) || [])) {
         if (d.type === 'constructor' && d.className === def.name && inRange(d)) {
-            lists.push(d.paramsStructured);
+            append(d);
         }
     }
     if (lists.length > 0) return lists;
@@ -951,6 +1098,7 @@ function contractedCallerSweep(index, name, def, options = {}) {
         includeMethods: true,
         targetDefinitions: [def],
         collectAccount: true,
+        ...(options.constructionSites === false && { constructorProjection: false }),
     });
 
     const confirmed = [];
@@ -1039,7 +1187,8 @@ function contractedCallerSweep(index, name, def, options = {}) {
 // overloads.
 
 // Exclusions whose verdict depends on the pin's declared parameters.
-const SIGNATURE_DEPENDENT_EXCLUSIONS = new Set(['arity-mismatch', 'overload-mismatch', 'generic-arity-mismatch']);
+const SIGNATURE_DEPENDENT_EXCLUSIONS = new Set(['arity-mismatch', 'overload-mismatch', 'generic-arity-mismatch',
+    'constructor-overload-other']);
 
 /** Declared parameter shape (types, optional/default/rest, method type parameters); names ignored. */
 function declaredSignatureKey(symbol) {
@@ -1251,10 +1400,14 @@ function sitesReboundByChange(index, name, def, rawCallers, confirmed, unverifie
     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 lineKey = site => `${site.file}\0${site.line}`;
+    const siteKey = site => {
+        const at = site.provenance?.facts?.site || site.callSite || site;
+        return `${lineKey(site)}\0${at.start != null ? `start:${at.start}` : at.column != null ? `column:${at.column}` : ''}`;
+    };
     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 reasonAt = new Map(excluded.map(entry => [lineKey(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)])];
@@ -1267,11 +1420,14 @@ function sitesReboundByChange(index, name, def, rawCallers, confirmed, unverifie
         // 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;
+        if (unverifiedKeys.has(key) ? boundBefore !== 'confirmed' : !reasonAt.has(lineKey(site))) 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 { occurrenceIdentity } = require('./provenance-facts');
+        const calls = (getCachedCalls(index, site.file) || []).filter(call => call.line === site.line &&
+            (call.name === name || call.resolvedName === name || call.name === site.calledAs ||
+                call.ownClass && call.ownClass.spelling === site.calledAs));
+        const exact = calls.filter(call => siteKey({ ...occurrenceIdentity(site.file, call), file: site.file }) === key);
+        const call = exact.length === 1 ? exact[0] : calls.length === 1 ? calls[0] : null;
         const language = index.files.get(site.file)?.language;
         let rebind = { kind: call ? 'count' : 'unread' };
         if (call && langTraits(language)?.hasArityOverloads && call.argCount != null && !call.argSpread) {
@@ -1302,7 +1458,7 @@ function sitesReboundByChange(index, name, def, rawCallers, confirmed, unverifie
             reason: 'bound-before-change',
             ...(prior?.reason && { priorReason: prior.reason }),
             boundBefore,
-            excludedAs: reasonAt.get(key) || null,
+            excludedAs: reasonAt.get(lineKey(site)) || null,
             ...(unverifiedKeys.has(key) && { stillUnverified: true }),
             rebind,
         });
@@ -1314,7 +1470,7 @@ function sitesReboundByChange(index, name, def, rawCallers, confirmed, unverifie
 
 /** Map an unverified sweep entry to the public site shape (relative `file`). */
 function unverifiedSiteShape(u) {
-    return {
+    const shape = {
         file: u.relativePath,
         line: u.line,
         expression: (u.content || '').trim(),
@@ -1333,11 +1489,40 @@ function unverifiedSiteShape(u) {
         ...(u.moduleAttribute && { moduleAttribute: true }),
         ...(u.annotationShorthand && { annotationShorthand: u.annotationShorthand }),
     };
+    // The site's own token (fix #422): a same-line edit of another token
+    // leaves it undecided.
+    const site = u.provenance?.facts?.site;
+    const range = site && site.line === u.line && Number.isInteger(site.start) && Number.isInteger(site.end)
+        ? { start: site.start, end: site.end } : null;
+    if (Number.isInteger(u.column) || range) {
+        Object.defineProperty(shape, '_token', {
+            value: { file: u.file, column: Number.isInteger(u.column) ? u.column : null, range },
+            enumerable: false,
+        });
+    }
+    return shape;
+}
+
+/**
+ * Does a planned change cover an unverified site (fix #422)? A change on
+ * its line covers it unless the change edits known tokens and the site's
+ * own token is another one.
+ */
+function siteCoveredByChanges(index, changes, site, name) {
+    const change = changes.find(c => c.file === site.file && c.line === site.line);
+    if (!change) return false;
+    const columns = change._edit?.columns;
+    const token = site._token;
+    if (!Array.isArray(columns) || !token) return true;
+    const column = token.column ?? (token.range
+        ? callTokenColumn(index, token.file, token.range, name, site.line) : null);
+    return column == null || columns.includes(column);
 }
 
 /**
- * BUG-BW: Build the list of call sites for `plan` using the SAME sweep verify
- * uses. This guarantees plan and verify agree on which sites need updating.
+ * Build callable sites through the same contracted sweep as verify.
+ * Value renames resolve their tokens through the value-binding pass and
+ * carry undecided call-shaped lines in their initial account.
  *
  * @param {object} index - ProjectIndex instance
  * @param {string} name - Function name being refactored
@@ -1345,13 +1530,31 @@ function unverifiedSiteShape(u) {
  * @returns {{ sites: Array, unverifiedSites: Array, account: object }}
  */
 function computePlanCallSites(index, name, def, options = {}) {
+    if (options.valueReferenceRename) {
+        // The value-binding pass settles these source occurrences. Preserve
+        // cross-language exclusions through the full caller sweep when an
+        // unresolved call belongs to another runtime family.
+        const { computeGroundSet, buildAccount } = require('./account');
+        const groundSet = computeGroundSet(index, name);
+        const accountParts = { confirmedEntries: [], unverifiedEntries: [], excludedEntries: [] };
+        const account = buildAccount(index, name, { groundSet, ...accountParts });
+        const { callNotResolvedEntries } = require('./analysis');
+        const candidates = callNotResolvedEntries(index, account);
+        const family = langTraits(index.files.get(def.file)?.language)?.nameReferenceFamily;
+        if (family && candidates.every(site =>
+            langTraits(index.files.get(site.file)?.language)?.nameReferenceFamily === family)) {
+            return { sites: [], unverifiedSites: candidates.map(unverifiedSiteShape),
+                account, groundSet, accountParts, valueReferenceRename: true };
+        }
+        index._opGroundSetCache?.set(name, groundSet);
+    }
     // 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);
+        contractedCallerSweep(index, name, def, { constructionSites: options.constructionSites });
 
     const sites = [];
     const planLineSeen = new Map(); // 'file:line' -> per-line ordinal (fix #231)
@@ -1369,6 +1572,7 @@ function computePlanCallSites(index, name, def, options = {}) {
             receiver: c.receiver,
             calledAs: c.calledAs,
             callSite: c.provenance?.facts?.site,
+            constructorSyntax: c.provenance?.facts?.constructorCall?.call?.syntax,
         };
         const siteKey = `${c.file}:${c.line}:${c.calledAs || name}`;
         const occurrence = planLineSeen.get(siteKey) || 0;
@@ -1389,11 +1593,14 @@ function computePlanCallSites(index, name, def, options = {}) {
             expression: (call.content || '').trim(),
             args: analysis.args,
             argCount: analysis.argCount,
+            ...(analysis.implicitConstruction && { implicitConstruction: true }),
             ...(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.keywordDelegation && { keywordDelegation: true }),
+            ...(c.ownClassConstruction && { ownClassConstruction: true }),
             ...(c.destructured && { destructured: c.destructured }),
             ...(c.importAliasSpelling && { importAliasSpelling: true }),
         });
@@ -1405,9 +1612,10 @@ function computePlanCallSites(index, name, def, options = {}) {
         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;
+    // A target-typed `new(..)` or a keyword delegation spells no name
+    // (fixes #400, #421): a rename never edits it, so an undecided one is no
+    // rename candidate either.
+    const renameRelevant = u => u.macroExpansion?.origin !== 'template' && !u.targetTyped && !u.keywordDelegation;
     return {
         sites,
         unverifiedSites: unverified.filter(renameRelevant).map(unverifiedSiteShape),
@@ -1464,13 +1672,21 @@ function sharedParsedTree(index, file, content, language) {
     // 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;
+    if (adapter?.queryTree && !adapter.queryTreeIsPlain?.(content, index.files?.get(file))) {
+        // Its plain parse, kept across operations like the view (fix #436:
+        // impact re-parsed every caller file with a conditional per query).
+        return typeof index._plainParsedTree === 'function'
+            ? index._plainParsedTree(file, content, language) : null;
+    }
     return index._getParsedTree(file, content, language);
 }
 
 function analyzeCallSite(index, call, funcName, occurrence = 0) {
+    if ((call.constructorSyntax || call.provenance?.facts?.constructorCall?.call?.syntax) === 'implicit') {
+        return { args: [], argCount: 0, isMethodCall: false, implicitConstruction: true };
+    }
     try {
-        const language = detectLanguage(call.file);
+        const language = index.languageOf(call.file);
         if (!language) return { args: null, argCount: 0 };
 
         // Use tree cache to avoid re-parsing the same file in batch operations
@@ -1507,7 +1723,25 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
 
         // Find the call expression at the target line matching funcName
         const spelling = call.calledAs && call.calledAs !== 'bound' ? call.calledAs : funcName;
-        const callNode = findCallNode(tree.rootNode, callTypes, targetRow, spelling, occurrence,
+        const constructionSyntax = call.constructorSyntax || call.provenance?.facts?.constructorCall?.call?.syntax;
+        const constructionShape = langTraits(language)?.constructorArgumentNodes?.[constructionSyntax];
+        const constructionArguments = node => constructionShape?.argsField
+            ? node.childForFieldName(constructionShape.argsField)
+            : node.namedChildren.find(child => child.type === constructionShape?.argsNodeType);
+        let constructionNode = null;
+        if (constructionShape) {
+            const site = call.callSite || call.provenance?.facts?.site;
+            if (site?.start != null) {
+                for (let node = tree.rootNode.descendantForIndex(site.start); node; node = node.parent) {
+                    if (node.type === constructionShape.nodeType && node.startIndex <= site.start &&
+                        node.endIndex >= (site.end ?? site.start) && constructionArguments(node)) {
+                        constructionNode = node;
+                        break;
+                    }
+                }
+            }
+        }
+        const callNode = constructionNode || findCallNode(tree.rootNode, callTypes, targetRow, spelling, occurrence,
             call.callSite || call.provenance?.facts?.site);
         if (!callNode) return { args: null, argCount: 0 };
 
@@ -1535,7 +1769,8 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
         // access to the enclosing-function symbol.
         const ctx = classifyCallContext(callNode, language);
 
-        const argsNode = callNode.childForFieldName('arguments');
+        const argsNode = (constructionNode && constructionArguments(constructionNode)) ||
+            callNode.childForFieldName('arguments');
         if (!argsNode) return { args: [], argCount: 0, isMethodCall, ...ctx };
 
         let args = [];
@@ -1646,7 +1881,7 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
  */
 function analyzeCallShape(index, filePath, lineNum, funcName) {
     try {
-        const language = detectLanguage(filePath);
+        const language = index.languageOf(filePath);
         if (!language) return null;
 
         // Reuse tree cache to avoid re-parsing during a batch (clustering scans many sites)
@@ -1998,6 +2233,7 @@ function verify(index, name, options = {}) {
         isMethod: c.isMethod,
         calledAs: c.calledAs,
         callSite: c.provenance?.facts?.site,
+        constructorSyntax: c.provenance?.facts?.constructorCall?.call?.syntax,
         // Preserve receiver identity through the usage-shaped adapter. Go
         // permits a local value to have the same spelling as its type; only
         // a type-qualified call is a method expression with an explicit
@@ -2375,6 +2611,28 @@ const {
  * pin) or its class (a member): 'edit'; another namespace or class: null;
  * unresolvable: 'review'.
  */
+/**
+ * A Rust path value `Q::m` naming a member pin (fix #422): 'edit' when the
+ * qualifier names the pin's own type or trait (or a type implementing the
+ * pinned trait without a member of its own), null when it names another
+ * type or trait, 'review' when the scopes cannot say.
+ */
+function rustPathValueVerdict(index, ref, def) {
+    const callers = require('./callers');
+    const call = { name: def.name, line: ref.line, receiver: ref.receiver, isPathCall: true,
+        isMethod: true, isFunctionReference: true };
+    if (callers.rustPathQualifierVerdict(index, ref.file, call, [def]) === 'other') return null;
+    const { resolveRustPathQualifier } = require('./rust-names');
+    const named = resolveRustPathQualifier(index, ref.file, ref.line, ref.receiver);
+    const owner = require('./class-identity').ownerRefOf(index, def)?.def;
+    const { classKeyOf } = require('./class-identity');
+    if (named?.defs?.length === 1 && owner && classKeyOf(index, named.defs[0]) === classKeyOf(index, owner)) {
+        return 'edit';
+    }
+    if (callers.rustTraitDeclPathProbe(index, ref.file, call, [def]) === 'target') return 'edit';
+    return 'review';
+}
+
 function cppQualifiedReferenceVerdict(index, ref, def) {
     const { resolveQualifier, effectiveNamespace, macroPrefixAt, includeClosure } = require('./cpp-scope');
     // Inside an indexed declaration the reference's scope is that
@@ -2416,8 +2674,9 @@ function cppQualifiedReferenceVerdict(index, ref, def) {
     } catch {
         return 'review';
     }
-    if (!resolved || resolved.kind === 'unknown') return 'review';
     const owner = def.className || (def.receiver ? String(def.receiver).replace(/^\*/, '') : null);
+    if (resolved?.namespaceOnly && owner) return null;
+    if (!resolved || resolved.kind === 'unknown') return 'review';
     if (resolved.kind === 'namespace') {
         if (owner) return null;
         return (resolved.resolvedNamespace || resolved.namespace) === effectiveNamespace(index, def) ? 'edit' : null;
@@ -2461,21 +2720,42 @@ const IMPORT_STATEMENT_TYPES = new Set(['import_statement', 'import_from_stateme
     'future_import_statement', 'use_declaration', 'import_declaration', 'using_directive', 'export_statement']);
 
 /** 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) {
+ * line/column (1-based line, 0-based column), or `line` when none does. A
+ * token of a declarator initialized by `require(..)`/`import(..)` belongs to
+ * the binding recorded on the initializer's line (fix #423: `const {\n
+ * getLevel,\n} = require('./levels')`); without a column the token `name`
+ * spells on the line is used. */
+function importStatementLine(index, filePath, line, column, name = null) {
     const entry = index.files.get(filePath);
-    if (!entry || !Number.isInteger(column)) return line;
+    if (!entry || (!Number.isInteger(column) && !name)) return line;
     let tree;
+    let content = null;
     try {
-        const content = index._readFile(filePath);
+        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 columns = [];
+    if (Number.isInteger(column)) columns.push(column);
+    else if (content != null) {
+        const text = content.split('\n')[line - 1] || '';
+        for (let at = text.indexOf(name); at !== -1; at = text.indexOf(name, at + 1)) columns.push(at);
+    }
+    for (const at of columns) {
+        let node = tree?.rootNode?.descendantForPosition({ row: line - 1, column: at });
+        if (!Number.isInteger(column) && (!node || node.text !== name || node.startPosition.column !== at)) continue;
+        while (node && !IMPORT_STATEMENT_TYPES.has(node.type) && node.type !== 'variable_declarator') {
+            node = node.parent;
+        }
+        if (node?.type === 'variable_declarator') {
+            const value = node.childForFieldName('value');
+            return value ? value.startPosition.row + 1 : line;
+        }
+        if (node) return node.startPosition.row + 1;
+    }
+    return line;
 }
 
 /** Is a Go site file compiled under another build constraint than the
@@ -2521,6 +2801,61 @@ function cLinkAlternatives(index, def, definitions) {
 
 // C: plain identifiers of one spelling at file scope name one entity
 // (no overloading, no namespaces).
+/**
+ * Go (fix #425): does a dot import of `refFile` (`import . "p"`) bring the
+ * pinned package-level declaration into the file? Its package is the
+ * imported directory's (never its tests) and only exported names enter.
+ */
+function goDotImportReaches(index, refFile, def) {
+    if (!def?.file || !/^\p{Lu}/u.test(def.name || '') || def.file.endsWith('_test.go')) return false;
+    const entry = index.files.get(refFile);
+    const pinDir = path.dirname(def.file);
+    return (entry?.importDetails || []).some(detail => {
+        if (detail.type !== 'dot-import' || !detail.module) return false;
+        const rel = entry.moduleResolved?.[detail.module];
+        if (!rel) return false;
+        const abs = path.isAbsolute(rel) ? rel : path.join(index.root, rel);
+        if (path.dirname(abs) !== pinDir) return false;
+        const imported = index.files.get(abs)?.packageName;
+        const pinPackage = index.files.get(def.file)?.packageName;
+        return !imported || !pinPackage || imported === pinPackage;
+    });
+}
+
+/**
+ * Go (fix #425): does the import named `qualifier` in `refFile` (by package
+ * clause, or the name the file writes) resolve to the package that declares
+ * the pinned exported, non-test declaration?
+ */
+function goImportReaches(index, refFile, qualifier, def) {
+    if (!def?.file || !/^\p{Lu}/u.test(def.name || '') || def.file.endsWith('_test.go')) return false;
+    const entry = index.files.get(refFile);
+    const modules = entry?.imports || [];
+    const names = entry?.importNames || [];
+    if (names.length !== modules.length) return false;
+    const pinDir = path.dirname(def.file);
+    return modules.some((module, i) => {
+        if (names[i] !== qualifier) return false;
+        const rel = entry.moduleResolved?.[module];
+        if (!rel) return false;
+        const abs = path.isAbsolute(rel) ? rel : path.join(index.root, rel);
+        return path.dirname(abs) === pinDir;
+    });
+}
+
+/** Is the receiver of a Go selector reference bound by a local? (fix #425) */
+function goSelectorReceiverIsLocal(index, ref) {
+    if (!Number.isInteger(ref.column)) return null;
+    try {
+        const content = index._readFile(ref.file);
+        const tree = index._getParsedTree?.(ref.file, content, 'go') ||
+            safeParse(getParser('go'), content);
+        return getLanguageAdapter('go')?.selectorReceiverIsLocal?.(tree, ref.line, ref.column) ?? null;
+    } catch {
+        return null;
+    }
+}
+
 function cExternalReferenceLanguage(index, file) {
     const traits = langTraits(index.files.get(file)?.language);
     return !!traits?.textualIncludes && !traits.hasArityOverloads;
@@ -2566,25 +2901,26 @@ function cExternalReferenceVerdict(index, ref, def, pinIdentity, definitions) {
 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 { files } = ctx.referenceSites || typeReferenceSites(index, def, name, ctx.groundSet);
+    const referenceKind = ctx.referenceKind || 'type';
     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';
+        change.editKind === 'example' || change.editKind === 'macro-expansion' || change.scopeAlternative ||
+        change.keepsLocalName;
     // Rebuild a line edit from code-unit token columns.
-    const lineEdit = (raw, columns) => {
+    // A Python import that binds the renamed module variable keeps its
+    // module and gains an alias (`import json as j`, fix #420).
+    const lineEdit = (raw, columns, aliases = []) => {
         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);
-        }
+        const aliased = aliases.filter(column => sorted.includes(column));
         return {
-            source: raw.trim(), renamed: renamed.trim(), count: sorted.length,
-            columns: sorted, rawSource: raw, oldName: name, newName: renameTo,
+            source: raw.trim(), renamed: renameColumns(raw, sorted, name, renameTo, aliased).trim(),
+            count: sorted.length, columns: sorted, rawSource: raw, oldName: name, newName: renameTo,
+            ...(aliased.length > 0 && { aliasColumns: aliased }),
         };
     };
     for (const [abs, info] of files) {
@@ -2616,6 +2952,7 @@ function applyTypeReferencePass(index, ctx) {
             const units = columns => columns.map(column => tokenColumn(raw, column, name))
                 .filter(Number.isInteger);
             const editUnits = units(slot.edits);
+            const aliasUnits = units(slot.importAliases || []);
             const skipUnits = new Set(units(slot.skipColumns || []));
             const reviewList = slot.reviews.map(review => ({
                 ...review,
@@ -2628,14 +2965,32 @@ function applyTypeReferencePass(index, ctx) {
             // 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.
+            // A binding of the pin's own variable keeps its edit; the other
+            // tokens of its line the lookup proves join it (fix #424: `x =
+            // getattr(x, ..)` reads the variable it rebinds).
+            if (existing && existing.scopeAlternative && existing.newExpression !== undefined) {
+                if (editUnits.length > 0) mergeTokenEdit(existing, lineEdit(raw, editUnits));
+                const edited = existing._edit?.columns || [];
+                const open = reviewList.filter(review => review.unit == null || !edited.includes(review.unit));
+                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 {
+                    decided.set(key, { abs, edited: true });
+                }
+                continue;
+            }
             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) &&
+                const trusted = referenceKind !== 'value' && (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
+                const keep = referenceKind === 'value' ? prior.filter(column => editUnits.includes(column)) : trusted ? prior.filter(column => !skipUnits.has(column))
                     : 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)));
@@ -2653,7 +3008,7 @@ function applyTypeReferencePass(index, ctx) {
                     reviewed.set(key, { abs, reason: open[0].reason });
                     continue;
                 }
-                const edit = lineEdit(raw, final);
+                const edit = lineEdit(raw, final, aliasUnits);
                 const previous = existing.newExpression;
                 existing.expression = edit.source;
                 existing.newExpression = edit.renamed;
@@ -2678,7 +3033,7 @@ function applyTypeReferencePass(index, ctx) {
                 continue;
             }
             const certain = reviewList.length === 0;
-            const edit = editUnits.length > 0 ? lineEdit(raw, editUnits) : null;
+            const edit = editUnits.length > 0 ? lineEdit(raw, editUnits, aliasUnits) : null;
             const hasEdit = !!edit && edit.renamed !== edit.source;
             if (certain) {
                 decided.set(key, { abs, edited: hasEdit });
@@ -2698,7 +3053,7 @@ function applyTypeReferencePass(index, ctx) {
                             file: rel,
                             line,
                             expression: edit.source,
-                            suggestion: `${kind === 'call' ? 'Rename to' : 'Update type reference'}: ${edit.renamed}`,
+                            suggestion: `${kind === 'call' ? 'Rename to' : `Update ${referenceKind} reference`}: ${edit.renamed}`,
                             newExpression: edit.renamed,
                             editKind: kind,
                         });
@@ -2718,7 +3073,7 @@ function applyTypeReferencePass(index, ctx) {
                     file: rel,
                     line,
                     expression: edit.source,
-                    suggestion: `Update type reference: ${edit.renamed}${reviewNote}`,
+                    suggestion: `Update ${referenceKind} reference: ${edit.renamed}${reviewNote}`,
                     newExpression: edit.renamed,
                     editKind: 'reference',
                     ...(!certain && { needsReview: true, reviewReason: reviewList[0].reason }),
@@ -2740,7 +3095,7 @@ function applyTypeReferencePass(index, ctx) {
     // C# applies `XAttribute` as `[X]` (fix #386).
     const { csharpAttributeShortSites } = require('./type-references');
     const suffix = 'Attribute';
-    for (const site of csharpAttributeShortSites(index, def, name)) {
+    for (const site of referenceKind === 'value' ? [] : 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
@@ -2913,6 +3268,66 @@ function memberAssignmentOwnerScope(index, def) {
     return 'external';
 }
 
+/** A named constructor outside its class body still names that class. */
+function constructorRenameOwner(index, member, requireConstructorSyntax = false) {
+    const owners = classDefsNamed(index, member.name).entries.map(entry => entry.def);
+    const contained = owners.filter(d => d.file === member.file &&
+        d.startLine <= member.startLine && d.endLine >= member.endLine)
+        .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+    if (contained && (!requireConstructorSyntax || member.type === 'constructor' ||
+        member.memberType === 'constructor')) return contained;
+    const line = member.nameLine || member.startLine;
+    const token = renameIdentifierTokens(index, member.file, line, member.name, member.name,
+        null, null, { definitionNameOnly: true, definition: member });
+    if (token.columns?.length !== 1) return requireConstructorSyntax ? undefined : null;
+    if (requireConstructorSyntax) {
+        const entry = index.files.get(member.file);
+        const language = entry?.language;
+        const content = index._readFile(member.file);
+        const tree = index._getParsedTree?.(member.file, content, language) || safeParse(getParser(language), content);
+        const position = { row: line - 1, column: token.columns[0] };
+        const isConstructor = candidate => {
+            const node = candidate?.rootNode.descendantForPosition(position);
+            // A position outside every name token resolves to the root.
+            return !!node?.parent && ['ctor', 'ctor-qualified'].includes(referenceRole(node, language).role);
+        };
+        if (!isConstructor(tree)) {
+            // Decoration macros can make a constructor look return-typed.
+            // Read the same recovered declaration that the index verified.
+            const blanks = entry?.recoveryBlanks;
+            if (!blanks?.length) return undefined;
+            const module = require('../languages').LANGUAGES[language]?.module();
+            const fresh = entry.hash && require('crypto').createHash('md5').update(content).digest('hex') === entry.hash;
+            const recovered = module?.recoveredTree?.(content, getParser(language), fresh ? blanks : null);
+            if (!isConstructor(recovered)) return undefined;
+        }
+    }
+    if (contained) return contained;
+    const { typeReferenceSites } = require('./type-references');
+    const ground = { perFile: new Map([[member.file, new Set([line])]]) };
+    const proven = [];
+    for (const candidate of owners) {
+        const sites = typeReferenceSites(index, candidate, candidate.name, ground);
+        const columns = sites.files.get(member.file)?.lines.get(line)?.edits || [];
+        if (!columns.includes(token.columns[0])) continue;
+        // A class template name alone cannot identify an unindexed
+        // specialization's constructor. Its own declaration must agree.
+        const { _cFamilySignatureKey } = require('./callers');
+        const signature = _cFamilySignatureKey(member);
+        const declaredOwner = [...sites.resolver.group].find(owner => !owner.forwardDeclaration &&
+            (index.symbols.get(member.name) || []).some(declaration => declaration !== member &&
+                (declaration.type === 'constructor' || declaration.memberType === 'constructor') &&
+                declaration.file === owner.file && declaration.startLine >= owner.startLine &&
+                declaration.endLine <= owner.endLine && _cFamilySignatureKey(declaration) === signature));
+        if (declaredOwner) proven.push({ def: declaredOwner, group: sites.resolver.group });
+    }
+    if (!proven.length) return null;
+    const first = proven[0];
+    if (proven.some(hit => hit.group.size !== first.group.size ||
+        [...hit.group].some(def => !first.group.has(def)))) return null;
+    return first.def;
+}
+
 function plan(index, name, options = {}) {
     index._beginOp();
     // Every slot member of a rename is swept over the same files: their call
@@ -2927,15 +3342,41 @@ function plan(index, name, options = {}) {
 
     const resolved = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
     let def = resolved.def || definitions[0];
+    if (options.renameTo && definitions.some(other => other !== def && other.file === def.file &&
+        (other.nameLine || other.startLine) === (def.nameLine || def.startLine) &&
+        (!options.className || other.className === options.className) &&
+        (isValueDefinition(def) && !def.className && isTypeRenamePin(other) ||
+            isTypeRenamePin(def) && isValueDefinition(other) && !other.className))) {
+        return { found: true, function: name,
+            error: 'This source handle names both a type and a value. Select the member with class_name or put the declarations on separate source lines.' };
+    }
     // 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) &&
+    const constructorOwnerName = def.className && langTraits(index.files.get(def.file)?.language)?.textualIncludes
+        ? require('./cpp-scope').stripTemplateArguments(def.className).split('::').pop() : def.className;
+    const namedConstructor = constructorOwnerName === 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;
+            (def.type === 'method' && index.files.get(def.file)?.language === 'csharp'));
+    // A C/C++ member out of its class can be a constructor or destructor
+    // whose kind the parse could not record (a macro, a specialization, an
+    // alias qualifier). It is named like a project type; any other member is
+    // neither (fix #418: the owner proof ran for every method rename).
+    const qualifiedCandidate = def.className && ['function', 'method', 'constructor'].includes(def.type) &&
+        langTraits(index.files.get(def.file)?.language)?.textualIncludes &&
+        classDefsNamed(index, def.name.startsWith('~') ? def.name.slice(1) : def.name).entries.length > 0;
+    const fixedConstructor = def.type === 'constructor' &&
+        langTraits(index.files.get(def.file)?.language)?.fixedConstructorName === def.name;
+    if (options.renameTo && (namedConstructor || qualifiedCandidate || fixedConstructor)) {
+        const owner = fixedConstructor ? ownerDefinitionOf(index, def) :
+            constructorRenameOwner(index, def, !namedConstructor ||
+                langTraits(index.files.get(def.file)?.language)?.textualIncludes);
+        if (owner !== undefined) {
+            if (!owner) return { found: true, function: name,
+                error: 'The constructor owner could not be resolved. Select the class declaration to plan its rename.' };
+            def = owner;
+            if (fixedConstructor) name = owner.name;
+        }
     }
     // BUG-BY: enrich types for typed-arrow-fn declarations.
     const arrowTypes = extractArrowTypesFromVarDecl(index, def);
@@ -2960,9 +3401,17 @@ 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.
+    // A rename the language's own protocol blocks never edits a class
+    // construction: the class is constructed by name, and the initializer
+    // is reached by the protocol, not by its spelling (fix #418: the sweep
+    // listed every construction as a review item of a blocked rename).
+    const constructionSites = !(options.renameTo && require('./constructor-calls').isConstructor(def, index) &&
+        externalContractOf(index, def)?.reason === 'language-protocol-member');
     const { sites: planCallSites, unverifiedSites: planUnverified, account: pinAccount,
-        groundSet: planGroundSet, accountParts: planAccountParts } = computePlanCallSites(index, name, def,
-        { analyzeArgs: !options.renameTo });
+        groundSet: planGroundSet, accountParts: planAccountParts,
+        valueReferenceRename = false } = computePlanCallSites(index, name, def,
+        { analyzeArgs: !options.renameTo, constructionSites,
+            valueReferenceRename: !!options.renameTo && isValueDefinition(def) && !def.macroExpansion });
     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.
@@ -3012,6 +3461,9 @@ function plan(index, name, options = {}) {
     let operation = null;
     let changes = [];
     const reviewItems = [];
+    // The declarations a rename changes together: the pin and its
+    // configuration alternatives (fix #419).
+    const renameClosure = [def];
     // Contract membership (fix #360): project slot roots the rename closed
     // over, and Go satisfaction sites the closure could not complete.
     const contractRootDefs = [];
@@ -3042,10 +3494,27 @@ function plan(index, name, options = {}) {
 
         // When adding a param, insert before rest params (*args/**kwargs) and
         // before optional params (required must precede optional in Python/TS).
-        {
-            const selfNames = ['self', 'cls', '&self', '&mut self', 'mut self'];
-            const minIdx = (newParams.length > 0 && selfNames.includes(newParams[0].name)) ? 1 : 0;
+        // Where calls bind arguments by name (Python), a list with `*args`
+        // or keyword-only params takes the new param as keyword-only, after
+        // them and before `**kwargs` (fix #424): a positional param before
+        // `*args` would rebind every call passing extra positionals.
+        // Inserted before a rest param elsewhere, calls passing arguments
+        // there now bind the new param: they are listed (`rebindIndex`).
+        let rebindIndex = null;
+        const selfNames = ['self', 'cls', '&self', '&mut self', 'mut self'];
+        const minIdx = (newParams.length > 0 && selfNames.includes(newParams[0].name)) ? 1 : 0;
+        const varPositional = p => p.rest && /^\*(?!\*)/.test(String(p.name));
+        const varKeyword = p => p.rest && String(p.name).startsWith('**');
+        if (langTraits(planLang)?.keywordArguments &&
+            newParams.some(p => varPositional(p) || p.keywordOnly)) {
+            newParam.keywordOnly = true;
+            const kwIdx = newParams.findIndex(varKeyword);
+            newParams.splice(kwIdx !== -1 ? kwIdx : newParams.length, 0, newParam);
+        } else {
             const firstRestIdx = newParams.findIndex(p => p.rest || (p.name && (p.name.startsWith('*') || p.name.startsWith('...'))));
+            if (firstRestIdx !== -1 && !varKeyword(newParams[firstRestIdx])) {
+                rebindIndex = Math.max(firstRestIdx, minIdx) - minIdx;
+            }
             if (firstRestIdx !== -1) {
                 // Always insert before rest params (*args, **kwargs, ...rest)
                 const insertIdx = Math.max(firstRestIdx, minIdx);
@@ -3066,7 +3535,7 @@ function plan(index, name, options = {}) {
         // Generate new signature with TS-correct optional marker (BUG-BV)
         // and arrow-fn enriched return type (BUG-BY).
         // BUG-5: preserve all modifier tokens (async/static/public/...).
-        const paramsList = newParams.map(formatTypedParam).filter(Boolean).join(', ');
+        const paramsList = formatTypedParamList(newParams, def.paramTypes);
         const modTokens = computeModifierTokens(def);
         const modPrefix = modTokens.length ? modTokens.join(' ') + ' ' : '';
         newSignature = `${modPrefix}${name}(${paramsList})`;
@@ -3077,16 +3546,39 @@ function plan(index, name, options = {}) {
         // for default values, every call site must pass the new argument.
         for (const site of planCallSites) {
             let suggestion;
+            const positional = site.positionalCount ?? site.argCount;
+            if (rebindIndex !== null && !site.implicitConstruction &&
+                (!site.args || site.args.some(arg => /^(\.\.\.|\*)/.test(arg)) || positional > rebindIndex)) {
+                // An argument this call passes at the new param's position
+                // now binds it instead of the rest param.
+                changes.push({
+                    file: site.file,
+                    line: site.line,
+                    expression: site.expression,
+                    suggestion: `Argument ${rebindIndex + 1} now binds ${options.addParam}: pass ${options.addParam} ` +
+                        `at position ${rebindIndex + 1} so the remaining arguments still reach the rest parameter`,
+                    args: site.args,
+                    needsReview: true,
+                    editKind: 'call',
+                });
+                continue;
+            }
             if (options.defaultValue && langHasDefaults) {
                 // The default makes the existing call valid. Keep the fact in
                 // metadata, but do not inflate the concrete edit plan with a
                 // no-op entry (UCN5-166).
                 unchangedSites++;
                 continue;
+            } else if (site.implicitConstruction) {
+                reviewItems.push({ file: site.file, line: site.line, expression: site.expression,
+                    suggestion: 'Add an explicit base constructor initializer with the required argument',
+                    needsReview: true, editKind: 'implicit-construction', implicitConstruction: true });
+                continue;
             } else if (options.defaultValue) {
                 suggestion = `Add argument: ${options.defaultValue} (no default parameter values in ${planFileEntry?.language || 'this language'})`;
             } else {
-                const keywordCall = langTraits(planLang)?.keywordArguments && site.keywordArgNames?.length > 0;
+                const keywordCall = langTraits(planLang)?.keywordArguments &&
+                    (newParam.keywordOnly || site.keywordArgNames?.length > 0);
                 suggestion = keywordCall
                     ? `Add keyword argument: ${options.addParam}=${options.addParam} (replace the right-hand value with the intended expression; keep existing keyword arguments)`
                     : `Add argument: ${options.addParam}`;
@@ -3124,7 +3616,7 @@ function plan(index, name, options = {}) {
         // Generate new signature with TS-correct optional marker (BUG-BV)
         // and arrow-fn enriched return type (BUG-BY).
         // BUG-5: preserve all modifier tokens (async/static/public/...).
-        const paramsList = newParams.map(formatTypedParam).filter(Boolean).join(', ');
+        const paramsList = formatTypedParamList(newParams, def.paramTypes);
         const modTokens = computeModifierTokens(def);
         const modPrefix = modTokens.length ? modTokens.join(' ') + ' ' : '';
         newSignature = `${modPrefix}${name}(${paramsList})`;
@@ -3177,6 +3669,9 @@ function plan(index, name, options = {}) {
 
     // The rename's usage records, shared with the method-group pass below.
     let planUsages = null;
+    // The pin's scope binds its name by other statements too (fix #424): the
+    // rename is the variable's, so references resolving there follow it.
+    let pinScopeRebound = false;
     if (options.renameTo) {
         operation = 'rename';
         newSignature = currentSignature.replace(new RegExp('\\b' + escapeRegExp(name) + '\\b'), options.renameTo);
@@ -3245,9 +3740,12 @@ function plan(index, name, options = {}) {
         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 target-typed `new(..)` or a keyword delegation (`base(..)`)
+            // spells no name: the type written at its declaration site is
+            // what the rename edits (fixes #393, #421).
+            // `cls(..)` / `type(self)(..)` / `new this(..)` spell the
+            // method's receiver, never the class (fix #434).
+            if (incoming.targetTyped || incoming.keywordDelegation || incoming.ownClassConstruction) 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
@@ -3280,6 +3778,11 @@ function plan(index, name, options = {}) {
                 }
                 continue;
             }
+            // A call spelled by an import alias (`h()` after `const h =
+            // require('./a').helper`) keeps its spelling; the import's
+            // source-side name is the edit (fix #434: it made a same-line
+            // spelled call a manual review).
+            if (incoming.calledAs && incoming.calledAs !== name && incoming.calledAs !== 'bound') continue;
             const lineKey = `${incoming.file}:${incoming.line}`;
             const site = emittedRenameCalls.get(lineKey) || {
                 file: incoming.file,
@@ -3402,7 +3905,7 @@ function plan(index, name, options = {}) {
         const usages = index.usages(name, {
             codeOnly: false,
             includeTests: true,
-            internalEvidence: true,
+            internalEvidence: !valueReferenceRename,
         });
         planUsages = usages;
         const importUsages = usages.filter(u => u.usageType === 'import' && !u.isDefinition);
@@ -3438,7 +3941,7 @@ function plan(index, name, options = {}) {
             // `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 statementLine = onLine ? line : importStatementLine(index, filePath, line, column, name);
             const bindings = (fileEntry?.importBindings || []).filter(binding =>
                 (binding.line === line || binding.line === statementLine) &&
                 binding.name === name && binding.module);
@@ -3451,13 +3954,23 @@ function plan(index, name, options = {}) {
                 binding.alias === name && binding.name !== name)) return false;
             if (bindings.length === 0) return true;
             return bindings.some(binding => {
+                // A Rust `use` path names the item its module declares (fix
+                // #422): another module's namesake is never the pin.
+                if (langTraits(fileEntry.language)?.itemScopeResolution && !def.className && !def.receiver) {
+                    const named = require('./rust-names').resolveRustUsePath(index, filePath, binding.line,
+                        binding.module, ['struct', 'enum', 'union', 'trait', 'type', 'module'].includes(def.type)
+                            ? 'type' : 'value');
+                    if (named?.external) return false;
+                    if (named?.defs) return named.defs.some(d => d.name === name && renameTargetFiles.has(d.file));
+                }
                 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 && (!require('./callers')._unresolvedModuleIsGap(index, binding.module, binding) ||
+                    require('./callers')._nonSourceModuleFile(index, filePath, binding.module))) return false;
                 if (!abs) return filePath !== def.file;
                 if (abs === filePath) return false;
                 // A module binding the name through one alternative of a
@@ -3465,16 +3978,40 @@ function plan(index, name, options = {}) {
                 // importer's token names the item, not the renamed pin.
                 const verdict = _nameBindingReaches(index, abs, name, renameTargetFiles, 4,
                     { configurationVerdict: true });
+                // The value-token pass can review an unresolved import. Do
+                // not preempt it with an automatic import edit, especially
+                // one that preserves a configuration item's local name.
+                if (isValueDefinition(def)) return verdict === 'yes';
                 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) => {
+        // `except ImportError: def f`) keeps the item's local name, as does
+        // one whose scope also declares the name by a def or class statement
+        // (fix #424: `class OMD` then `try: from .dictutils import OMD`): the
+        // importer's variable is not the renamed definition alone (a plain
+        // rebinding joins the variable's rename, fix #420).
+        const importKeepsItemName = (filePath, line, column = null) => {
             const { itemsNamed } = require('./configuration-items');
-            return itemsNamed(index, filePath, name).some(item =>
-                item.sites.some(site => site.kind === 'import' && site.line === line));
+            if (itemsNamed(index, filePath, name).some(item =>
+                item.sites.some(site => site.kind === 'import' && site.line === line))) return true;
+            const entry = index.files.get(filePath);
+            if (!langTraits(entry?.language)?.assignmentDeclaresLocal) return false;
+            let tree;
+            try {
+                const content = index._readFile(filePath);
+                tree = index._getParsedTree?.(filePath, content, entry.language) ||
+                    safeParse(getParser(entry.language), content);
+            } catch { tree = null; }
+            const text = index._getFileLines(filePath)[line - 1] || '';
+            const at = Number.isInteger(column) ? column : text.length - text.trimStart().length;
+            let importNode = tree?.rootNode.descendantForPosition({ row: line - 1, column: at }) || null;
+            while (importNode && importNode.type !== 'import_from_statement' &&
+                importNode.type !== 'import_statement') importNode = importNode.parent;
+            if (!importNode) return false;
+            const { pythonScopeBindingKinds } = require('../languages/lexical-scope');
+            return pythonScopeBindingKinds(importNode, name).some(site => site.kind === 'def');
         };
         for (const imp of importUsages) {
             // Skip if already covered by a call site change in the same file:line
@@ -3485,14 +4022,17 @@ function plan(index, name, options = {}) {
             // The token is the importer's own local alias (fix #397): an
             // import alias keeps its local name.
             if (imp.importAlias) continue;
+            // A module path segment names a module (fix #424).
+            if (imp.modulePath) continue;
             if (imp.file && def.file && !importMayBindPin(imp.file)) continue;
             if (imp.file && !importSourceBindsPin(imp.file, imp.line, imp.column)) continue;
+            const keepsLocalName = !!imp.file && importKeepsItemName(imp.file, imp.line, imp.column);
             const edit = renameIdentifierTokens(index, imp.file,
-                imp.line, name, imp.file && importKeepsItemName(imp.file, imp.line)
+                imp.line, name, keepsLocalName
                     ? `${options.renameTo} as ${name}` : options.renameTo);
             const newImport = edit.renamed;
             if (newImport === edit.source) continue;
-            changes.push(tagTokenEdit({
+            const importChange = tagTokenEdit({
                 file: imp.relativePath || imp.file,
                 line: imp.line,
                 expression: edit.source,
@@ -3500,7 +4040,11 @@ function plan(index, name, options = {}) {
                 newExpression: newImport,
                 isImport: true,
                 editKind: 'import',
-            }, edit));
+            }, edit);
+            // The module still binds the old name (fix #424): its `__all__`
+            // entry names that binding.
+            if (keepsLocalName) Object.defineProperty(importChange, 'keepsLocalName', { value: true });
+            changes.push(importChange);
         }
 
         // Renamed CJS/Python imports are intentionally surfaced as reference
@@ -3542,8 +4086,10 @@ function plan(index, name, options = {}) {
             for (const exported of targetEntry.exportDetails || []) {
                 if ((exported.name !== name && exported.alias !== name) ||
                     !exported.line) continue;
+                // Under the pin's own name (fix #423): `export { other as
+                // name } from './pin'` exposes another declaration.
                 const ownership = _nameBindingReaches(
-                    index, exportPath, name, renameTargetFiles, 8);
+                    index, exportPath, name, renameTargetFiles, 8, { targetName: name });
                 // Transitive file reachability is not name ownership. A file
                 // can import the target somewhere in its dependency closure
                 // while exporting its own same-spelled local declaration.
@@ -3616,7 +4162,7 @@ function plan(index, name, options = {}) {
             const pathMod = require('path');
             const dunderFiles = new Set([def.file]);
             for (const change of changes) {
-                if (change.editKind !== 'import') continue;
+                if (change.editKind !== 'import' || change.keepsLocalName) continue;
                 const abs = pathMod.isAbsolute(change.file)
                     ? change.file : pathMod.join(index.root, change.file);
                 dunderFiles.add(abs);
@@ -3653,14 +4199,18 @@ function plan(index, name, options = {}) {
                                 const quoteRe = new RegExp(`(["'])${escapeRegExp(name)}\\1`, 'g');
                                 const newLine = sourceLine.replace(quoteRe, `$1${options.renameTo}$1`);
                                 if (newLine === sourceLine) continue;
-                                changes.push({
+                                const entryChange = {
                                     file: rel,
                                     line: lineNo,
                                     expression: sourceLine.trim(),
                                     suggestion: `Update __all__ entry: ${newLine.trim()}`,
                                     newExpression: newLine.trim(),
                                     editKind: 'reference',
-                                });
+                                };
+                                // The edited entry is no text dependency left
+                                // for review (fix #424).
+                                Object.defineProperty(entryChange, 'dunderAllEntry', { value: true });
+                                changes.push(entryChange);
                             } else {
                                 for (let i = 0; i < s.namedChildCount; i++) strStack.push(s.namedChild(i));
                             }
@@ -3699,6 +4249,8 @@ function plan(index, name, options = {}) {
                         ? `Update declaration: ${edit.renamed}`
                         : isAccessorDefinition(member) && isAccessorDefinition(def)
                         ? `Update accessor: ${edit.renamed}`
+                        : member.modifiers?.includes('partial') && def.modifiers?.includes('partial')
+                        ? `Update partial method part: ${edit.renamed}`
                         : `Update overload signature: ${edit.renamed}`,
                     newExpression: edit.renamed,
                     isDefinition: true,
@@ -3734,36 +4286,23 @@ function plan(index, name, options = {}) {
             });
         }
         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))) ||
+            const { _isCrossFileConfigurationMember, _isConfigurationAlternative } = require('./callers');
+            const alternatives = definitions.filter(other => other !== def && (
+                // One rule with the caller engine (fix #426): Python runtime
+                // configuration items (fix #398F), Go build-constraint files
+                // (fix #425), and same-file definitions of one owner, owner
+                // path, signature and generic arity with configuration
+                // evidence (`#[cfg]`, a conditional branch the other does not
+                // share): overloads differing in generic arity and local
+                // functions of two methods are two items.
+                _isConfigurationAlternative(index, def, other, { macros: true }) ||
                 // 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 = [];
+            renameClosure.push(...alternatives);
             for (const other of alternatives) {
                 const line = other.nameLine || other.startLine;
                 const rel = other.relativePath || other.file;
@@ -3784,7 +4323,7 @@ function plan(index, name, options = {}) {
                         }, edit));
                     }
                 }
-                const sweep = computePlanCallSites(index, name, other, { analyzeArgs: !options.renameTo });
+                const sweep = computePlanCallSites(index, name, other, { analyzeArgs: !options.renameTo, constructionSites });
                 const seen = new Set([...planCallSites, ...alternativeSites].map(site =>
                     `${site.file}:${site.line}:${site.column ?? '*'}`));
                 const lines = new Set([...planCallSites, ...alternativeSites].map(site =>
@@ -3842,8 +4381,7 @@ function plan(index, name, options = {}) {
             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}`));
+                const kept = planUnverified.filter(site => !siteCoveredByChanges(index, changes, site, name));
                 planUnverified.length = 0;
                 planUnverified.push(...kept);
                 planUnverified.sort((a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line);
@@ -3859,7 +4397,9 @@ function plan(index, name, options = {}) {
         // alias, and class-body reads of a member are references.
         {
             let adapter = null;
-            try { adapter = getLanguageAdapter(planLang); } catch { adapter = null; }
+            try {
+                if (langTraits(planLang)?.scopeAlternativeBindings !== false) adapter = getLanguageAdapter(planLang);
+            } catch { adapter = null; }
             if (typeof adapter?.findScopeAlternativeBindings === 'function') {
                 let tree = null;
                 try {
@@ -3872,6 +4412,7 @@ function plan(index, name, options = {}) {
                     ? adapter.findScopeAlternativeBindings(tree, def.nameLine || def.startLine, name)
                     : [];
                 const rel = def.relativePath || def.file;
+                if (bindings.some(binding => binding.kind !== 'reference')) pinScopeRebound = true;
                 for (const binding of bindings) {
                     if (changes.some(change => change.file === rel && change.line === binding.line)) continue;
                     const replacement = binding.kind === 'import-name'
@@ -3880,7 +4421,7 @@ function plan(index, name, options = {}) {
                         replacement, [binding.column]);
                     if (edit.renamed === edit.source) continue;
                     const isReference = binding.kind === 'reference';
-                    changes.push(tagTokenEdit({
+                    const change = tagTokenEdit({
                         file: rel,
                         line: binding.line,
                         expression: edit.source,
@@ -3890,7 +4431,12 @@ function plan(index, name, options = {}) {
                         newExpression: edit.renamed,
                         ...(!isReference && { isDefinition: true }),
                         editKind: isReference ? 'reference' : 'definition',
-                    }, edit));
+                    }, edit);
+                    // A binding of the pin's own variable (fix #424): the
+                    // type lookup never re-decides it (`from threading
+                    // import RLock` beside `class RLock` keeps its alias).
+                    Object.defineProperty(change, 'scopeAlternative', { value: true });
+                    changes.push(change);
                 }
             }
         }
@@ -4189,8 +4735,17 @@ function plan(index, name, options = {}) {
             // band with slot attribution. Bounded — a pathological slot
             // discloses the cut instead of sweeping forever.
             const SLOT_SWEEP_CAP = 25;
-            const siteTokenKey = site =>
-                `${site.file}:${site.line}:${Number.isInteger(site.column) ? site.column : '*'}`;
+            const siteTokenKey = site => {
+                // A slot's members can confirm different calls on one line.
+                // Resolve column-less records by their own source range before
+                // deduplicating them, just as the edit pass does.
+                const column = Number.isInteger(site.column) ? site.column
+                    : callTokenColumn(index, site.absoluteFile || site.file,
+                        site.siteRange, name, site.line);
+                const token = Number.isInteger(column) ? column
+                    : site.siteRange ? `${site.siteRange.start}-${site.siteRange.end}` : '*';
+                return `${site.file}:${site.line}:${token}`;
+            };
             const seenSiteTokens = new Set(planCallSites.map(site => siteTokenKey(site)));
             const slotMemberSites = [];
             // Members a macro generated (fix #374) are swept after, and
@@ -4201,7 +4756,7 @@ function plan(index, name, options = {}) {
             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 });
+                const memberSweep = computePlanCallSites(index, name, memberDef, { analyzeArgs: !options.renameTo, constructionSites });
                 for (const site of memberSweep.sites) {
                     const key = siteTokenKey(site);
                     if (seenSiteTokens.has(key)) continue;
@@ -4280,10 +4835,8 @@ function plan(index, name, options = {}) {
             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 =>
-                `${change.file}:${change.line}`));
             const keptUnverified = planUnverified.filter(site =>
-                !changedLines.has(`${site.file}:${site.line}`));
+                !siteCoveredByChanges(index, changes, site, name));
             planUnverified.length = 0;
             planUnverified.push(...keptUnverified);
             planUnverified.sort((a, b) => codeUnitCompare(a.file, b.file) ||
@@ -4448,8 +5001,7 @@ function plan(index, name, options = {}) {
                 }, 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}`));
+                const kept = planUnverified.filter(site => !siteCoveredByChanges(index, changes, site, name));
                 planUnverified.length = 0;
                 planUnverified.push(...kept);
             }
@@ -4483,14 +5035,25 @@ function plan(index, name, options = {}) {
         // so those rows surface needsReview instead of a synthesized edit.
         // A NESTED pin's own container is exempt: inside it the pin IS the
         // binder (`return decorator`).
-        {
+        // Value references use the binding pass below, including local
+        // shadows and receivers, rather than the callable reference rules.
+        if (!valueReferenceRename) {
             const fileSymbols = index.files.get(def.file)?.symbols || [];
             const scopeKinds = new Set(['function', 'method', 'constructor',
                 'private', 'get', 'set', 'property', 'classmethod', 'special']);
+            // Source spans (line, column) decide nesting on one line (fix
+            // #426: `int Go() { int Handler() => 3; return Handler(); }`).
+            const spanOf = symbol => {
+                const span = symbol.sourceSpan;
+                return span && Number.isInteger(span.startColumn) && Number.isInteger(span.endColumn) ? span : null;
+            };
+            const atOrBefore = (l1, c1, l2, c2) => l1 < l2 || (l1 === l2 && c1 <= c2);
             const rangeOf = symbol => ({
                 start: symbol.startLine,
                 end: symbol.endLine || symbol.startLine,
+                span: spanOf(symbol),
             });
+            const spanWidth = range => (range.span ? range.span.end - range.span.start : Infinity);
             const containerOf = (symbol) => {
                 const target = rangeOf(symbol);
                 let best = null;
@@ -4498,18 +5061,35 @@ function plan(index, name, options = {}) {
                     if (candidate === symbol || !scopeKinds.has(candidate.type)) continue;
                     const range = rangeOf(candidate);
                     if (!(range.start <= target.start && range.end >= target.end)) continue;
-                    if (range.start === target.start && range.end === target.end) continue;
-                    if (!best || (range.end - range.start) < (best.end - best.start)) {
+                    if (range.start === target.start && range.end === target.end &&
+                        !(range.span && target.span && spanWidth(range) > spanWidth(target) &&
+                            atOrBefore(range.span.startLine, range.span.startColumn,
+                                target.span.startLine, target.span.startColumn) &&
+                            atOrBefore(target.span.endLine, target.span.endColumn,
+                                range.span.endLine, range.span.endColumn))) continue;
+                    if (!best || (range.end - range.start) < (best.end - best.start) ||
+                        ((range.end - range.start) === (best.end - best.start) && spanWidth(range) < spanWidth(best))) {
                         best = range;
                     }
                 }
                 return best; // null = module scope
             };
+            // Does a container hold a reference? By its span when both have
+            // columns and the container shares a line with others.
+            const holds = (container, ref) => {
+                if (!(container.start <= ref.line && container.end >= ref.line)) return false;
+                if (!container.span || !Number.isInteger(ref.column) ||
+                    (ref.line !== container.start && ref.line !== container.end)) return true;
+                return atOrBefore(container.span.startLine, container.span.startColumn, ref.line, ref.column) &&
+                    atOrBefore(ref.line, ref.column, container.span.endLine, container.span.endColumn);
+            };
             // 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));
+            // Configuration alternatives are one item with the pin too (fix
+            // #419): a reference ambiguous only between them names the item.
+            const pinIdentity = new Set([...require('./callers')._closeCallableIdentityGroup(
+                index, [def], definitions), ...renameClosure]);
             const binders = definitions
                 .filter(candidate => candidate.file === def.file &&
                     !NON_CALLABLE_TYPES.has(candidate.type))
@@ -4546,6 +5126,37 @@ function plan(index, name, options = {}) {
             // 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;
+            // Does a Python reference in the pin's file resolve to the scope
+            // the pin's statement binds its name in (fix #424)?
+            let pinScopeTree;
+            let pinScopeNode;
+            const referenceInPinScope = (ref) => {
+                if (ref.file !== def.file || !Number.isInteger(ref.column)) return false;
+                if (pinScopeTree === undefined) {
+                    pinScopeTree = null;
+                    try {
+                        const content = index._readFile(def.file);
+                        pinScopeTree = index._getParsedTree?.(def.file, content, planLang) ||
+                            safeParse(getParser(planLang), content);
+                    } catch { pinScopeTree = null; }
+                    let declNode = pinScopeTree?.rootNode.descendantForPosition({ row: pinNameLine - 1,
+                        column: Math.max(0, (index._getFileLines(def.file)[pinNameLine - 1] || '').indexOf(name)) });
+                    while (declNode && declNode.type !== 'function_definition' && declNode.type !== 'class_definition') {
+                        declNode = declNode.parent;
+                    }
+                    pinScopeNode = declNode?.parent || null;
+                    while (pinScopeNode && pinScopeNode.type !== 'function_definition' && pinScopeNode.type !== 'module') {
+                        if (pinScopeNode.type === 'class_definition') { pinScopeNode = null; break; }
+                        pinScopeNode = pinScopeNode.parent;
+                    }
+                }
+                if (!pinScopeNode || pinScopeNode.type !== 'function_definition') return false;
+                const node = pinScopeTree.rootNode.descendantForPosition({ row: ref.line - 1, column: ref.column });
+                if (node?.type !== 'identifier' || node.text !== name) return false;
+                const { referenceScopeNode } = require('../languages/lexical-scope');
+                const scope = referenceScopeNode(node, name);
+                return !!scope && sameNode(scope, pinScopeNode);
+            };
             const pinAtFileScope = !pinContainer && !fileSymbols.some(symbol =>
                 symbol.type === 'module' && symbol !== def &&
                 symbol.startLine <= pinNameLine &&
@@ -4562,6 +5173,12 @@ function plan(index, name, options = {}) {
                 if (ref.receiver && index.files.get(ref.file)?.language === 'cpp') {
                     return cppQualifiedReferenceVerdict(index, ref, def);
                 }
+                // A path value naming a member (`let f = T::method;`, fix
+                // #422) names what its qualifier resolves to by item scopes.
+                if (def.className && ref.receiver && ref.scopedReference &&
+                    langTraits(index.files.get(ref.file)?.language)?.itemScopeResolution) {
+                    return rustPathValueVerdict(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
@@ -4596,6 +5213,18 @@ function plan(index, name, options = {}) {
                         }
                         return null;
                     }
+                    // A member access (`options.revalidate`) never names a
+                    // non-member declaration through its binding (fix #423,
+                    // swr: a pin in an untyped-cast arrow had no container
+                    // and module-scope binder logic edited the property);
+                    // only a module namespace receiver can, as below.
+                    if (ref.receiver) {
+                        const viaModule = !ref.receiverLocalBinding
+                            ? _moduleAttributeBindingReaches(index, ref.file, ref.receiver, name,
+                                renameTargetFiles)
+                            : null;
+                        return viaModule === 'yes' ? 'edit' : viaModule === 'unknown' ? 'review' : 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
@@ -4604,24 +5233,25 @@ function plan(index, name, options = {}) {
                         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;
+                        // pin only when that binding is the pin's own def, or
+                        // the variable the pin's scope binds by other
+                        // statements too, renamed whole (fix #424).
+                        if (Array.isArray(ref.scopeDefLines) && ref.scopeDefLines.includes(pinNameLine)) return 'edit';
+                        return pinScopeRebound && referenceInPinScope(ref) ? 'edit' : null;
                     }
                     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);
+                        const contains = !binder.container || holds(binder.container, ref);
                         if (!contains) continue;
                         const size = binder.container
                             ? binder.container.end - binder.container.start
                             : Infinity;
-                        if (!winner || size < winner.size) {
-                            winner = { def: binder.def, size };
+                        const width = binder.container ? spanWidth(binder.container) : Infinity;
+                        if (!winner || size < winner.size || (size === winner.size && width < winner.width)) {
+                            winner = { def: binder.def, size, width };
                             ambiguous = false;
-                        } else if (size === winner.size &&
+                        } else if (size === winner.size && width === winner.width &&
                             binder.def !== winner.def) {
                             ambiguous = true;
                         }
@@ -4634,6 +5264,24 @@ function plan(index, name, options = {}) {
                     return null;
                 }
                 if (def.className) return null;
+                // Go (fix #425): a bare name no local binds denotes the
+                // package-level declaration of the reference's own package
+                // (directory and package clause, test visibility), or the
+                // exported name a dot import brings into the file.
+                if (!ref.receiver && ref.scopeBinding === 'module' && !def.receiver &&
+                    langTraits(index.files.get(ref.file)?.language)?.packageScope === 'directory') {
+                    const { goSamePackage } = require('./go-packages');
+                    if (goSamePackage(index, ref.file, def.file)) return 'edit';
+                    return goDotImportReaches(index, ref.file, def) ? 'edit' : null;
+                }
+                // `pkg.F` (fix #425): an import no local shadows names the
+                // imported package's declaration.
+                if (ref.receiver && !def.receiver &&
+                    langTraits(index.files.get(ref.file)?.language)?.packageScope === 'directory') {
+                    if (!goImportReaches(index, ref.file, ref.receiver, def)) return null;
+                    const local = goSelectorReceiverIsLocal(index, ref);
+                    return local === false ? 'edit' : local === true ? null : 'review';
+                }
                 // Module-attribute references carry stronger evidence
                 // than a bare name: `import requests; requests.put` binds
                 // through requests' export chain even inside a function.
@@ -4657,8 +5305,29 @@ function plan(index, name, options = {}) {
                 if (ref.scopeBinding === 'module' && cExternalReferenceLanguage(index, ref.file)) {
                     return cExternalReferenceVerdict(index, ref, def, pinIdentity, definitions);
                 }
+                // A file-scope reference of a statically scoped module names
+                // that module's own top-level declaration of the name when no
+                // import binds it (fix #423, pino `const { epochTime } =
+                // time`): a local declaration, never the pin of another file.
+                if (ref.scopeBinding === 'module' &&
+                    langTraits(index.files.get(ref.file)?.language)?.staticModuleScope) {
+                    const refEntry = index.files.get(ref.file);
+                    const imported = (refEntry?.importBindings || []).some(binding =>
+                        (binding.alias || binding.name) === name);
+                    if (!imported && (refEntry?.symbols || []).some(symbol => symbol.name === name &&
+                        !symbol.className && !symbol.memberAssigned && !symbol.bodyScopedName &&
+                        !(refEntry.symbols || []).some(scope => scope !== symbol &&
+                            scopeKinds.has(scope.type) && scope.startLine <= symbol.startLine &&
+                            (scope.endLine || scope.startLine) >= (symbol.endLine || symbol.startLine) &&
+                            !(scope.startLine === symbol.startLine && scope.endLine === symbol.endLine)))) {
+                        return null;
+                    }
+                }
+                // The chain must arrive under the pin's own name (fix #423,
+                // swr `import { middleware as preload }`): an import alias
+                // spelled like the pin binds the other export.
                 const ownership = _nameBindingReaches(
-                    index, ref.file, name, renameTargetFiles);
+                    index, ref.file, name, renameTargetFiles, 4, { targetName: name });
                 if (ownership === 'yes' &&
                     (ref.scopeBinding === 'module' ||
                         !insideFunctionLike(ref.file, ref.line))) {
@@ -4668,6 +5337,10 @@ function plan(index, name, options = {}) {
             };
             const eligible = (ref) => {
                 if (ref.usageType !== 'reference' || ref.isDefinition) return false;
+                // A module path segment names a module; the name of `from m
+                // import name as alias` is decided by m in the import pass
+                // (fix #424), never by this file's binding of the name.
+                if (ref.modulePath || ref.importSource) 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).
@@ -4700,7 +5373,9 @@ function plan(index, name, options = {}) {
                 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) {
+                // A path value (`T::m`, fix #422) is its own token.
+                if (verdict === 'edit' && ref.file === def.file && def.className &&
+                    records.some((record, i) => verdicts[i] === 'edit' && !record.scopedReference)) {
                     const selfColumns = selfMemberTokenColumns(index, def.file, ref.line, name);
                     if (selfColumns.length === 0) verdict = 'review';
                     else refColumns = selfColumns;
@@ -4742,6 +5417,22 @@ function plan(index, name, options = {}) {
                     continue;
                 }
                 if (existing) {
+                    const uneditedReview = records.some((record, i) => verdicts[i] === 'review' &&
+                        (!Number.isInteger(record.column) || !existing._edit?.columns.includes(record.column)));
+                    // Type lookup decides every token in its later pass,
+                    // including another type token beside this construction.
+                    if (uneditedReview && !isTypeRenamePin(def) && !existing.needsReview) {
+                        changes.push({
+                            file: rel,
+                            line: ref.line,
+                            expression: (ref.content || '').trim(),
+                            suggestion: `Verify this reference resolves to ` +
+                                `${name} at ${def.relativePath || def.file}:` +
+                                `${def.startLine} before renaming`,
+                            needsReview: true,
+                            editKind: 'reference',
+                        });
+                    }
                     // 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
@@ -4768,7 +5459,7 @@ function plan(index, name, options = {}) {
                         editKind: 'reference',
                     }, edit));
                 } else {
-                    changes.push({
+                    const review = {
                         file: rel,
                         line: ref.line,
                         expression: (ref.content || '').trim(),
@@ -4777,7 +5468,53 @@ function plan(index, name, options = {}) {
                             `${def.startLine} before renaming`,
                         needsReview: true,
                         editKind: 'reference',
-                    });
+                    };
+                    // The tokens under review (fix #419): a declaration edit
+                    // of this line that renames them already decides them.
+                    const reviewed = records.map(record => record.column);
+                    if (reviewed.every(Number.isInteger)) {
+                        Object.defineProperty(review, '_reviewColumns', { value: reviewed, enumerable: false });
+                    }
+                    changes.push(review);
+                }
+            }
+            // An object-pattern key that destructures the pin from a module
+            // object (fix #423, pino `const time = require('./lib/time');
+            // const { epochTime } = time`) reads the module member: the key
+            // is renamed and the local kept, as for a destructured member
+            // call. A module chain UCN cannot follow is a review item.
+            if (!def.className) {
+                const seenPatternLines = new Set();
+                for (const u of usages) {
+                    if (!u.isDefinition || u.file === def.file || !u.file) continue;
+                    const fileLanguage = index.files.get(u.file)?.language;
+                    if (!langTraits(fileLanguage)?.staticModuleScope) continue;
+                    const lineKey = `${u.file}:${u.line}`;
+                    if (seenPatternLines.has(lineKey)) continue;
+                    seenPatternLines.add(lineKey);
+                    for (let line = u.startLine || u.line; line <= (u.endLine || u.line); line++) {
+                        for (const key of objectPatternKeysAt(index, u.file, line, name)) {
+                            const verdict = _moduleAttributeBindingReaches(index, u.file, key.source, name,
+                                renameTargetFiles);
+                            if (verdict === 'yes') {
+                                emitPatternKeyEdit(u.file, u.relativePath || u.file, key);
+                            } else if (verdict === 'unknown') {
+                                const rel = u.relativePath || u.file;
+                                if (!reviewItems.some(item => item.file === rel && item.line === key.line)) {
+                                    reviewItems.push({
+                                        file: rel,
+                                        line: key.line,
+                                        expression: (index.getLineContent(u.file, key.line) || '').trim(),
+                                        suggestion: `Verify whether "${key.source}.${name}" names ${name} at ` +
+                                            `${def.relativePath || def.file}:${def.startLine}; if it does, ` +
+                                            `rename the destructured property to "${options.renameTo}", keeping the local binding`,
+                                        needsReview: true,
+                                        editKind: 'reference',
+                                    });
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -4786,9 +5523,46 @@ function plan(index, name, options = {}) {
         // form: attribute reads and writes. Reuse impact's receiver-evidence
         // query so a typed field is edited mechanically and an unresolved
         // receiver is surfaced for review instead of silently omitted.
-        const accessorReferences = findAccessorReferences(index, name, def, {
+        let accessorReferences = findAccessorReferences(index, name, def, {
             includeTests: true,
         });
+        // A property's dispatch slot (fix #426): an access the pin's lookup
+        // leaves to an overriding member (`Count` read inside a subclass
+        // declaring `override Count`) is an access of that slot member, and
+        // so is one the pin's own lookup could not decide but a slot
+        // member's lookup confirms. The members' confirmed accesses join the
+        // pin's answer; what they leave undecided the pin's own answer
+        // already partitions.
+        const slotAccessors = accessorReferences && hierarchySlot
+            ? [...hierarchySlot.ancestors, ...hierarchySlot.descendants]
+                .flatMap(entry => entry.members)
+                .filter(member => member !== def && isAccessorDefinition(member))
+            : [];
+        if (slotAccessors.length > 0) {
+            const tokenKey = ref => `${ref.absoluteFile}\0${ref.line}\0${ref.column ?? '*'}`;
+            const confirmed = new Map(accessorReferences.confirmed.map(ref => [tokenKey(ref), ref]));
+            const unverified = [...accessorReferences.unverified];
+            for (const member of slotAccessors.slice(0, 25)) {
+                const answer = findAccessorReferences(index, name, member, { includeTests: true });
+                if (!answer) continue;
+                for (const ref of answer.confirmed) {
+                    if (!confirmed.has(tokenKey(ref))) confirmed.set(tokenKey(ref), ref);
+                }
+            }
+            const sort = (a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line ||
+                (a.column ?? -1) - (b.column ?? -1);
+            const seenUnverified = new Set();
+            accessorReferences = {
+                ...accessorReferences,
+                confirmed: [...confirmed.values()].sort(sort),
+                unverified: unverified.filter(ref => {
+                    const key = tokenKey(ref);
+                    if (confirmed.has(key) || seenUnverified.has(key)) return false;
+                    seenUnverified.add(key);
+                    return true;
+                }).sort(sort),
+            };
+        }
         if (accessorReferences) {
             const confirmedByLine = new Map();
             for (const ref of accessorReferences.confirmed) {
@@ -4833,8 +5607,7 @@ function plan(index, name, options = {}) {
                 const existing = changes.find(change =>
                     change.file === ref.file && change.line === ref.line &&
                     !change.needsReview);
-                if (existing) Object.assign(existing, concrete);
-                else changes.push(concrete);
+                if (!existing || !mergeTokenEdit(existing, edit)) changes.push(tagTokenEdit(concrete, edit));
             }
             const listedAccess = new Set();
             for (const ref of accessorReferences.unverified) {
@@ -4861,6 +5634,8 @@ function plan(index, name, options = {}) {
             const rel = textRef.relativePath || textRef.file;
             if (reviewItems.some(item =>
                 item.file === rel && item.line === textRef.line)) continue;
+            if (changes.some(change => change.dunderAllEntry && change.file === rel &&
+                change.line === textRef.line)) continue;
             reviewItems.push({
                 file: rel,
                 line: textRef.line,
@@ -4882,8 +5657,23 @@ function plan(index, name, options = {}) {
     const definitionLine = def.nameLine || def.startLine;
     const definitionFile = def.relativePath || def.file;
     const definitionSource = index.getLineContent(def.file, definitionLine).trim();
+    // A reference awaiting review on this line stays a separate item, with
+    // its reason; the declaration token still has its own certain edit
+    // (fix #419: only accessor pins kept it apart). A type rename's own pass
+    // decides every token of its lines.
+    let definitionEdit;
+    const declarationEdit = () => definitionEdit ||= renameIdentifierTokens(index, def.file,
+        definitionLine, name, options.renameTo, null, null, { definitionNameOnly: true, definition: def });
+    const decidedByDeclaration = change => Array.isArray(change._reviewColumns) && (() => {
+        const edit = declarationEdit();
+        return Array.isArray(edit.columns) && change._reviewColumns.every(column =>
+            edit.columns.includes(tokenColumn(edit.rawSource || '', column, name)));
+    })();
+    const separateReview = change => !!options.renameTo && !!change.needsReview &&
+        (isAccessorDefinition(def) || (!isTypeRenamePin(def) && change.editKind === 'reference' &&
+            !change.isDefinition && !decidedByDeclaration(change)));
     const existingDefinitionLine = changes.find(change =>
-        change.file === definitionFile && change.line === definitionLine);
+        change.file === definitionFile && change.line === definitionLine && !separateReview(change));
     // 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
@@ -4903,9 +5693,7 @@ function plan(index, name, options = {}) {
         existingDefinitionLine.isDefinition = true;
         existingDefinitionLine.editKind = 'definition';
         if (options.renameTo) {
-            const defEdit = renameIdentifierTokens(index, def.file,
-                definitionLine, name, options.renameTo,
-                null, null, { definitionNameOnly: true, definition: def });
+            const defEdit = declarationEdit();
             // Keep the tokens the line's other edit renames (a recursive or
             // delegating call on the declaration line) (fix #376).
             if (!(existingDefinitionLine.newExpression !== undefined &&
@@ -4924,9 +5712,7 @@ function plan(index, name, options = {}) {
             editKind: 'definition',
         };
         if (options.renameTo) {
-            const defEdit = renameIdentifierTokens(index, def.file,
-                definitionLine, name, options.renameTo,
-                null, null, { definitionNameOnly: true, definition: def });
+            const defEdit = declarationEdit();
             const renamed = defEdit.renamed;
             definitionChange.newExpression = renamed;
             definitionChange.suggestion = `Update definition: ${renamed}`;
@@ -5035,6 +5821,25 @@ function plan(index, name, options = {}) {
     // resolve to exactly the renamed declaration is a review item.
     let typePass = null;
     const fileRenames = [];
+    if (options.renameTo && isValueDefinition(def) && planGroundSet && !def.macroExpansion) {
+        const { valueReferenceSites } = require('./value-references');
+        const references = valueReferenceSites(index, def, name, planGroundSet);
+        if (references.ambiguousDeclaration) return { found: true, function: name,
+            error: references.ambiguityReason === 'storage'
+                ? 'This source handle names both a static and an instance field. Put the declarations on separate source lines to select one.'
+                : 'This source handle names multiple value declarations in different scopes. Put the declarations on separate source lines to select one.' };
+        const valueRename = references.privateIdentifier ? `#${options.renameTo}` : options.renameTo;
+        if (references.privateIdentifier) {
+            const at = currentSignature.indexOf(name);
+            if (at >= 0) newSignature = currentSignature.slice(0, at) + valueRename +
+                currentSignature.slice(at + name.length);
+        }
+        typePass = applyTypeReferencePass(index, {
+            def, name, renameTo: valueRename, changes, reviewItems,
+            planUnverified, groundSet: planGroundSet, referenceKind: 'value',
+            referenceSites: references,
+        });
+    }
     if (options.renameTo && isTypeRenamePin(def) && planGroundSet &&
         !def.macroExpansion) {
         typePass = applyTypeReferencePass(index, {
@@ -5055,6 +5860,29 @@ function plan(index, name, options = {}) {
         }
     }
 
+    // A descendant's instance write can read the inherited method before
+    // replacing it. The field declaration is a different binding, but its
+    // initializer still needs review when this method is renamed.
+    if (options.renameTo && def.className && !isValueDefinition(def)) {
+        const { instanceAttributeInitializerReads } = require('./value-references');
+        for (const member of definitions) {
+            if (!member.instanceAttribute) continue;
+            const owner = ownerRefOf(index, member);
+            if (!owner || descendsFromTargets(index, owner, [def]) === 'no') continue;
+            for (const site of instanceAttributeInitializerReads(index, member)) {
+                const file = member.relativePath || path.relative(index.root, member.file);
+                if (changes.some(change => change.file === file && change.line === site.line &&
+                    change._edit?.columns?.includes(site.column))) continue;
+                if (reviewItems.some(item => item.file === file && item.line === site.line &&
+                    item.reviewReason === 'instance-attribute-before-write')) continue;
+                reviewItems.push({ file, line: site.line,
+                    expression: index.getLineContent(member.file, site.line).trim(),
+                    suggestion: `Review the previous ${name} value read before this instance attribute is written`,
+                    needsReview: true, reviewReason: 'instance-attribute-before-write', editKind: 'reference' });
+            }
+        }
+    }
+
     // 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
@@ -5278,12 +6106,43 @@ function plan(index, name, options = {}) {
         planUnverified.push(...kept);
     }
 
+    // Configuration-dependent C/C++ bindings (fix #413): a site in a known
+    // arm where an imported declaration, not any declaration the rename
+    // changes, binds the name keeps its spelling; the plan's ACCOUNT lists
+    // it as another target (fix #419: never dropped unreported). A site the
+    // build configuration decides is a review item.
+    const configurationOther = [];
+    if (options.renameTo && langTraits(planLang)?.textualIncludes) {
+        const { conditionalImportBinding } = require('./cpp-scope');
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const change = changes[i];
+            if (change.editKind === 'definition' || change.needsReview ||
+                change.newExpression === undefined) continue;
+            // A site in another alternative's branch binds that alternative,
+            // which the rename changes too: 'other' means outside the whole
+            // closure (fix #419).
+            const configuration = conditionalImportBinding(index, renameClosure, {
+                file: path.resolve(index.root, change.file), line: change.line,
+            });
+            if (configuration === 'other') {
+                changes.splice(i, 1);
+                configurationOther.push({ file: path.resolve(index.root, change.file), line: change.line,
+                    reason: 'configuration-other' });
+            } else if (configuration === 'uncertain') {
+                delete change.newExpression;
+                change.needsReview = true;
+                change.reviewReason = 'configuration-alternative';
+                change.suggestion = 'Build configuration selects this name\'s declaration; review this reference before renaming it';
+            }
+        }
+    }
+
     // 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)) {
+        (slotAccountSites.length > 0 || planUnverified.length > 0 || typePass || configurationOther.length > 0)) {
         const pathMod = require('path');
         const absoluteOf = file => (pathMod.isAbsolute(file) ? file : pathMod.join(index.root, file));
         const editedCallLines = new Set(changes.filter(change =>
@@ -5307,10 +6166,12 @@ function plan(index, name, options = {}) {
             }
             return { confirmed, excluded };
         };
+        const otherLines = new Set(configurationOther.filter(entry => !editedCallLines.has(
+            `${relOf(entry.file)}:${entry.line}`)).map(entry => `${entry.file}:${entry.line}`));
         const build = (extra) => buildAccount(index, name, {
             groundSet: planGroundSet,
             confirmedEntries: [
-                ...planAccountParts.confirmedEntries,
+                ...planAccountParts.confirmedEntries.filter(entry => !otherLines.has(`${absoluteOf(entry.file)}:${entry.line}`)),
                 ...slotAccountSites.filter(site => editedCallLines.has(`${site.file}:${site.line}`))
                     .map(site => ({ file: site.absoluteFile || absoluteOf(site.file), line: site.line })),
                 ...extra.confirmed,
@@ -5320,7 +6181,7 @@ function plan(index, name, options = {}) {
                     !typeDecided.has(`${relOf(entry.file)}:${entry.line}`)),
                 ...planUnverified.map(site => ({ file: absoluteOf(site.file), line: site.line })),
             ],
-            excludedEntries: [...extra.excluded, ...planAccountParts.excludedEntries],
+            excludedEntries: [...configurationOther, ...extra.excluded, ...planAccountParts.excludedEntries],
         });
         let extra = typeClaims((typePass?.removed || []).map(site => `${site.file}:${site.line}`));
         planAccount = build(extra);
@@ -5692,7 +6553,7 @@ function analyzeCallSiteAST(index, filePath, lineNum, funcName) {
     };
 
     try {
-        const language = detectLanguage(filePath);
+        const language = index.languageOf(filePath);
         if (!language) return result;
 
         const parser = getParser(language);
@@ -5902,78 +6763,6 @@ function _docCrefMemberPass(index, name, renameTo, renamedDefs, changes, reviewI
 
 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)`,
@@ -5988,7 +6777,8 @@ function csharpLocalBinding(memberNode, node, name) {
  */
 function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
     const pathMod = require('path');
-    const { resolveClassRef, findDeclaringClass, parentRefsOf } = require('./class-identity');
+    const { resolveClassRef, findDeclaringClass, parentRefsOf, relationToTargets } = require('./class-identity');
+    const { externalTypeDenotation } = require('./type-denotation');
     const renamed = new Set(renamedDefs);
     const members = (index.symbols.get(name) || []).filter(d => d.className &&
         !IDENTITY_TYPE_KINDS_FOR_CREF.has(d.type));
@@ -6016,6 +6806,9 @@ function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
         if (column == null || !tree) return 'review';
         const node = tree.rootNode.descendantForPosition({ row, column });
         if (!node || node.type !== 'identifier' || node.text !== name) return 'review';
+        const position = referenceRole(node, index.files.get(ref.file)?.language);
+        if (position.role === 'unknown') return 'review';
+        if (position.role !== 'value' && position.role !== 'member') return null;
         const types = [];
         let member = null;
         for (let current = node.parent; current; current = current.parent) {
@@ -6025,12 +6818,37 @@ function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
         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;
+            // Typed instance method values and static method groups use
+            // the receiver's lookup, never the enclosing class (fix #411).
+            const typed = ref.receiverType;
+            const written = !typed && langTraits(index.files.get(ref.file)?.language)?.methodGroupReceiver?.(node);
+            if (!typed) {
+                if (!written) return 'review';
+                if (member && csharpLocalBinding(member, node, written.name) !== 'none') return 'review';
+                const receiverMembers = (index.symbols.get(receiver) || []).filter(d => d.className &&
+                    !d.isConstructor && d.type !== 'constructor' && d.className !== receiver &&
+                    !IDENTITY_TYPE_KINDS_FOR_CREF.has(d.type));
+                if (receiverMembers.length > 0) {
+                    for (const type of types) {
+                        const owner = classRefAt(ref.file, type);
+                        if (!owner || findDeclaringClass(index, owner, receiverMembers)) return 'review';
+                    }
+                }
+            }
+            const typeName = typed || written.name;
+            const qualifier = typed ? ref.receiverTypeQualifier : written.qualifier;
+            const arity = typed ? ref.receiverTypeArgs : written.arity;
+            if (externalTypeDenotation(index, ref.file, typeName, qualifier || null, ref.line)) return 'review';
+            const typeRef = resolveClassRef(index, typeName, ref.file, {
+                line: ref.line,
+                ...(qualifier && { namespace: qualifier }),
+                ...(Number.isInteger(arity) && { arity }),
+            });
+            if (!typeRef?.key || !typeRef.def) return 'review';
+            const relation = relationToTargets(index, typeRef, renamedDefs);
+            if (typed && (relation === 'ancestor' || relation === 'maybe')) return 'review';
+            const verdict = verdictOf(findDeclaringClass(index, typeRef, members));
+            return verdict === 'skip' ? null : verdict || (openAncestry(typeRef) ? 'review' : null);
         }
         if (!receiver && member) {
             const local = csharpLocalBinding(member, node, name);
@@ -6062,11 +6880,9 @@ function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
         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)));
+    // An explicit receiver can name the method too. Unresolved receivers
+    // remain review items instead of falling into simple-name lookup.
+    const candidateRecord = record => record.usageType === 'reference' && !record.isDefinition;
     for (const first of usages) {
         if (first.usageType !== 'reference' || first.isDefinition) continue;
         const abs = first.file;
@@ -6111,7 +6927,7 @@ function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
                 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`,
+                    `(an unresolved receiver, 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',