ucn 5.5.1 → 5.5.2

package/core/type-references.js

@@ -40,7 +40,33 @@
 const path = require('path');
 const { getParser, safeParse, langTraits, LANGUAGES } = require('../languages');
 const { sameNode } = require('../languages/utils');
+const { jsPatternTarget } = require('../languages/lexical-scope');
 const { classKeyOf } = require('./class-identity');
+const { projectHas, sharedRead, containingDeclarations } = require('./provenance-overload');
+const { indexedContent } = require('./source-memo');
+
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazyCppScopeModuleCache = null;
+const lazyCppScopeModule = () => lazyCppScopeModuleCache || (lazyCppScopeModuleCache = require('./cpp-scope'));
+
+/** The namespaces (packages) a language's files declare, with each dotted prefix. */
+function declaredNamespacePrefixes(index, language) {
+    return require('./type-denotation').memoizedDerivation(index, `\x01ns-prefixes\x00${language}`, () => {
+        const namespaces = new Set();
+        for (const entry of index.files.values()) {
+            if (entry.language !== language) continue;
+            for (const s of entry.symbols || []) {
+                if (!s.namespace) continue;
+                const parts = s.namespace.split('.');
+                for (let i = 1; i <= parts.length; i++) namespaces.add(parts.slice(0, i).join('.'));
+            }
+        }
+        return namespaces;
+    });
+}
+const csharpNamespacePrefixes = index => declaredNamespacePrefixes(index, 'csharp');
+const javaPackagePrefixes = index => declaredNamespacePrefixes(index, 'java');
 
 const TYPE_RENAME_KINDS = new Set([
     'class', 'struct', 'interface', 'trait', 'enum', 'record', 'union', 'type',
@@ -145,10 +171,22 @@ function classifyJava(node) {
             if (field === 'name') return skip('variable', { binding: true });
             break;
         case 'formal_parameter': case 'catch_formal_parameter': case 'spread_parameter':
-        case 'enhanced_for_statement': case 'resource': case 'record_pattern_component':
-            if (field === 'name' || node.type === 'identifier') return skip('parameter', { binding: true });
+        case 'enhanced_for_statement': case 'resource':
+            if (field === 'name') return skip('parameter', { binding: true });
+            break;
+        // Pattern variables (fix #420): `o instanceof T v`, `case T v`,
+        // `case R(int v, ..)` declare locals whose scope follows the
+        // pattern's flow (JLS 6.3.1).
+        case 'instanceof_expression':
+            if (field === 'name') return skip('pattern', { binding: true });
+            break;
+        case 'type_pattern': case 'record_pattern_component':
+            if (node.type === 'identifier') return skip('pattern', { binding: true });
             break;
-        case 'lambda_expression': case 'inferred_parameters':
+        case 'lambda_expression':
+            if (field === 'parameters') return skip('parameter', { binding: true });
+            break;
+        case 'inferred_parameters':
             return skip('parameter', { binding: true });
         case 'type_parameter':
             return skip('type-parameter', { typeParam: true });
@@ -179,8 +217,20 @@ function classifyJava(node) {
         case 'marker_annotation': case 'annotation':
             if (field === 'name') return { role: 'type' };
             break;
+        case 'element_value_pair':
+            if (field === 'key') return skip('annotation-element');
+            break;
         case 'labeled_statement': case 'break_statement': case 'continue_statement':
             return skip('label');
+        case 'object_creation_expression': {
+            // A qualified instance creation `outer.new Inner()` names a
+            // member class of the outer expression's type (JLS 15.9.1), not a
+            // type in scope at the site (fix #426).
+            const outer = parent.namedChild(0);
+            if (outer && field === 'type' && !sameNode(outer, node) &&
+                outer.endIndex <= node.startIndex) return { role: 'qualified-creation', outer };
+            break;
+        }
         default:
             break;
     }
@@ -188,6 +238,52 @@ function classifyJava(node) {
     if (node.type === 'identifier') return { role: 'value' };
     return { role: 'unknown', why: `java:${parent.type}` };
 }
+
+/**
+ * The declared type of a Java expression naming a value, read from its
+ * declaration in scope (fix #426): `this` is the enclosing class, a simple
+ * name the nearest local, parameter or field declaring it. null otherwise.
+ */
+function javaExpressionTypeName(expression) {
+    const head = typeNode => {
+        if (!typeNode) return null;
+        if (typeNode.type === 'generic_type') {
+            return head(typeNode.namedChildren.find(child =>
+                child.type === 'type_identifier' || child.type === 'scoped_type_identifier'));
+        }
+        if (typeNode.type === 'scoped_type_identifier') return typeNode.namedChildren.at(-1)?.text || null;
+        return typeNode.type === 'type_identifier' ? typeNode.text : null;
+    };
+    if (expression.type === 'this') {
+        const owner = ancestor(expression, JAVA_CLASS_NODES);
+        return owner?.childForFieldName('name')?.text || null;
+    }
+    if (expression.type !== 'identifier') return null;
+    const name = expression.text;
+    const declares = (declaration) => (declaration.namedChildren || []).some(child =>
+        child.type === 'variable_declarator' && child.childForFieldName('name')?.text === name);
+    for (let scope = expression.parent; scope; scope = scope.parent) {
+        if (scope.type === 'block' || scope.type === 'constructor_body' || scope.type === 'class_body') {
+            for (const child of scope.namedChildren || []) {
+                if (child.startIndex >= expression.startIndex && scope.type !== 'class_body') break;
+                if ((child.type === 'local_variable_declaration' || child.type === 'field_declaration') &&
+                    declares(child)) return head(child.childForFieldName('type'));
+            }
+        }
+        if (['method_declaration', 'constructor_declaration', 'lambda_expression'].includes(scope.type)) {
+            const params = scope.childForFieldName('parameters');
+            for (const param of params?.namedChildren || []) {
+                if ((param.type === 'formal_parameter' || param.type === 'spread_parameter') &&
+                    param.childForFieldName('name')?.text === name) return head(param.childForFieldName('type'));
+            }
+        }
+        if (JAVA_CLASS_NODES.has(scope.type)) {
+            // Fields of an enclosing class are in scope through its body.
+            continue;
+        }
+    }
+    return null;
+}
 const JAVA_CLASS_NODES = new Set(['class_declaration', 'enum_declaration', 'record_declaration',
     'interface_declaration']);
 
@@ -242,6 +338,9 @@ function classifyCSharp(node) {
         case 'alias_qualified_name':
             if (field === 'name') return { role: 'type', qualifier: parent.childForFieldName('alias'), aliasQualified: true };
             return skip('extern-alias');
+        case 'invocation_expression':
+            if (field === 'function') return skip('method-call');
+            break;
         case 'member_access_expression':
             if (field === 'name') return { role: 'member', receiver: parent.childForFieldName('expression') };
             return { role: 'value' };
@@ -302,11 +401,24 @@ function classifyJs(node) {
         case 'member_expression':
             if (field === 'property') return { role: 'member', receiver: parent.childForFieldName('object') };
             return { role: 'value' };
-        case 'required_parameter': case 'optional_parameter': case 'rest_pattern':
-        case 'formal_parameters': case 'array_pattern': case 'assignment_pattern':
-        case 'object_assignment_pattern':
+        case 'required_parameter': case 'optional_parameter':
+            // The parameter's pattern binds; its default value and type are
+            // read (fix #431: `x: number = LIMIT` reads LIMIT).
+            if (node.type === 'identifier' && field === 'pattern') return skip('parameter', { binding: true });
+            break;
+        case 'formal_parameters':
             if (node.type === 'identifier') return skip('parameter', { binding: true });
             break;
+        case 'rest_pattern': case 'array_pattern': case 'assignment_pattern':
+        case 'object_assignment_pattern': {
+            if (node.type !== 'identifier') break;
+            // A destructuring target declares a name, or (an assignment
+            // pattern, `[a, b] = f()`) writes the binding in scope (fix #431).
+            const target = jsPatternTarget(node);
+            if (target === 'declaration') return skip('parameter', { binding: true });
+            if (target === 'assignment') return { role: 'value', patternWrite: true };
+            break;
+        }
         case 'variable_declarator':
             if (field === 'name') return skip('variable', { binding: true });
             break;
@@ -333,6 +445,11 @@ function classifyJs(node) {
                 if (required) return { role: 'import', requireSource: required, aliased: true };
                 return skip('property-key');
             }
+            if (parent.type === 'pair_pattern' && field === 'value' && node.type === 'identifier') {
+                const target = jsPatternTarget(node);
+                if (target === 'declaration') return skip('destructured', { binding: true });
+                if (target === 'assignment') return { role: 'value', patternWrite: true };
+            }
             break;
         case 'type_parameter':
             if (field === 'name') return skip('type-parameter', { typeParam: true });
@@ -349,6 +466,8 @@ function classifyJs(node) {
         // `const { Widget } = require('./w')` is an import of Widget.
         const required = requireSourceOf(node);
         if (required) return { role: 'import', requireSource: required };
+        // `({ a } = obj)` writes the binding in scope (fix #431).
+        if (jsPatternTarget(node) === 'assignment') return { role: 'value', patternWrite: true };
         return skip('destructured', { binding: true });
     }
     if (node.type === 'type_identifier') return { role: 'type' };
@@ -459,7 +578,13 @@ function classifyGo(node) {
             if (field === 'name') return { role: 'decl', declNode: parent };
             break;
         case 'qualified_type':
-            if (field === 'name') return { role: 'type', qualifier: parent.childForFieldName('package') };
+            if (field === 'name') {
+                // In an expression the grammar reads the index of `x[a.b]`
+                // as a type argument `a.b` (fix #431): a selector on a value
+                // `a` unless `a` names an imported package.
+                return { role: 'type', qualifier: parent.childForFieldName('package'),
+                    ...(require('../languages/lexical-scope').goExpressionTypeArgument(parent) && { selectorOperand: true }) };
+            }
             return skip('package');
         case 'field_declaration':
             if (node.type === 'field_identifier') return skip('field-name');
@@ -569,6 +694,9 @@ function classifyRust(node) {
         case 'const_item': case 'static_item':
             if (field === 'name') return skip('constant', { binding: true });
             break;
+        case 'const_parameter':
+            if (field === 'name') return skip('parameter', { binding: true, genericParameter: true });
+            break;
         case 'mod_item':
             return skip('module-name');
         case 'label': case 'loop_label': case 'lifetime':
@@ -619,9 +747,18 @@ function classifyC(node, language) {
         case 'qualified_identifier': {
             const scope = parent.childForFieldName('scope');
             if (field === 'name') {
-                const declarator = parent.parent?.type === 'function_declarator' &&
-                    isField(parent, 'declarator');
-                if (declarator && scope && textOf(scope).replace(/<.*$/, '').split('::').pop() === node.text) {
+                let qualified = parent;
+                while (qualified.parent?.type === 'qualified_identifier' && isField(qualified, 'name')) {
+                    qualified = qualified.parent;
+                }
+                const declarator = qualified.parent?.type === 'function_declarator' &&
+                    isField(qualified, 'declarator') ? qualified.parent : null;
+                let declaration = declarator;
+                while (declaration?.parent && (isField(declaration, 'declarator') ||
+                    ['reference_declarator', 'parenthesized_declarator', 'attributed_declarator'].includes(declaration.parent.type))) {
+                    declaration = declaration.parent;
+                }
+                if (declarator && !declaration.childForFieldName('type') && scope) {
                     return { role: 'ctor-qualified', qualifier: scope, qualifiedNode: parent };
                 }
                 return { role: 'type', cppQualified: true };
@@ -640,16 +777,26 @@ function classifyC(node, language) {
         }
         case 'function_declarator': {
             if (field !== 'declarator') break;
+            // `typedef int F(void *data);` names a function type (fix #427).
+            if (parent.parent?.type === 'type_definition' && isField(parent, 'declarator')) {
+                return { role: 'decl', declNode: parent.parent, typedef: true };
+            }
             const classNode = ancestor(node, C_TYPE_SPECIFIERS, new Set(['compound_statement']));
             const body = classNode?.childForFieldName('body');
             // `struct List<K>::Node { Node(..) }` names its class by the
             // qualified name's last segment (fix #396).
-            const className = classNode?.childForFieldName('name');
-            const classBase = className?.type === 'qualified_identifier'
-                ? textOf(className).split('::').pop().replace(/<.*$/s, '') : className?.text;
+            let className = classNode?.childForFieldName('name');
+            while (className && (className.type === 'qualified_identifier' || className.type === 'template_type')) {
+                className = className.childForFieldName('name') || className.namedChild(0);
+            }
+            const classBase = className?.text;
             if (classNode && body && contains(body, node) && classBase === node.text) {
                 return { role: 'ctor', classNode };
             }
+            // A deduction guide's name is the class template's (fix #427).
+            if (language === 'cpp' && require('../languages/c-family').deductionGuideOf(parent.parent)) {
+                return { role: 'type' };
+            }
             return skip('function', { binding: true });
         }
         case 'field_initializer':
@@ -676,7 +823,8 @@ function classifyC(node, language) {
             if (node.type === 'field_identifier') return skip('field-name');
             break;
         case 'enumerator':
-            return skip('enumerator');
+            if (field === 'name') return skip('enumerator');
+            break;
         case 'type_parameter_declaration': case 'optional_type_parameter_declaration':
         case 'variadic_type_parameter_declaration':
             // `template <typename T = Widget>`: the default is a reference.
@@ -684,11 +832,21 @@ function classifyC(node, language) {
             return skip('type-parameter', { typeParam: true });
         case 'preproc_def': case 'preproc_function_def': case 'preproc_params':
             return skip('macro-name');
+        case 'structured_binding_declarator':
+            // `auto [a, b] = p;` declares each name (fix #420).
+            if (node.type === 'identifier') return skip('variable', { binding: true });
+            break;
+        case 'reference_declarator':
+            // The C++ grammar gives the referenced declarator no field name.
+            if (sameNode(parent.namedChild(0), node)) {
+                if (node.type === 'identifier') return skip('variable', { binding: true });
+                if (node.type === 'field_identifier') return skip('field-name');
+            }
+            break;
         case 'init_declarator': case 'parameter_declaration': case 'optional_parameter_declaration':
-        case 'pointer_declarator': case 'reference_declarator': case 'array_declarator':
+        case 'pointer_declarator': case 'array_declarator':
         case 'declaration':
-            if (node.type === 'identifier' && (field === 'declarator' || parent.type === 'pointer_declarator' ||
-                parent.type === 'reference_declarator' || parent.type === 'array_declarator')) {
+            if (['identifier', 'field_identifier'].includes(node.type) && field === 'declarator') {
                 return skip('variable', { binding: true });
             }
             break;
@@ -784,16 +942,30 @@ function typeParamScope(node) {
 // ── Identity of the pinned type ──────────────────────────────────────────
 
 function pinGroupOf(index, def, name) {
+    // Several construction witnesses may ask about the same type. Share
+    // the pure grouping calculation and all its reads, but give each
+    // resolver its own collections: value resolvers extend these groups.
+    const key = JSON.stringify(['type-pin-group', name, def]);
+    const saved = sharedRead(index, key, view => pinGroupFacts(view, def, name));
+    return { ...saved, group: new Set([def, ...saved.group]), all: [...saved.all] };
+}
+
+function pinGroupFacts(index, def, name) {
     const language = index.files.get(def.file)?.language;
     const family = familyOf(language);
-    const all = (index.symbols.get(name) || []).filter(d => TYPE_DECL_KINDS.has(d.type) &&
-        familyOf(index.files.get(d.file)?.language) === family);
+    // Different pins of one name inspect the same declarations. Their
+    // definition identities depend on the index, not on the selected pin.
+    const candidates = sharedRead(index, JSON.stringify(['type-pin-candidates', name, family]), view =>
+        (view.symbols.get(name) || []).filter(d => TYPE_DECL_KINDS.has(d.type) &&
+            familyOf(view.files.get(d.file)?.language) === family)
+            .map(d => ({ def: d, key: classKeyOf(view, d) })));
+    const all = candidates.map(candidate => candidate.def);
     const pinKey = classKeyOf(index, def);
-    const group = new Set([def]);
+    const group = new Set();
     let crossConfig = null;
-    for (const other of all) {
-        if (other === def) continue;
-        if (classKeyOf(index, other) === pinKey) {
+    for (const candidate of candidates) {
+        const other = candidate.def;
+        if (candidate.key === pinKey) {
             group.add(other);
             continue;
         }
@@ -821,7 +993,7 @@ function pinGroupOf(index, def, name) {
                 group.add(other);
                 continue;
             }
-            const { includeClosure } = require('./cpp-scope');
+            const { includeClosure } = lazyCppScopeModule();
             if (includeClosure(index, def.file).has(other.file) || includeClosure(index, other.file).has(def.file)) {
                 group.add(other);
                 continue;
@@ -830,7 +1002,7 @@ function pinGroupOf(index, def, name) {
             if (crossConfig(index, def.file, other.file)) group.add(other);
         }
     }
-    return { group, all, family, language };
+    return { group: [...group], all, family, language };
 }
 
 const CLASS_KEYWORD_KINDS = new Set(['class', 'struct']);
@@ -841,7 +1013,7 @@ function isHeader(file) {
 }
 
 function effectiveNs(index, d) {
-    const { effectiveNamespace } = require('./cpp-scope');
+    const { effectiveNamespace } = lazyCppScopeModule();
     return effectiveNamespace(index, d) || '';
 }
 
@@ -852,6 +1024,101 @@ function rustModulePath(index, d) {
 
 // ── Resolution ───────────────────────────────────────────────────────────
 
+// Whether a word occurrence of `name` in Rust source is followed, past
+// whitespace and comments, by `!`: what an invocation's path needs before
+// its token tree in a source that parses without error.
+function spelledBeforeBang(source, name) {
+    // ASCII word characters only: anything else around the name (Unicode
+    // identifiers, Unicode whitespace) keeps the file.
+    const word = c => (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+    for (let at = source.indexOf(name); at >= 0; at = source.indexOf(name, at + 1)) {
+        if (at > 0 && word(source.charCodeAt(at - 1)) || word(source.charCodeAt(at + name.length))) continue;
+        let i = at + name.length;
+        for (;;) {
+            const c = source.charCodeAt(i);
+            if (c > 127) return true;
+            if (c === 32 || c === 9 || c === 10 || c === 13 || c === 11 || c === 12) { i++; continue; }
+            if (c === 47 && source.charCodeAt(i + 1) === 47) {
+                const end = source.indexOf('\n', i);
+                if (end < 0) { i = source.length; break; }
+                i = end + 1;
+                continue;
+            }
+            if (c === 47 && source.charCodeAt(i + 1) === 42) {
+                let depth = 1;
+                i += 2;
+                while (i < source.length && depth > 0) {
+                    if (source.charCodeAt(i) === 47 && source.charCodeAt(i + 1) === 42) { depth++; i += 2; }
+                    else if (source.charCodeAt(i) === 42 && source.charCodeAt(i + 1) === 47) { depth--; i += 2; }
+                    else i++;
+                }
+                continue;
+            }
+            break;
+        }
+        if (source.charCodeAt(i) === 33) return true;
+    }
+    return false;
+}
+
+// The innermost class around a line by the index's declarations.
+function enclosingClassIn(index, file, line) {
+    const entry = index.files.get(file);
+    let best = null;
+    for (const s of entry?.symbols || []) {
+        if (s.startLine > line || s.endLine < line) continue;
+        const isClass = TYPE_DECL_KINDS.has(s.type) && s.type !== 'type';
+        const candidate = isClass ? s.name : (s.className || null);
+        if (!candidate) continue;
+        if (!best || (s.endLine - s.startLine) < (best.span)) {
+            best = { name: candidate, span: s.endLine - s.startLine };
+        }
+    }
+    return best?.name || null;
+}
+
+// The namespace and class a C/C++ site's lookup starts in: from the site's
+// own tree node when it has one (no pinned type takes part).
+function cppSiteContextOf(index, siteNode, siteFile, file, line, syntax = null) {
+    const node = siteNode && siteFile === file && siteNode.startPosition.row + 1 === line
+        ? siteNode : null;
+    const { macroNamespacePrefixAt, namespaceAt } = lazyCppScopeModule();
+    if (!node && !syntax) return { namespace: namespaceAt(index, file, line), className: enclosingClassIn(index, file, line) };
+    const facts = syntax || require('../languages/cpp-site-syntax').cppSiteSyntax(node);
+    const { namespaces, memberOf, recovered } = facts;
+    const classes = [...facts.classes];
+    // A class body the raw tree lost (macro-heavy headers, conditional
+    // members): the indexed nested classes around the line (parsed from
+    // the recovered source) still name their owners (fix #396: `union
+    // Data` inside `GenericValue`).
+    if (classes.length > 0) {
+        const symbols = index.files.get(file)?.symbols || [];
+        const around = name => symbols.find(s => s.name === name && TYPE_DECL_KINDS.has(s.type) &&
+            s.startLine <= line && line <= s.endLine);
+        for (let owner = around(classes[0].split('::').pop())?.enclosingType, depth = 0;
+            owner && depth < 8 && !classes.includes(owner); depth++) {
+            classes.unshift(owner);
+            owner = around(owner)?.enclosingType;
+        }
+    }
+    const prefix = macroNamespacePrefixAt(index, file, line);
+    const own = namespaces.join('::');
+    let namespace = prefix && own ? `${prefix}::${own}` : prefix || own;
+    let className = classes.length > 0 ? classes.join('::') : memberOf;
+    // Macro-heavy code can break the raw tree so that an enclosing
+    // namespace block closes early; the indexed declarations around the
+    // line (parsed from the recovered source) still carry it.
+    const indexed = namespaceAt(index, file, line);
+    if (indexed && indexed !== namespace && (namespace === '' || own === '' ||
+        indexed.endsWith(`::${own}`) || indexed.startsWith(`${namespace}::`) ||
+        (recovered && indexed.startsWith(namespace)))) namespace = indexed;
+    // Out-of-line member bodies: the index (parsed from the recovered
+    // source) knows their class even when a macro before the return type
+    // broke the literal head; the head's own qualifier is the fallback.
+    if (classes.length === 0) className = enclosingClassIn(index, file, line) || memberOf;
+    return { namespace, className };
+}
+
 class TypeReferenceResolver {
     constructor(index, def, name) {
         this.index = index;
@@ -862,6 +1129,7 @@ class TypeReferenceResolver {
         this.all = all;
         this.family = family;
         this.language = language;
+        this.declarationKinds = TYPE_DECL_KINDS;
         this.pinFiles = new Set([...group].map(d => d.file));
         this.memo = new Map();
         this._embedders = undefined;
@@ -869,6 +1137,41 @@ class TypeReferenceResolver {
 
     inGroup(d) { return this.group.has(d); }
 
+    /**
+     * The Python function scope the pinned class statement binds its name
+     * in (fix #424), when that scope binds the name by other statements
+     * too: one variable, renamed whole (its other bindings are the plan's
+     * alternative bindings), so a reference resolving to that scope names
+     * the pin's variable. Null for module and class-body scopes, which the
+     * module lookup and class-body order decide.
+     */
+    pythonPinScope(tree) {
+        if (this.family !== 'python' || !tree) return null;
+        if (this._pythonPinScope && this._pythonPinScope.tree === tree) return this._pythonPinScope.scope;
+        let scope = null;
+        const row = (this.def.nameLine || this.def.startLine) - 1;
+        const stack = [tree.rootNode];
+        let classNode = null;
+        while (stack.length > 0 && !classNode) {
+            const node = stack.pop();
+            if (node.startPosition.row > row || node.endPosition.row < row) continue;
+            if (node.type === 'class_definition' && node.childForFieldName('name')?.text === this.name &&
+                node.childForFieldName('name').startPosition.row === row) {
+                classNode = node;
+                break;
+            }
+            for (let i = node.namedChildCount - 1; i >= 0; i--) stack.push(node.namedChild(i));
+        }
+        const owner = classNode && bindingScope(classNode, 'python', {});
+        if (owner?.type === 'function_definition') {
+            const { pythonScopeBindingKinds } = require('../languages/lexical-scope');
+            const sites = pythonScopeBindingKinds(classNode.parent, this.name);
+            if (sites.some(site => !sameNode(site.node, classNode.childForFieldName('name')))) scope = owner;
+        }
+        this._pythonPinScope = { tree, scope };
+        return scope;
+    }
+
     /**
      * Generic arity written at the token being decided, where arity is part
      * of a type's identity (trait genericArityIsIdentity, fix #389): `X` is
@@ -876,9 +1179,14 @@ class TypeReferenceResolver {
      * site is not an identifier token (doc comments).
      */
     siteArity() {
+        if (this.siteSyntax && Number.isInteger(this.siteSyntax.arity)) return this.siteSyntax.arity;
         const node = this.siteNode;
         if (!node || node.type !== 'identifier' || !langTraits(this.language)?.genericArityIsIdentity) return null;
         const parent = node.parent;
+        if (CSHARP_TYPE_DECLS.has(parent?.type) && sameNode(parent.childForFieldName('name'), node)) {
+            const list = parent.namedChildren.find(child => child.type === 'type_parameter_list');
+            return list ? list.namedChildren.filter(child => child.type === 'type_parameter').length : 0;
+        }
         // A constructor or finalizer is named after its class without type
         // arguments (fix #390: `Strategy(..)` inside `class Strategy<T>`):
         // its arity is the enclosing declaration's.
@@ -911,7 +1219,7 @@ class TypeReferenceResolver {
     /** Type-like definitions of NAME declared in `file`. */
     fileTypes(file, name = this.name) {
         return (this.index.symbols.get(name) || []).filter(d => d.file === file &&
-            TYPE_DECL_KINDS.has(d.type));
+            this.declarationKinds.has(d.type));
     }
 
     /** Container range of a definition inside its own file (innermost
@@ -925,10 +1233,12 @@ class TypeReferenceResolver {
     }
 
     _containerOf(d) {
-        const entry = this.index.files.get(d.file);
         let best = null;
-        for (const s of entry?.symbols || []) {
+        for (const s of containingDeclarations(this.index, d) || []) {
             if (s === d || s.startLine == null || s.endLine == null) continue;
+            if (s.sourceSpan && d.sourceSpan &&
+                (s.sourceSpan.start > d.sourceSpan.start ||
+                 s.sourceSpan.end < d.sourceSpan.end)) continue;
             if (s.startLine > d.startLine || s.endLine < d.endLine) continue;
             if (s.startLine === d.startLine && s.endLine === d.endLine) continue;
             if (s.type === 'impl' || s.type === 'field') continue;
@@ -991,7 +1301,9 @@ class TypeReferenceResolver {
         if (!entry) return { verdict: 'unknown', reason: 'unindexed-file' };
         if (this.family === 'c') return this.resolveCFamily(file, line, name, null);
         if (this.family === 'rust') return this.resolveRustName(file, line, name);
-        const local = this.visibleInFile(file, line, name);
+        // A C# compilation unit can hold several namespace bodies. A type
+        // declared somewhere in the file is not automatically in scope.
+        const local = this.family === 'csharp' ? [] : this.visibleInFile(file, line, name);
         if (local.length > 0) {
             // A module-scope assignment of the name rebinds it, unless that
             // assignment is the type's own declaration (a type alias).
@@ -1013,7 +1325,16 @@ class TypeReferenceResolver {
 
     chase(startFile, name) {
         const { _nameBindingReaches } = require('./callers');
-        return _nameBindingReaches(this.index, startFile, name, this.pinFiles, 8, { exactName: true });
+        const reach = _nameBindingReaches(this.index, startFile, name, this.pinFiles, 8,
+            { exactName: true, configurationVerdict: true });
+        // A module binding the name through one alternative of a
+        // configuration item keeps the item's name (fix #424, the #398F
+        // import rule): its importers' and attribute readers' tokens name
+        // the item, never the renamed pin.
+        // Value dependencies still reach the chosen alternative at runtime.
+        // Its importers keep the chooser's name, so they are review sites,
+        // never automatic edits of one alternative's declaration.
+        return reach === 'configuration' ? (this.valueReferences ? 'unknown' : 'no') : reach;
     }
 
     moduleFile(entry, module) {
@@ -1187,29 +1508,12 @@ class TypeReferenceResolver {
      * the namespace of the indexed types around the line.
      */
     csharpSiteNamespace(file, line) {
+        if (this.siteSyntax?.file === file && this.siteSyntax.line === line) {
+            return this.siteSyntax.context.scopes.at(-1)?.namespace || '';
+        }
         const node = this.siteNode && this.siteFile === file && this.siteNode.startPosition.row + 1 === line
             ? this.siteNode : null;
-        if (node) {
-            const parts = [];
-            let root = node;
-            for (let current = node.parent; current; current = current.parent) {
-                if (current.type === 'namespace_declaration') {
-                    const nameNode = current.childForFieldName('name');
-                    if (nameNode) parts.unshift(textOf(nameNode));
-                }
-                root = current;
-            }
-            for (let i = 0; i < root.namedChildCount; i++) {
-                const child = root.namedChild(i);
-                if (child.startIndex > node.startIndex) break;
-                if (child.type === 'file_scoped_namespace_declaration') {
-                    const nameNode = child.childForFieldName('name');
-                    if (nameNode) parts.unshift(textOf(nameNode));
-                    break;
-                }
-            }
-            if (parts.length > 0) return parts.join('.');
-        }
+        if (node) return require('../languages/csharp-scope').usingScopesOf(node).at(-1)?.namespace || '';
         const { siteNamespaceOf } = require('./type-denotation');
         return siteNamespaceOf(this.index.files.get(file), line);
     }
@@ -1226,10 +1530,10 @@ class TypeReferenceResolver {
         const entry = this.index.files.get(file);
         const { csharpUsings } = require('./type-denotation');
         const candidates = this.all.filter(d => d.name === name && !d.enclosingType);
-        const alias = (entry.importBindings || []).some(b => b.name === name && b.kind === 'using');
-        if (alias) return { verdict: 'no', reason: 'using-alias' };
         const site = this.csharpSiteNamespace(file, line);
         if (site === undefined) return { verdict: 'unknown', reason: 'unknown-namespace' };
+        const localNested = this.visibleInFile(file, line, name).filter(d => d.enclosingType);
+        if (localNested.length) return this.judge(localNested);
         // Member types of an enclosing class come first, declared in any
         // `partial` part of it (fix #395: `readonly DepthLimiter _d;` in one
         // part of `partial class PropertyValueConverter`, the nested class
@@ -1250,6 +1554,7 @@ class TypeReferenceResolver {
                 if (members.length > 0) return this.judge(members);
             }
         }
+        const scope = csharpUsings(this.index, file, site, this.siteNode, this.siteSyntax?.context);
         const chain = [];
         for (let parts = site ? site.split('.') : []; parts.length > 0; parts = parts.slice(0, -1)) {
             chain.push(parts.join('.'));
@@ -1257,15 +1562,20 @@ class TypeReferenceResolver {
         chain.push('');
         for (const ns of chain) {
             const here = candidates.filter(d => (d.namespace || '') === ns);
+            const alias = scope.aliases.has(name) && scope.aliasScopes?.get(name) === ns;
+            if (alias && (here.length || scope.ambiguousAliases.has(name))) {
+                return { verdict: 'unknown', reason: 'ambiguous-type' };
+            }
             if (here.length > 0) return this.judge(here);
+            if (alias) return { verdict: 'no', reason: 'using-alias' };
+            // This namespace's imports are considered before its parent's
+            // declarations; using-static directives can provide nested types.
+            const usings = new Set([...scope.namespaces, ...scope.statics].filter(module =>
+                scope.namespaceScopes.get(module)?.has(ns) || scope.staticScopes.get(module)?.has(ns)));
+            const viaUsing = candidates.filter(d => usings.has(d.namespace || '') ||
+                (d.enclosingType && usings.has(`${d.namespace ? d.namespace + '.' : ''}${d.enclosingType}`)));
+            if (viaUsing.length > 0) return this.judge(viaUsing);
         }
-        // Using directives resolved from the namespace each is written in
-        // (fix #395: `namespace FluentValidation; using Results;` names
-        // FluentValidation.Results); `using static` also brings nested types.
-        const scope = csharpUsings(this.index, file);
-        const usings = new Set([...scope.namespaces, ...scope.statics]);
-        const viaUsing = candidates.filter(d => usings.has(d.namespace || ''));
-        if (viaUsing.length > 0) return this.judge(viaUsing);
         if ([...this.group].some(d => d.enclosingType) && this.inheritsFromPinOwner(file)) {
             return { verdict: 'unknown', reason: 'inherited-member-type' };
         }
@@ -1391,19 +1701,20 @@ class TypeReferenceResolver {
             if (entry?.language !== 'rust') continue;
             let content;
             try { content = this.index._readFile(file); } catch { continue; }
+            // A cleanly parsed file holds an invocation of the macro only
+            // where its name token is followed by `!` (fix #435: every file
+            // spelling a type-like macro name was parsed and walked).
+            if (!entry.parseErrorRegions && indexedContent(this.index, file, entry, content) &&
+                !spelledBeforeBang(content, macroName)) continue;
             const tree = this.index._getParsedTree?.(file, content, 'rust') || safeParse(getParser('rust'), content);
             if (!tree) continue;
             const rows = new Set(lineNumbers.map(n => n - 1));
-            const stack = [tree.rootNode];
-            while (stack.length > 0) {
-                const current = stack.pop();
-                if (current.type === 'macro_invocation' && rows.has(current.startPosition.row)) {
-                    const macro = current.childForFieldName('macro');
-                    if (macro && macro.text.split('::').pop() === macroName) {
-                        sites.push({ file, line: current.startPosition.row + 1 });
-                    }
+            for (const current of tree.rootNode.descendantsOfType('macro_invocation')) {
+                if (!rows.has(current.startPosition.row)) continue;
+                const macro = current.childForFieldName('macro');
+                if (macro && macro.text.split('::').pop() === macroName) {
+                    sites.push({ file, line: current.startPosition.row + 1 });
                 }
-                for (let i = current.namedChildCount - 1; i >= 0; i--) stack.push(current.namedChild(i));
             }
         }
         this.memo.set(key, sites);
@@ -1431,7 +1742,7 @@ class TypeReferenceResolver {
     rustModuleVerdict(resolved, name, depth) {
         const { rustModuleItems } = require('./rust-modules');
         const verdicts = [];
-        const items = rustModuleItems(this.index, resolved, name).filter(d => TYPE_DECL_KINDS.has(d.type));
+        const items = rustModuleItems(this.index, resolved, name).filter(d => this.declarationKinds.has(d.type));
         if (items.length > 0) verdicts.push(this.judge(items));
         for (const moduleEntry of resolved.entries) {
             const target = this.index.files.get(moduleEntry.file);
@@ -1501,36 +1812,23 @@ class TypeReferenceResolver {
 
     // ── C / C++ ──
 
-    enclosingClassAt(file, line) {
-        const entry = this.index.files.get(file);
-        let best = null;
-        for (const s of entry?.symbols || []) {
-            if (s.startLine > line || s.endLine < line) continue;
-            const isClass = TYPE_DECL_KINDS.has(s.type) && s.type !== 'type';
-            const candidate = isClass ? s.name : (s.className || null);
-            if (!candidate) continue;
-            if (!best || (s.endLine - s.startLine) < (best.span)) {
-                best = { name: candidate, span: s.endLine - s.startLine };
-            }
-        }
-        return best?.name || null;
-    }
+    enclosingClassAt(file, line) { return enclosingClassIn(this.index, file, line); }
 
     resolveCFamily(file, line, name, qualifierText, options = {}) {
         const entry = this.index.files.get(file);
-        const { includeClosure, resolveQualifier } = require('./cpp-scope');
+        const { includeClosure, resolveQualifier } = lazyCppScopeModule();
         const visible = includeClosure(this.index, file);
         if (entry.language === 'c') {
             // C tags (struct/union/enum) live in their own namespace; typedef
             // names in the ordinary one.
             const tagSite = options.tag != null;
             const candidates = this.all.filter(d => d.name === name &&
-                (tagSite ? !cOrdinaryName(d) : cOrdinaryName(d)));
+                (this.valueReferences || (tagSite ? !cOrdinaryName(d) : cOrdinaryName(d))));
             const seen = candidates.filter(d => d.file === file || visible.has(d.file));
             if (seen.length > 0) return this.judge(seen);
             return { verdict: 'unknown', reason: 'not-in-include-closure' };
         }
-        const spelling = qualifierText ? `${qualifierText}::${name}` : name;
+        const spelling = qualifierText ? `${qualifierText}${qualifierText.endsWith('::') ? '' : '::'}${name}` : name;
         if (qualifierText && this.def.enclosingType) {
             // `Acc<T>::Member` / `Acc<double>::Member` against a member of a
             // specialization: the template arguments pick the class.
@@ -1573,9 +1871,12 @@ class TypeReferenceResolver {
         const site = this.cppSiteContext(file, line);
         const context = { file, line, namespace: site.namespace,
             className: qualifierText && qualifierText.startsWith('::') ? null : site.className };
-        const found = resolveQualifier(this.index, context, spelling, visible, 0, { declarations: true });
+        const found = resolveQualifier(this.index, context, spelling, visible, 0,
+            { declarations: true, values: this.valueReferences === true,
+                ...(this.valueReferences && this.siteNode && { valueSite: {
+                    file: this.siteFile || file, index: this.siteNode.startIndex } }) });
         if (found.kind === 'namespace') return { verdict: 'no', reason: 'namespace' };
-        if (found.kind === 'type') {
+        if (found.kind === 'type' || found.kind === 'value') {
             const declarations = (found.declarations || []).filter(d => !functionLocal(d) || localInScope(d));
             const siblings = this.cppSiblingMembers(declarations);
             if (siblings) {
@@ -1689,7 +1990,7 @@ class TypeReferenceResolver {
      * from file:line (its injected class name), or null. */
     cppBaseNamed(file, line, className, name, depth) {
         if (depth > 3) return null;
-        const { includeClosure, resolveQualifier, effectiveNamespace } = require('./cpp-scope');
+        const { includeClosure, resolveQualifier, effectiveNamespace } = lazyCppScopeModule();
         const { splitParentList } = require('./graph-build');
         const visible = includeClosure(this.index, file);
         const simple = String(className).split('::').pop();
@@ -1726,73 +2027,9 @@ class TypeReferenceResolver {
      * other lines outside every indexed symbol keep their real scope.
      */
     cppSiteContext(file, line) {
-        const node = this.siteNode && this.siteFile === file && this.siteNode.startPosition.row + 1 === line
-            ? this.siteNode : null;
-        const { macroNamespacePrefixAt, namespaceAt } = require('./cpp-scope');
-        if (!node) return { namespace: namespaceAt(this.index, file, line), className: this.enclosingClassAt(file, line) };
-        const namespaces = [];
-        const classes = [];
-        let memberOf = null;
-        let recovered = false;
-        for (let current = node.parent; current; current = current.parent) {
-            if (current.type === 'ERROR') recovered = true;
-            if (current.type === 'namespace_definition') {
-                const nameNode = current.childForFieldName('name');
-                if (nameNode) namespaces.unshift(textOf(nameNode));
-            } else if (C_TYPE_SPECIFIERS.has(current.type)) {
-                const body = current.childForFieldName('body');
-                const nameNode = current.childForFieldName('name');
-                if (body && contains(body, node) && nameNode) {
-                    // Specializations keep their arguments (`Acc<double>`), as
-                    // the index names them; an out-of-class nested definition
-                    // (`struct List<K>::Node`) is in its owner's scope too
-                    // (fix #396).
-                    const segments = textOf(nameNode).split('::');
-                    classes.unshift(segments.slice(-2).join('::'));
-                }
-            } else if (current.type === 'function_definition' && !memberOf && classes.length === 0) {
-                let declarator = current.childForFieldName('declarator');
-                while (declarator && declarator.type !== 'function_declarator' && declarator.childForFieldName?.('declarator')) {
-                    declarator = declarator.childForFieldName('declarator');
-                }
-                const qualified = declarator?.childForFieldName?.('declarator');
-                if (qualified?.type === 'qualified_identifier') {
-                    const scope = qualified.childForFieldName('scope');
-                    // `List<K>::Node::f`: Node's scope, then List's (fix #396).
-                    if (scope) memberOf = qualifiedScopeText(qualified) || textOf(scope).split('::').pop();
-                }
-            }
-        }
-        // A class body the raw tree lost (macro-heavy headers, conditional
-        // members): the indexed nested classes around the line (parsed from
-        // the recovered source) still name their owners (fix #396: `union
-        // Data` inside `GenericValue`).
-        if (classes.length > 0) {
-            const symbols = this.index.files.get(file)?.symbols || [];
-            const around = name => symbols.find(s => s.name === name && TYPE_DECL_KINDS.has(s.type) &&
-                s.startLine <= line && line <= s.endLine);
-            for (let owner = around(classes[0].split('::').pop())?.enclosingType, depth = 0;
-                owner && depth < 8 && !classes.includes(owner); depth++) {
-                classes.unshift(owner);
-                owner = around(owner)?.enclosingType;
-            }
-        }
-        const prefix = macroNamespacePrefixAt(this.index, file, line);
-        const own = namespaces.join('::');
-        let namespace = prefix && own ? `${prefix}::${own}` : prefix || own;
-        let className = classes.length > 0 ? classes.join('::') : memberOf;
-        // Macro-heavy code can break the raw tree so that an enclosing
-        // namespace block closes early; the indexed declarations around the
-        // line (parsed from the recovered source) still carry it.
-        const indexed = namespaceAt(this.index, file, line);
-        if (indexed && indexed !== namespace && (namespace === '' || own === '' ||
-            indexed.endsWith(`::${own}`) || indexed.startsWith(`${namespace}::`) ||
-            (recovered && indexed.startsWith(namespace)))) namespace = indexed;
-        // Out-of-line member bodies: the index (parsed from the recovered
-        // source) knows their class even when a macro before the return type
-        // broke the literal head; the head's own qualifier is the fallback.
-        if (classes.length === 0) className = this.enclosingClassAt(file, line) || memberOf;
-        return { namespace, className };
+        const syntax = this.siteFile === file && this.siteContextSyntax?.line === line
+            ? this.siteContextSyntax.syntax : null;
+        return cppSiteContextOf(this.index, this.siteNode, this.siteFile, file, line, syntax);
     }
 
     // ── Qualified names ──
@@ -1847,6 +2084,21 @@ class TypeReferenceResolver {
                 return { verdict: 'no', reason: 'member' };
             }
             case 'go': {
+                // A local declared before the selector hides the package
+                // name in its block (fix #420: `conf := conf.Default` then
+                // `conf.Limit` reads a field of the local).
+                if (qualifierNode?.type === 'identifier') {
+                    if (!this._goScopes) this._goScopes = new WeakMap();
+                    let memo = this._goScopes.get(qualifierNode.tree);
+                    if (!memo) { memo = new Map(); this._goScopes.set(qualifierNode.tree, memo); }
+                    const { referenceScope } = require('../languages/lexical-scope');
+                    const scope = referenceScope(qualifierNode, 'go', memo, text);
+                    if (scope === 'unknown') return { verdict: 'unknown', reason: 'qualifier-scope' };
+                    if (scope && scope !== 'module' && scope !== 'none') {
+                        if (tok.role === 'member') return this.goFieldVerdict(this.siteNode, file);
+                        return { verdict: 'no', reason: 'local-binding' };
+                    }
+                }
                 const binding = (entry.importBindings || []).find(b => (b.alias || b.name) === text && b.module);
                 if (!binding) {
                     if (tok.role === 'member') return this.goFieldVerdict(this.siteNode, file);
@@ -1941,21 +2193,9 @@ class TypeReferenceResolver {
         return pythonModulePath(this.index, file, receiver, this.memo);
     }
 
-    javaPackages() {
-        const key = 'java-packages';
-        if (!this.memo.has(key)) {
-            const packages = new Set();
-            for (const entry of this.index.files.values()) {
-                if (entry.language !== 'java') continue;
-                for (const s of entry.symbols || []) {
-                    if (!s.namespace) continue;
-                    const parts = s.namespace.split('.');
-                    for (let i = 1; i <= parts.length; i++) packages.add(parts.slice(0, i).join('.'));
-                }
-            }
-            this.memo.set(key, packages);
-        }
-        return this.memo.get(key);
+    /** Does the project declare Java package `name` or one below it? */
+    javaPackageDeclared(name) {
+        return projectHas(this.index, 'java-package-prefixes', name, javaPackagePrefixes);
     }
 
     resolveJavaQualified(file, line, text, tok) {
@@ -1966,7 +2206,7 @@ class TypeReferenceResolver {
             return prefix === qualifier;
         });
         if (byFqnPrefix.length > 0) return this.judge(byFqnPrefix);
-        if (this.javaPackages().has(qualifier)) return { verdict: 'no', reason: 'other-package' };
+        if (this.javaPackageDeclared(qualifier)) return { verdict: 'no', reason: 'other-package' };
         const last = qualifier.split('.').pop();
         const nested = candidates.filter(d => d.enclosingType === last);
         if (nested.length > 0) {
@@ -1984,25 +2224,17 @@ class TypeReferenceResolver {
         return { verdict: 'unknown', reason: 'qualified-name' };
     }
 
-    csharpNamespaces() {
-        const key = 'cs-namespaces';
-        if (!this.memo.has(key)) {
-            const namespaces = new Set();
-            for (const entry of this.index.files.values()) {
-                if (entry.language !== 'csharp') continue;
-                for (const s of entry.symbols || []) {
-                    if (!s.namespace) continue;
-                    const parts = s.namespace.split('.');
-                    for (let i = 1; i <= parts.length; i++) namespaces.add(parts.slice(0, i).join('.'));
-                }
-            }
-            this.memo.set(key, namespaces);
-        }
-        return this.memo.get(key);
+    /** Does the project declare C# namespace `name` or one below it? */
+    csharpNamespaceDeclared(name) {
+        return projectHas(this.index, 'cs-namespace-prefixes', name, csharpNamespacePrefixes);
     }
 
     resolveCSharpQualified(file, line, text, tok) {
-        const entry = this.index.files.get(file);
+        // A constructed containing type has an arity at every owner
+        // segment. Erasing those arguments would merge Outer.Inner with
+        // Outer<T>.Inner. Until that owner chain is proven, keep the site
+        // visible without supplying a type-identity witness.
+        if (text.includes('<')) return { verdict: 'unknown', reason: 'generic-containing-type' };
         // An `extern alias` qualifier (`Old::Lib.Core.Widget`, fix #401)
         // names an assembly reference: a project namespace of that spelling
         // may or may not be the assembly's.
@@ -2014,26 +2246,39 @@ class TypeReferenceResolver {
             return spelled ? { verdict: 'unknown', reason: 'extern-alias' } : { verdict: 'no', reason: 'external-namespace' };
         }
         let qualifier = text.replace(/<.*?>/g, '').replace(/^global::/, '');
-        // A using alias names the qualifier's head.
+        // A using alias names the qualifier's head in this namespace body.
         const head = qualifier.split('.')[0];
-        const alias = (entry.importBindings || []).find(b => b.name === head && b.kind === 'using' && b.module);
-        if (alias) qualifier = [alias.module, ...qualifier.split('.').slice(1)].join('.');
-        const site = text.startsWith('global::') || alias ? '' : (this.csharpSiteNamespace(file, line) || '');
+        const { csharpUsings } = require('./type-denotation');
+        const namespace = this.csharpSiteNamespace(file, line);
+        if (namespace === undefined) return { verdict: 'unknown', reason: 'unknown-namespace' };
+        const scope = csharpUsings(this.index, file, namespace, this.siteNode);
+        const global = text.startsWith('global::');
         const chain = [];
-        for (let parts = site ? site.split('.') : []; parts.length > 0; parts = parts.slice(0, -1)) {
+        for (let parts = !global && namespace ? namespace.split('.') : []; parts.length > 0; parts = parts.slice(0, -1)) {
             chain.push(parts.join('.'));
         }
         chain.push('');
         const candidates = this.all.filter(d => d.name === this.name);
-        const namespaces = this.csharpNamespaces();
         for (const ns of chain) {
             const full = ns ? `${ns}.${qualifier}` : qualifier;
             const hits = candidates.filter(d => {
                 const prefix = `${d.namespace || ''}${d.enclosingType ? (d.namespace ? '.' : '') + d.enclosingType : ''}`;
                 return prefix === full;
             });
+            const alias = !global && scope.aliasScopes?.get(head) === ns && scope.aliases.get(head);
+            if (alias && (hits.length || scope.ambiguousAliases.has(head))) {
+                return { verdict: 'unknown', reason: 'ambiguous-type' };
+            }
             if (hits.length > 0) return this.judge(hits);
-            if (namespaces.has(full)) return { verdict: 'no', reason: 'other-namespace' };
+            if (this.csharpNamespaceDeclared(full)) return { verdict: 'no', reason: 'other-namespace' };
+            if (alias) {
+                if (scope.aliasSyntax.get(head)?.includes('<')) {
+                    return { verdict: 'unknown', reason: 'generic-alias-owner' };
+                }
+                const expanded = [alias, ...qualifier.split('.').slice(1)].join('.');
+                return this.resolveCSharpQualified(file, line, 'global::' + expanded, tok);
+            }
+            if (this.csharpNamespaceDeclared(ns ? `${ns}.${head}` : head)) return { verdict: 'no', reason: 'other-namespace' };
         }
         const last = qualifier.split('.').pop();
         if (candidates.some(d => d.enclosingType === last)) {
@@ -2198,8 +2443,7 @@ const PY_ANNOTATION_STOP = new Set(['block', 'module', 'class_definition', 'func
  * Decide every name token on the ground lines of a type rename.
  * @returns {{ files: Map<string, {relativePath, lines: Map<number, {edits: number[], reviews: Array<{column, reason}>, skips: number, text: boolean, tokens: number}>}> }}
  */
-function typeReferenceSites(index, def, name, groundSet) {
-    const resolver = new TypeReferenceResolver(index, def, name);
+function typeReferenceSites(index, def, name, groundSet, resolver = new TypeReferenceResolver(index, def, name)) {
     const files = new Map();
     const perFile = groundSet?.perFile || new Map();
     const sortedFiles = [...perFile.keys()].sort();
@@ -2246,6 +2490,8 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
     const name = resolver.name;
     let content;
     try { content = index._readFile(file); } catch { return null; }
+    const local = resolver.readLocalFile?.(file, entry, language, lineNumbers, content);
+    if (local) return local;
     let htmlView = null;
     if (language === 'html') {
         htmlView = htmlScriptView(content, name);
@@ -2254,7 +2500,8 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
     const parser = getParser(language);
     if (!parser) return null;
     const tree = htmlView ? safeParse(parser, htmlView.script)
-        : index._getParsedTree?.(file, content, language) || safeParse(parser, content);
+        : (resolver.valueReferences && require('./query-bodies').localQueryTree(index, file, entry, language, name, content)) ||
+            index._getParsedTree?.(file, content, language) || safeParse(parser, content);
     const lines = new Map();
     const lineOf = row => {
         let slot = lines.get(row + 1);
@@ -2299,15 +2546,20 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
         };
         for (const at of occurrences) {
             let node = root.descendantForIndex(at, at + name.length);
+            // An extra (a comment) inside an aliased rule can carry the
+            // alias as its type, depending on which traversal first wrapped
+            // the node (fix #420: `{ // x }` read as `interface_body` after a
+            // children walk, as `comment` otherwise): its grammar type is
+            // the stable one.
+            const type = node && (node.isExtra ? node.grammarType || node.type : node.type);
             // The smallest node holding the text: a token, a text or macro
             // leaf, or (between tokens) a container the walk would not read.
-            while (node && !TOKEN_TYPES.has(node.type) && !TEXT_NODE.test(node.type) &&
-                node.type !== 'preproc_arg' && !(node.type === 'ERROR' && node.namedChildCount === 0)) {
+            if (node && !TOKEN_TYPES.has(type) && !TEXT_NODE.test(type) &&
+                type !== 'preproc_arg' && !(type === 'ERROR' && node.namedChildCount === 0)) {
                 node = null;
             }
             if (!node || seen.has(node.id) || !overlaps(node)) continue;
             seen.add(node.id);
-            const type = node.type;
             if (TOKEN_TYPES.has(type)) {
                 const length = node.endIndex - node.startIndex;
                 if ((length === name.length || length === nameBytes) && node.text === name) found.push(node);
@@ -2321,9 +2573,10 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
             // code, read as tokens of their own).
             if (node.namedChildCount !== 0 && !type.includes('comment')) continue;
             mark(node, 'text');
-            if (resolver.family === 'csharp' && type === 'comment' && marks) docComments.push(node);
+            if (!resolver.valueReferences && resolver.family === 'csharp' && type === 'comment' && marks) docComments.push(node);
             if (resolver.family === 'python' && type === 'string_content' &&
-                (pythonTypeExpressionString(node, entry) || pythonDunderAllEntry(node, name))) found.push(node);
+                ((!resolver.valueReferences && pythonTypeExpressionString(node, entry)) ||
+                    pythonDunderAllEntry(node, name))) found.push(node);
         }
         return found;
     };
@@ -2336,8 +2589,14 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
     // a persisted blank reads through the recovered tree too.
     const persistedBlanks = resolver.family === 'c' && Array.isArray(entry.recoveryBlanks) &&
         entry.recoveryBlanks.length > 0 ? entry.recoveryBlanks : null;
+    // A decoration can make a record look like a clean function whose
+    // fields look like local declarations. Recover the pinned value's
+    // enclosing header too, using the same blanks the index verified.
+    const valueDeclarationHeader = resolver.valueReferences && persistedBlanks && resolver.def.file === file &&
+        tokens.some(node => node.startPosition.row + 1 === (resolver.def.nameLine || resolver.def.startLine) &&
+            enclosingHeaderHoldsBlank(node, persistedBlanks));
     if (resolver.family === 'c' && ((tree.rootNode.hasError && tokens.some(statementHasError)) ||
-        (persistedBlanks && tokens.some(node => statementHoldsBlank(node, persistedBlanks))))) {
+        (persistedBlanks && tokens.some(node => statementHoldsBlank(node, persistedBlanks))) || valueDeclarationHeader)) {
         // Only when the literal parse breaks around a token: the recovery
         // re-parses the file.
         let module;
@@ -2393,6 +2652,7 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
         .map(t => ({ node: t.node, scope: bindingScope(t.node, resolver.family, t.role), role: t.role }));
     const typeParams = classified.filter(t => t.role.role === 'skip' && t.role.typeParam)
         .map(t => ({ node: t.node, scope: typeParamScope(t.node) }));
+    let fileLocalOnly = true;
     for (const token of classified) {
         const row = token.node.startPosition.row;
         const slot = lineOf(row);
@@ -2404,24 +2664,97 @@ function scanFile(index, resolver, file, entry, language, lineNumbers) {
         resolver.siteNode = token.node;
         resolver.siteFile = file;
         // A position no rule decides is a review item, never an edit or a skip.
-        const decision = decide(resolver, file, entry, token, bindings, typeParams) ||
+        const decision = (resolver.decideToken
+            ? resolver.decideToken(file, entry, token, bindings, typeParams)
+            : decide(resolver, file, entry, token, bindings, typeParams)) ||
             { verdict: 'unknown', reason: 'unmodelled-position' };
+        if (!decision.fileLocalOnly) fileLocalOnly = false;
         resolver.siteNode = null;
         // An `__all__` entry is a code reference: once edited it is no
         // longer a text-only review item.
         if (token.role.role === 'dunder-all') slot.stringAnnotation = true;
-        if (decision.verdict === 'yes') slot.edits.push(token.node.startPosition.column);
+        // The impact band (fix #428) reads each token's syntactic role and
+        // why a token names something else; a rename reads only verdicts.
+        if (resolver.collectRoles) {
+            // A Python annotation is an expression in a type position.
+            const role = token.role.role === 'value' && resolver.family === 'python' &&
+                ancestor(token.node, PY_ANNOTATION, PY_ANNOTATION_STOP) ? 'type' : token.role.role;
+            (slot.roles ||= new Map()).set(token.node.startPosition.column, role);
+            if (constructionHead(token.node)) (slot.constructionColumns ||= []).push(token.node.startPosition.column);
+        }
+        if (decision.verdict === 'yes') {
+            slot.edits.push(token.node.startPosition.column);
+            // A binding renamed by aliasing its import (`import x as y`).
+            if (decision.importAlias) (slot.importAliases ||= []).push(token.node.startPosition.column);
+        }
         else if (decision.verdict === 'unknown') {
             slot.reviews.push({ column: token.node.startPosition.column, reason: decision.reason || 'unresolved' });
         } else {
-            slot.skips++;
-            slot.skipColumns.push(token.node.startPosition.column);
+            skipToken(resolver, slot, token.node.startPosition.column, decision.reason);
         }
     }
     for (const comment of docComments) decideDocCrefs(resolver, file, comment, lineOf(comment.startPosition.row));
+    if (resolver.family === 'c' && !resolver.valueReferences) decideReplacementListCasts(resolver, file, lines);
+    resolver.rememberLocalFile?.(file, lines, fileLocalOnly);
     return lines;
 }
 
+/** A token that names something else: counted, and why when asked. */
+function skipToken(resolver, slot, column, reason) {
+    slot.skips++;
+    slot.skipColumns.push(column);
+    if (resolver.collectRoles) (slot.skipReasons ||= new Map()).set(column, reason || 'other-declaration');
+}
+
+// Expressions whose head names the constructed type (fix #428): `S { .. }`
+// (Rust struct expressions) and `S(..)` (tuple structs, functional casts).
+const CONSTRUCTION_HEADS = new Map([
+    ['struct_expression', 'name'], ['call_expression', 'function'],
+]);
+const HEAD_WRAPPERS = new Set(['scoped_type_identifier', 'scoped_identifier', 'generic_type', 'generic_function']);
+
+/** Is this token the head of a construction expression? */
+function constructionHead(node) {
+    let current = node;
+    for (let depth = 0; depth < 4 && current.parent; depth++) {
+        const parent = current.parent;
+        const field = CONSTRUCTION_HEADS.get(parent.type);
+        if (field) return sameNode(parent.childForFieldName(field), current);
+        if (!HEAD_WRAPPERS.has(parent.type)) return false;
+        // A path's last segment names the type; a qualifier does not.
+        const name = parent.childForFieldName('name') || parent.childForFieldName('type');
+        if (name && !sameNode(name, current)) return false;
+        current = parent;
+    }
+    return false;
+}
+
+/**
+ * A cast spelled in a C/C++ replacement list (`#define D(t, p) t[(U16)(p)]`,
+ * fix #427): the name is the type its file's lookup finds where the macro is
+ * defined, so a line whose every occurrence of the name is such a cast to
+ * the renamed type is an edit; any other replacement-list text stays a
+ * review item.
+ */
+function decideReplacementListCasts(resolver, file, lines) {
+    const { getCachedCalls, _recordIsNoCall } = require('./callers');
+    let records = null;
+    const fileLines = resolver.index._getFileLines(file);
+    const word = new RegExp(`(?<![A-Za-z0-9_$])${resolver.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9_$])`, 'g');
+    for (const [line, slot] of lines) {
+        if (!slot.macroBody || slot.tokens > 0 || slot.reviews.length > 0) continue;
+        records ||= getCachedCalls(resolver.index, file) || [];
+        const casts = records.filter(call => call.line === line && call.name === resolver.name &&
+            call.parenthesizedCallee && call.inMacroBody && Number.isInteger(call.column));
+        if (casts.length === 0) continue;
+        const occurrences = (String(fileLines[line - 1] || '').match(word) || []).length;
+        if (occurrences !== casts.length || !casts.every(call => _recordIsNoCall(resolver.index, file, call))) continue;
+        if (resolver.resolveName(file, line)?.verdict !== 'yes') continue;
+        slot.tokens += casts.length;
+        slot.edits.push(...casts.map(call => call.column));
+    }
+}
+
 /**
  * C# XML documentation `cref` attributes are references the compiler
  * resolves (CS1574 when documentation is generated): each spelling of the
@@ -2463,20 +2796,20 @@ function decideDocCrefs(resolver, file, comment, slot) {
             handled = true;
             if (verdict.verdict === 'yes') slot.edits.push(column);
             else if (verdict.verdict === 'unknown') slot.reviews.push({ column, reason: 'doc-cref' });
-            else {
-                slot.skips++;
-                slot.skipColumns.push(column);
-            }
+            else skipToken(resolver, slot, column, verdict.reason);
+            if (resolver.collectRoles) (slot.roles ||= new Map()).set(column, 'doc-cref');
         }
     }
     if (handled) slot.stringAnnotation = true;
 }
 
-function shadowOf(token, bindings, space, family) {
+function shadowOf(token, bindings, space, family, pinScope = null) {
     let verdict = null;
     for (const binding of bindings) {
         if (sameNode(binding.node, token.node)) continue;
         if (!binding.scope || !contains(binding.scope, token.node)) continue;
+        // Another binding of the pinned class's own variable (fix #424).
+        if (pinScope && sameNode(binding.scope, pinScope)) continue;
         // Type positions are a separate namespace outside Python/JS values.
         if (space === 'type' && family !== 'python') continue;
         if (binding.role.patternBinding) return 'unknown';
@@ -2517,20 +2850,6 @@ function statementHasError(node) {
     return false;
 }
 
-/** The class path a qualified declarator's scope names, without its
- * leading namespace-looking segments: `ns::List<K>::Node::f` -> the scope
- * segments `List<K>::Node` (the last two at most). */
-function qualifiedScopeText(qualified) {
-    const scopes = [];
-    let current = qualified;
-    while (current?.type === 'qualified_identifier') {
-        const scope = current.childForFieldName('scope');
-        if (scope) scopes.push(textOf(scope));
-        current = current.childForFieldName('name');
-    }
-    return scopes.length > 0 ? scopes.slice(-2).join('::') : null;
-}
-
 /** Does a persisted recovery blank fall inside the declaration or
  * statement holding this token? (`blanks`: sorted [start, end] ranges) */
 function statementHoldsBlank(node, blanks) {
@@ -2539,8 +2858,19 @@ function statementHoldsBlank(node, blanks) {
         if (/(declaration|definition|statement)$/.test(current.type)) { statement = current; break; }
     }
     if (!statement) return false;
-    const start = statement.startIndex;
-    const end = statement.endIndex;
+    return rangeHoldsBlank(statement.startIndex, statement.endIndex, blanks);
+}
+
+function enclosingHeaderHoldsBlank(node, blanks) {
+    for (let owner = node.parent; owner; owner = owner.parent) {
+        const body = owner.childForFieldName('body');
+        if (body && body.startIndex <= node.startIndex &&
+            rangeHoldsBlank(owner.startIndex, body.startIndex, blanks)) return true;
+    }
+    return false;
+}
+
+function rangeHoldsBlank(start, end, blanks) {
     let lo = 0;
     let hi = blanks.length;
     while (lo < hi) {
@@ -2589,7 +2919,7 @@ function macroArgumentOtherUse(resolver, file, node) {
         : (list.namedChildren || []).filter(child => !child.type.endsWith('comment'));
     const index = args.findIndex(arg => sameNode(arg, argument));
     if (index < 0 || argument.text !== node.text) return null;
-    const { includeClosure } = require('./cpp-scope');
+    const { includeClosure } = lazyCppScopeModule();
     const visible = includeClosure(resolver.index, file);
     const macros = (resolver.index.symbols.get(callee.text) || []).filter(d => d.type === 'macro' &&
         d.functionLike && (d.file === file || visible.has(d.file)));
@@ -2661,12 +2991,17 @@ function decide(resolver, file, entry, token, bindings, typeParams) {
             // the class its qualifier spells.
             const spelled = cppPrefix(node);
             if (spelled == null) return { verdict: 'unknown', reason: 'constructor-owner' };
-            const segments = spelled.split('::');
-            // `Sink<Mutex>::Sink(...)`: template arguments are not part of
-            // the class name the constructor repeats (fix #387).
-            const last = require('./cpp-scope').stripTemplateArguments(segments.pop()).trim();
-            if (last !== resolver.name) return { verdict: 'no', reason: 'other-type' };
-            return resolver.resolveCFamily(file, line, last, segments.length > 0 ? segments.join('::') : null);
+            const { resolveQualifier, includeClosure } = lazyCppScopeModule();
+            const site = resolver.cppSiteContext(file, line);
+            // The qualifier may be an alias of the declaring class. Resolve
+            // its type identity, rather than renaming the alias declaration.
+            const owner = resolveQualifier(resolver.index, { file, line,
+                namespace: site.namespace, className: site.className }, spelled,
+            includeClosure(resolver.index, file));
+            if (owner.kind !== 'type') return { verdict: 'unknown', reason: 'constructor-owner' };
+            const verdict = resolver.judge(owner.classes);
+            return verdict.verdict === 'yes' && !owner.visible
+                ? { verdict: 'unknown', reason: 'not-in-include-closure' } : verdict;
         }
         case 'meminit': {
             // A member named like the type is initialized as a member.
@@ -2677,6 +3012,20 @@ function decide(resolver, file, entry, token, bindings, typeParams) {
             return resolveUnqualifiedToken(resolver, file, token, bindings, typeParams, 'type');
         }
         case 'import': return decideImport(resolver, file, entry, token);
+        case 'qualified-creation': {
+            // Only a member class is created through an outer instance.
+            const members = resolver.all.filter(d => d.name === resolver.name && d.enclosingType);
+            if (members.length === 0) return { verdict: 'no', reason: 'not-member-type' };
+            const outerType = javaExpressionTypeName(role.outer);
+            const owner = outerType ? resolver.resolveTypeNamed(file, line, outerType) : 'unknown';
+            if (owner === 'owner') return { verdict: 'yes' };
+            // Another outer type may inherit the member class; only one that
+            // declares its own member class of the name settles it.
+            if (owner === 'other' && members.some(d => !resolver.inGroup(d) && d.enclosingType === outerType)) {
+                return { verdict: 'no', reason: 'other-type' };
+            }
+            return { verdict: 'unknown', reason: 'qualified-creation' };
+        }
         case 'member':
             return decideMember(resolver, file, token, bindings);
         case 'gofield':
@@ -2689,7 +3038,8 @@ function decide(resolver, file, entry, token, bindings, typeParams) {
                 if (prefix) return resolver.resolveCFamily(file, line, resolver.name, prefix);
             }
             if (role.qualifier) {
-                return resolver.resolveQualified(file, line, role.qualifier, null, { role: role.role });
+                return resolver.resolveQualified(file, line, role.qualifier,
+                    role.aliasQualified ? textOf(role.qualifier) + '::' : null, { role: role.role });
             }
             if (role.aliasQualified) return { verdict: 'unknown', reason: 'extern-alias' };
             if (role.elaborated && family === 'c') {
@@ -2733,8 +3083,10 @@ function memberShadowOf(resolver, file, node) {
     // members of the enclosing classes first: a method of that name (C#
     // `static LogEvent LogEvent(..)`, a C++ member function) hides the
     // type there (fix #393). A constructor is the class's own name.
-    const invokedAt = node.parent && ((node.parent.type === 'invocation_expression' ||
-        node.parent.type === 'call_expression') && isField(node, 'function'));
+    const invokedName = langTraits(resolver.index.files.get(file)?.language)?.isInvokedName;
+    const invokedAt = invokedName ? invokedName(node, { unqualified: true }) : node.parent &&
+        ((node.parent.type === 'invocation_expression' || node.parent.type === 'call_expression') &&
+            isField(node, 'function'));
     if (invokedAt) {
         const scopeNames = new Set(owners);
         let level = [...owners];
@@ -2765,7 +3117,8 @@ function memberShadowOf(resolver, file, node) {
 function resolveUnqualifiedToken(resolver, file, token, bindings, typeParams, space) {
     const family = resolver.family;
     if (space === 'value' || family === 'python' || family === 'js') {
-        const shadow = shadowOf(token, bindings, space, family);
+        const shadow = shadowOf(token, bindings, space, family,
+            file === resolver.def.file ? resolver.pythonPinScope(token.node.tree) : null);
         if (shadow === 'no') return { verdict: 'no', reason: 'local-binding' };
         if (shadow === 'unknown') return { verdict: 'unknown', reason: 'local-binding' };
         if (shadow === 'module') {
@@ -2778,6 +3131,16 @@ function resolveUnqualifiedToken(resolver, file, token, bindings, typeParams, sp
             return { verdict: 'unknown', reason: 'module-rebinding' };
         }
     }
+    // C and C++ name lookup finds a variable or parameter declared before
+    // the name in an enclosing block before any type (C: one ordinary
+    // namespace; C++: the variable hides the class or alias): `ctx(out,
+    // vargs)` after `auto& vargs = ..` passes the variable (fix #427).
+    if (space === 'type' && family === 'c' && bindings.some(binding =>
+        ['variable', 'parameter'].includes(binding.role.why) && !sameNode(binding.node, token.node) &&
+        binding.scope && binding.scope.type !== 'translation_unit' && contains(binding.scope, token.node) &&
+        binding.node.startIndex < token.node.startIndex)) {
+        return { verdict: 'no', reason: 'local-binding' };
+    }
     if (space === 'value') {
         const member = memberShadowOf(resolver, file, token.node);
         if (member) return member;
@@ -2808,6 +3171,9 @@ function declVerdict(resolver, file, declNode, role = {}, nameLine = null) {
     // annotated or decorated declarations) is matched there first.
     const named = nameLine != null ? resolver.fileTypes(file).filter(d => d.nameLine === nameLine && kindOk(d)) : [];
     if (named.length > 0) return resolver.judge(named);
+    const exact = resolver.fileTypes(file).filter(d => d.nameLine == null && kindOk(d) &&
+        d.startLine === startLine && d.endLine === endLine);
+    if (exact.length > 0) return resolver.judge(exact);
     const defs = resolver.fileTypes(file).filter(d => d.nameLine == null && (d.endLine === endLine ||
         (d.startLine <= startLine + 1 && d.startLine >= startLine - 3 &&
             d.endLine >= endLine - 1 && d.endLine <= endLine + 1)) &&
@@ -3160,10 +3526,8 @@ function decideStringAnnotation(resolver, file, entry, node, slot) {
         const column = node.startPosition.column + offset;
         if (verdict.verdict === 'yes') slot.edits.push(column);
         else if (verdict.verdict === 'unknown') slot.reviews.push({ column, reason: verdict.reason || 'string-annotation' });
-        else {
-            slot.skips++;
-            slot.skipColumns.push(column);
-        }
+        else skipToken(resolver, slot, column, verdict.reason);
+        if (resolver.collectRoles) (slot.roles ||= new Map()).set(column, 'string-annotation');
     }
     slot.stringAnnotation = true;
 }
@@ -3220,9 +3584,14 @@ function csharpAttributeShortSites(index, def, name) {
 }
 
 module.exports = {
+    cppSiteContextOf,
     csharpAttributeShortSites,
     TYPE_RENAME_KINDS,
     isTypeRenamePin,
+    referenceRole: classify,
+    referenceBindingScope: (node, language, role) => bindingScope(node, familyOf(language), role),
+    referenceTypeParameterScope: typeParamScope,
+    referenceImportVerdict: decideImport,
     typeReferenceSites,
     TypeReferenceResolver,
     familyOf,