ucn 5.5.0 → 5.5.2

package/languages/c-family.js

@@ -15,6 +15,7 @@ const {
     traverseTree,
     nodeTextWithoutComments,
     traverseTreeCached,
+    getCachedNodeList,
     nodeToLocation,
     extractJSDocstring,
     visitNameNodes,
@@ -403,6 +404,18 @@ const MAX_TYPE_EVIDENCE_OCCURRENCES = 512;
 const definitionReadingMemo = new Map(); // grammar + replacement list -> reading (fix #387)
 const IDENTIFIER_TEXT = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
+/**
+ * A replacement list without the object-like macro names `isDecoration`
+ * accepts (names that expand to declaration specifiers or nothing), as
+ * preprocessing tokens joined by spaces (fix #427).
+ */
+function withoutDecorationMacros(body, isDecoration) {
+    const tokens = lexPP(String(body || ''));
+    if (!tokens.some(token => token.k === 'id' && isDecoration(token.v))) return body;
+    return tokens.filter((token, i) => !(token.k === 'id' && tokens[i + 1]?.v !== '(' && isDecoration(token.v)))
+        .map(token => token.v).join(' ');
+}
+
 /**
  * Per-file evidence for decoration decisions, gathered lazily from the
  * file's own tree and directives: names proven types by an occurrence, names
@@ -445,6 +458,9 @@ class DecorationEvidence {
             }
         }
         if (this.defines.has(name)) return this.defines.get(name);
+        // A definition that names itself (or one that names it) reads as
+        // no reading while it is being read.
+        this.defines.set(name, null);
         const bodies = [];
         const code = this.code;
         // A name the file does not define reads by the project's definitions
@@ -470,6 +486,14 @@ class DecorationEvidence {
             }
             bodies.push(body.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, ' '));
         }
+        // Object-like macros a body names that themselves read as
+        // decoration expand to specifiers or nothing: the body reads as the
+        // rest of it (fix #427: `#define API __declspec(dllexport) VIS` with
+        // `#define VIS __attribute__((visibility("default")))` or empty).
+        const reduced = bodies.map(body => withoutDecorationMacros(body, word => word !== name &&
+            (this.defineEnds.has(word) || externalMacroContext?.objectBodies?.has(word)) &&
+            this.defined(word) === 'decoration'));
+        bodies.splice(0, bodies.length, ...reduced);
         const readings = new Set(bodies.map(body => this.readBody(body)));
         let reading = readings.size === 1 ? [...readings][0] : null;
         // A statement macro defined empty in some configuration
@@ -503,11 +527,24 @@ class DecorationEvidence {
     }
 
     probeBody(text) {
-        if (/^catch\b/.test(text)) {
-            const tree = safeParse(this.parser, `void __ucn_probe__() { try { } ${text} }`, undefined, PARSE_OPTIONS);
+        const statementProbe = source => {
+            const tree = safeParse(this.parser, source, undefined, PARSE_OPTIONS);
             const clean = !!tree && !tree.rootNode.hasError;
             tree?.delete?.();
-            return clean ? 'statement' : null;
+            return clean;
+        };
+        if (/^catch\b/.test(text)) {
+            // A complete handler, or (fix #427) a handler head the block
+            // after the invocation completes (`catch(...)`).
+            return statementProbe(`void __ucn_probe__() { try { } ${text} }`) ||
+                statementProbe(`void __ucn_probe__() { try { } ${text} { } }`) ? 'statement' : null;
+        }
+        // A conditional head with its condition (`if(true)`, `if(false)`):
+        // removed, the block after it stays a statement (fix #427: one
+        // configuration's `try`/`catch(...)` is another's `if(true)` /
+        // `if(false)`).
+        if (/^(?:if|while|for|switch)\s*\(/.test(text)) {
+            return statementProbe(`void __ucn_probe__() { ${text} { } }`) ? 'statement' : null;
         }
         const probe = source => {
             const tree = safeParse(this.parser, source, undefined, PARSE_OPTIONS);
@@ -997,6 +1034,14 @@ function dependentTypeInBodyError(node) {
     return false;
 }
 
+/** `Class::*` with no declarator name after the `*` (the grammar's MISSING name). */
+function memberPointerAbstractDeclarator(node) {
+    const name = node.childForFieldName('name');
+    if (name?.type !== 'pointer_type_declarator') return false;
+    const declarator = name.childForFieldName('declarator');
+    return !!declarator?.isMissing && name.namedChildCount === 1;
+}
+
 function macroTypeRanges(tree, code, evidence = null) {
     const ranges = [];
     const pairs = [];
@@ -1043,6 +1088,15 @@ function macroTypeRanges(tree, code, evidence = null) {
         return true;
     };
     traverseTree(tree.rootNode, node => {
+        // An abstract pointer-to-member declarator (`Ret (Class::*)(Args...)`,
+        // `Type Class::*`) has no reading in the grammar, which then misreads
+        // the whole declaration (fix #427). Read with `*` in place of
+        // `Class::*`, it is the pointer declarator of the same shape; the
+        // parameter keeps its written type (structuredParams).
+        if (treeHasError && node.type === 'qualified_identifier' && memberPointerAbstractDeclarator(node)) {
+            ranges.push([node.startIndex, node.endIndex, '*'.padStart(node.endIndex - node.startIndex, ' ')]);
+            return false;
+        }
         ranges.push(...errorMacroRanges(node, code, pairs, evidence));
         const statementMacro = statementMacroRange(node, code, evidence);
         if (statementMacro) ranges.push(statementMacro);
@@ -1575,6 +1629,12 @@ function preprocessorDirective(line) {
  */
 const CONDITIONAL_RECOVERY_MAX_BYTES = 256 * 1024;
 
+// Keep every branch's tokens while removing only conditional directives.
+// Consumers must still parse the combined tokens to establish their meaning.
+function conditionalHeaderText(code) {
+    return code.split(/(?<=\n)/).map(line => preprocessorDirective(line) ? blankLine(line) : line).join('');
+}
+
 function conditionalRecoverySources(code) {
     if (Buffer.byteLength(code) > CONDITIONAL_RECOVERY_MAX_BYTES) return [];
     const lines = code.match(/.*(?:\r\n|\n|\r|$)/g)?.filter(Boolean) || [];
@@ -1675,6 +1735,22 @@ function conditionalRecoverySources(code) {
         const source = selected.join('');
         if (!sources.includes(source)) sources.push(source);
     }
+    // Every alternative head of one construct at once (fix #430).
+    const directiveRows = [];
+    const directiveEnd = new Map();
+    for (let row = 0; row < lines.length; row++) {
+        if (!directives[row]) continue;
+        let end = row;
+        while (end + 1 < lines.length && /\\[ \t]*\r?\n?$/.test(lines[end])) end++;
+        directiveEnd.set(row, end);
+        directiveRows.push({ row, kind: directives[row].kind });
+    }
+    const closures = alternativeBranchClosures(lines, directiveRows, directiveEnd);
+    if (closures) {
+        const source = lines.map((line, row) => closures.replace.has(row) ? closures.replace.get(row)
+            : closures.rows.has(row) ? blankLine(line) : line).join('');
+        if (!sources.includes(source)) sources.push(source);
+    }
     return sources;
 }
 
@@ -1683,6 +1759,77 @@ const DIRECTIVE_TOKEN_TYPES = new Set([
     '#if', '#ifdef', '#ifndef', '#elif', '#elifdef', '#elifndef', '#else', '#endif',
 ]);
 
+/**
+ * The `{` minus `}` count of the program tokens on rows [from, to): directive
+ * lines (a `#define` replacement list, with its continuation lines) are not
+ * program tokens, nor are braces in comments and literals.
+ */
+function programBraceBalance(lines, from, to) {
+    const kept = [];
+    for (let row = from; row < to; row++) {
+        if (/^\s*#/.test(lines[row])) {
+            while (row + 1 < to && /\\[ \t]*\r?\n?$/.test(lines[row])) row++;
+            continue;
+        }
+        kept.push(lines[row]);
+    }
+    const text = kept.join('');
+    let balance = 0;
+    for (let index = 0; index < text.length; index++) {
+        const skipped = skipLexicalRegion(text, index);
+        if (skipped != null) {
+            index = skipped - 1;
+            continue;
+        }
+        if (text[index] === '{') balance++;
+        else if (text[index] === '}') balance--;
+    }
+    return balance;
+}
+
+/**
+ * Alternative heads of one construct (fix #430): a conditional whose every
+ * branch opens the same number k of braces the code after it closes
+ * (`#if X  T f() {  #else  T f() {  #endif ... }`, entt `type_hash::value`).
+ * Each branch is read as its own construct, closed by k braces written into
+ * the directive line that ends it (the `#elif`/`#else` line, blank in every
+ * configuration), so every alternative is a declaration; directive lines are
+ * blanked and every other byte and row kept. Returns { rows, replace } for
+ * the groups of `directives` (`{ row, kind }` in order, `directiveEnd` maps a
+ * row to its last continuation row) that qualify, or null.
+ */
+function alternativeBranchClosures(lines, directives, directiveEnd) {
+    const rows = new Set();
+    const replace = new Map();
+    const stack = [];
+    for (const directive of directives) {
+        if (directive.kind === 'if' || directive.kind === 'ifdef' || directive.kind === 'ifndef') {
+            stack.push({ branches: [directive.row] });
+        } else if (directive.kind === 'elif' || directive.kind === 'else') {
+            stack[stack.length - 1]?.branches.push(directive.row);
+        } else if (directive.kind === 'endif') {
+            const group = stack.pop();
+            if (!group) return null;
+            if (group.branches.length < 2) continue;
+            const edges = [...group.branches, directive.row];
+            const balances = group.branches.map((row, b) => programBraceBalance(lines, row + 1, edges[b + 1]));
+            const k = balances[0];
+            if (!(k > 0) || balances.some(balance => balance !== k)) continue;
+            const closers = group.branches.slice(1);
+            if (closers.some(row => directiveEnd.get(row) !== row ||
+                lines[row].replace(/[\r\n]+$/, '').length < k)) continue;
+            for (const row of edges) {
+                for (let line = row; line <= directiveEnd.get(row); line++) rows.add(line);
+            }
+            for (const row of closers) {
+                const blank = blankLine(lines[row]);
+                replace.set(row, '}'.repeat(k) + blank.slice(k));
+            }
+        }
+    }
+    return rows.size > 0 ? { rows, replace } : null;
+}
+
 /**
  * fix #391: the source with the preprocessor conditionals the grammar could
  * not place resolved, or null. tree-sitter models a conditional as a node
@@ -1697,7 +1844,7 @@ const DIRECTIVE_TOKEN_TYPES = new Set([
  * number. Only the conditionals the grammar could not place change; every
  * other line reads as before.
  */
-function misplacedDirectiveRepair(tree, source) {
+function misplacedDirectiveRepair(tree, source, info = null) {
     const misplaced = new Set();
     const visit = node => {
         const error = node.type === 'ERROR';
@@ -1712,30 +1859,7 @@ function misplacedDirectiveRepair(tree, source) {
     // conditionals (`#ifdef X else { #endif ... #ifdef X } #endif`, fix
     // #393): the grammar reads it as a block that swallows the declarations
     // after it, with no ERROR near the directives.
-    const braceBalance = (from, to) => {
-        // Program tokens only: directive lines (a `#define` replacement
-        // list, with its continuation lines) are not.
-        const kept = [];
-        for (let row = from; row < to; row++) {
-            if (/^\s*#/.test(lines[row])) {
-                while (row + 1 < to && /\\[ \t]*\r?\n?$/.test(lines[row])) row++;
-                continue;
-            }
-            kept.push(lines[row]);
-        }
-        const text = kept.join('');
-        let balance = 0;
-        for (let index = 0; index < text.length; index++) {
-            const skipped = skipLexicalRegion(text, index);
-            if (skipped != null) {
-                index = skipped - 1;
-                continue;
-            }
-            if (text[index] === '{') balance++;
-            else if (text[index] === '}') balance--;
-        }
-        return balance;
-    };
+    const braceBalance = (from, to) => programBraceBalance(lines, from, to);
     // Directive line spans (a directive continues over backslash-newlines).
     const directiveEnd = new Map();
     const directives = [];
@@ -1748,6 +1872,8 @@ function misplacedDirectiveRepair(tree, source) {
         directives.push({ row, kind: directive.kind });
     }
     const blank = new Set();
+    // Groups of alternative heads keep every branch, each closed in place.
+    const closures = alternativeBranchClosures(lines, directives, directiveEnd);
     const stack = [];
     for (const directive of directives) {
         if (directive.kind === 'if' || directive.kind === 'ifdef' || directive.kind === 'ifndef') {
@@ -1758,6 +1884,7 @@ function misplacedDirectiveRepair(tree, source) {
             const group = stack.pop();
             if (!group) return null;
             const rows = [...group.branches, directive.row];
+            if (closures?.rows.has(directive.row)) continue;
             if (!rows.some(row => misplaced.has(row))) {
                 const edges = [...group.branches, directive.row];
                 let split = false;
@@ -1792,8 +1919,10 @@ function misplacedDirectiveRepair(tree, source) {
             }
         }
     }
-    if (stack.length > 0 || blank.size === 0) return null;
-    return lines.map((line, row) => (blank.has(row) ? blankLine(line) : line)).join('');
+    if (stack.length > 0 || (blank.size === 0 && !closures)) return null;
+    if (info && closures) info.closedAlternatives = true;
+    return lines.map((line, row) => closures?.replace.has(row) ? closures.replace.get(row)
+        : blank.has(row) || closures?.rows.has(row) ? blankLine(line) : line).join('');
 }
 
 const STRUCTURE_SCORE_TYPES = [
@@ -1928,8 +2057,9 @@ const KNOWN_MACRO_ROUNDS = 3;
  * statements again), so a few rounds run. Returns { source, tree,
  * invocations }; `blank` stays set only on invocations the source blanks.
  */
-function knownMacroInvocationRecovery(parser, source) {
+function knownMacroInvocationRecovery(parser, source, rawCapture = null) {
     let tree = safeParse(parser, source, undefined, PARSE_OPTIONS);
+    if (rawCapture?.source === source) rawCapture.tree = tree;
     const own = directiveFunctionMacros(source);
     // The project's attribute and return-type macros matter only where the
     // grammar failed (fix #396).
@@ -1961,7 +2091,7 @@ function knownMacroInvocationRecovery(parser, source) {
             for (const invocation of blanks) kept.set(invocation.start, { ...invocation, blank: null });
             break;
         }
-        tree.delete?.();
+        if (tree !== rawCapture?.tree) tree.delete?.();
         tree = candidate;
         current = blanked;
     }
@@ -1991,7 +2121,7 @@ function withExternalFunctionMacros(macros) {
     return { defs, undefs: merged.undefs };
 }
 
-function parseTree(parser, code) {
+function parseTree(parser, code, rawCapture = null) {
     const cacheKey = treeCacheKey(code);
     const cached = cachedCFamilyTree(parser, cacheKey);
     if (cached) return cached;
@@ -2016,7 +2146,7 @@ function parseTree(parser, code) {
     // Invocations of the file's own function-like macros that the grammar
     // read as declarations are the preprocessor's view before any other
     // recovery (fix #385).
-    const known = knownMacroInvocationRecovery(parser, pinnedSource);
+    const known = knownMacroInvocationRecovery(parser, pinnedSource, rawCapture);
     const source = known.source;
     const tree = known.tree;
     const knownSource = source !== pinnedSource ? source : null;
@@ -2064,7 +2194,7 @@ function parseTree(parser, code) {
     const releaseTree = candidate => {
         if (!candidate || !liveTrees.has(candidate)) return;
         liveTrees.delete(candidate);
-        candidate.delete?.();
+        if (candidate !== rawCapture?.tree) candidate.delete?.();
     };
     // Misreads a damage hid (fix #396): once a configuration or a directive
     // repair restores the structure around them, the decoration rules and
@@ -2221,7 +2351,8 @@ function parseTree(parser, code) {
         // round over the repaired tree, which exposes misreads the damage hid.
         if (!conditionalApplied && !(repairFolded && best) &&
             (largeSource || attributeSelected.rootNode.hasError)) {
-            const repairedSource = misplacedDirectiveRepair(attributeSelected, attributeSource);
+            const repairInfo = {};
+            const repairedSource = misplacedDirectiveRepair(attributeSelected, attributeSource, repairInfo);
             if (repairedSource) {
                 let candidate = safeParse(parser, repairedSource, undefined, PARSE_OPTIONS);
                 liveTrees.add(candidate);
@@ -2236,7 +2367,12 @@ function parseTree(parser, code) {
                         candidateErrors = round.errors;
                     }
                 }
-                if (candidateErrors < selectedErrors) {
+                // A repair that reads alternative heads (fix #430) is also
+                // kept at an equal error count when it recovers structure,
+                // as the configuration sweep prefers the richest view.
+                if (candidateErrors < selectedErrors || repairInfo.closedAlternatives &&
+                    candidateErrors === selectedErrors &&
+                    treeStructureScore(candidate) > treeStructureScore(attributeSelected)) {
                     best = candidate;
                     bestCode = candidateSource;
                 } else {
@@ -2502,6 +2638,15 @@ function withoutShadowedFreeFunctions(secondary, primaryClasses) {
     });
 }
 
+/** Whether a declarator names a qualified entity (`H<T>::x`, `*Foo::p`). */
+function qualifiedDeclarator(node) {
+    for (let current = node, depth = 0; current && depth < 16; depth++) {
+        if (current.type === 'qualified_identifier') return true;
+        current = current.childForFieldName('declarator');
+    }
+    return false;
+}
+
 function unwrapDeclarator(node) {
     let current = node;
     const seen = new Set();
@@ -2539,6 +2684,9 @@ function functionDeclarator(node) {
     }
     const direct = node.childForFieldName('declarator');
     if (direct?.type === 'operator_cast') return direct;
+    // An out-of-class conversion operator (`T::operator int() const {..}`,
+    // fix #427): the qualified name holds the operator_cast.
+    if (direct?.type === 'qualified_identifier' && qualifiedOperatorCast(direct)) return direct;
     const unwrapped = unwrapDeclarator(direct);
     if (unwrapped) return unwrapped;
     for (const child of node.namedChildren || []) {
@@ -2549,6 +2697,39 @@ function functionDeclarator(node) {
     return null;
 }
 
+/**
+ * A C++17 deduction guide (`template<class T> W(T) -> W<T>;`, `explicit
+ * W(const char*) -> W<int>;`): a declaration with no type whose function
+ * declarator names a class template and whose trailing return type is a
+ * template-id of that same template ([temp.deduct.guide]). It declares no
+ * function; its name token names the class template (fix #427). Returns the
+ * name node, or null.
+ */
+function deductionGuideOf(node) {
+    if (!node || !['declaration', 'field_declaration', 'ERROR'].includes(node.type)) return null;
+    if (node.childForFieldName?.('type')) return null;
+    const declarator = node.type === 'ERROR'
+        ? (node.namedChildren || []).find(child => child.type === 'function_declarator')
+        : node.childForFieldName('declarator');
+    if (declarator?.type !== 'function_declarator') return null;
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode || !['identifier', 'type_identifier', 'field_identifier'].includes(nameNode.type)) return null;
+    const trailing = (declarator.namedChildren || []).find(child => child.type === 'trailing_return_type');
+    let type = trailing?.namedChildren.find(child => child.type === 'type_descriptor')?.childForFieldName('type');
+    while (type?.type === 'qualified_identifier') type = type.childForFieldName('name');
+    if (type?.type !== 'template_type') return null;
+    return type.childForFieldName('name')?.text === nameNode.text ? nameNode : null;
+}
+
+/** The operator_cast a qualified name ends in (`A::B::operator int`), or null. */
+function qualifiedOperatorCast(node) {
+    let current = node;
+    while (current?.type === 'qualified_identifier') {
+        current = current.childForFieldName('name') || current.namedChildren[current.namedChildCount - 1];
+    }
+    return current?.type === 'operator_cast' ? current : null;
+}
+
 function canonicalCallableName(raw) {
     const text = String(raw || '').trim();
     if (!text.startsWith('operator')) return text;
@@ -2626,6 +2807,27 @@ function declaratorIdentity(declarator) {
         const scopeNode = scopes[scopes.length - 1];
         const qualifier = scopes.slice(0, -1).map(scope => scope.text.replace(/\s+/g, ''))
             .filter(Boolean).join('::');
+        if (nameNode?.type === 'operator_cast') {
+            // `Text::operator Text::bool_type()` converts to the member type
+            // the class body spells `bool_type` (fix #427): the owner's own
+            // qualification is not part of the in-class name.
+            const cast = declaratorIdentity(nameNode);
+            if (!cast.name) return {};
+            const owner = [...scopes.map(scope => scope.text.replace(/\s+/g, ''))].join('::');
+            let name = cast.name;
+            for (const prefix of [owner, scopeNode?.text?.replace(/\s+/g, '')].filter(Boolean)) {
+                if (name.startsWith(`operator ${prefix}::`)) {
+                    name = `operator ${name.slice(`operator ${prefix}::`.length)}`;
+                    break;
+                }
+            }
+            return {
+                ...cast,
+                name,
+                className: scopeNode?.text?.split('::').pop(),
+                ...(qualifier && { ownerQualifier: qualifier }),
+            };
+        }
         return {
             name: canonicalCallableName(nameNode?.text),
             className: scopeNode?.text?.split('::').pop(),
@@ -3161,9 +3363,31 @@ function paramTypeText(param, identity) {
     return typeText || null;
 }
 
-function structuredParams(paramsNode) {
+/**
+ * The written text of a node the recovery read with `*` in place of an
+ * abstract pointer-to-member declarator's `Class::*` (fix #427), or null.
+ */
+function writtenMemberPointerText(node, lines) {
+    if (!node || !lines) return null;
+    const start = node.startPosition;
+    const end = node.endPosition;
+    if (start.row !== end.row) return null;
+    const written = lines[start.row]?.slice(start.column, end.column);
+    return written && written !== node.text && /::\s*\*/.test(written)
+        ? written.replace(/\s+/g, ' ').trim() : null;
+}
+
+function paramsDisplayText(paramsNode, lines) {
+    const text = writtenMemberPointerText(paramsNode, lines) || nodeTextWithoutComments(paramsNode);
+    return text.replace(/^\(|\)$/g, '').trim();
+}
+
+function structuredParams(paramsNode, lines = null) {
     if (!paramsNode) return [];
     const result = [];
+    // A parameter the recovery read as a pointer declarator in place of an
+    // abstract pointer-to-member one keeps its written type (fix #427).
+    const writtenMemberPointer = param => writtenMemberPointerText(param, lines);
     for (const param of paramsNode.namedChildren || []) {
         if (param.type !== 'parameter_declaration' &&
             param.type !== 'optional_parameter_declaration' &&
@@ -3196,6 +3420,8 @@ function structuredParams(paramsNode) {
                 info.unnamed = true;
             }
         }
+        const memberPointer = writtenMemberPointer(param);
+        if (memberPointer && info.unnamed) info.name = memberPointer;
         if (param.type === 'optional_parameter_declaration') info.optional = true;
         let declaratorCursor = declarator;
         let variadicDeclarator = false;
@@ -3387,25 +3613,47 @@ function templatedDeclaration(node) {
     return current || node;
 }
 
+/**
+ * The cv- and ref-qualifiers of a member function's implicit object
+ * parameter (`int f() const &`, fix #427): { memberConst, refQualifier }.
+ */
+function memberQualifiers(declarator) {
+    let holder = declarator;
+    if (holder?.type === 'qualified_identifier') holder = qualifiedOperatorCast(holder);
+    if (holder?.type === 'operator_cast') {
+        holder = holder.childForFieldName('declarator') ||
+            (holder.namedChildren || []).find(child => child.type === 'abstract_function_declarator');
+    }
+    if (!holder) return {};
+    const out = {};
+    for (const child of holder.namedChildren || []) {
+        if (child.type === 'type_qualifier' && child.text === 'const') out.memberConst = true;
+        if (child.type === 'ref_qualifier') out.refQualifier = child.text.replace(/\s+/g, '');
+    }
+    return out;
+}
+
 function memberFromNode(node, className, access, lines, mode) {
     const declarator = functionDeclarator(node);
     if (!declarator) return null;
     const identity = declaratorIdentity(declarator);
     if (!identity.name) return null;
     const paramsNode = parameterListOf(declarator);
-    const { startLine, endLine, indent } = nodeToLocation(node, lines);
+    const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
+    const ownerName = enclosingClass(node)?.name || className;
     const isConstructor = mode === 'cpp' &&
-        (identity.name === className || identity.name === `~${className}`);
+        (identity.name === ownerName || identity.name === `~${ownerName}`);
     const modifiers = modifiersOf(node, access ? [access] : []);
     if (isConstructor && identity.name.startsWith('~')) modifiers.push('destructor');
     return {
         name: identity.name,
-        params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
-        paramsStructured: structuredParams(paramsNode),
+        params: paramsNode ? paramsDisplayText(paramsNode, lines) : '...',
+        paramsStructured: structuredParams(paramsNode, lines),
         returnType: isConstructor ? null :
             (identity.conversionType || returnTypeOf(templatedDeclaration(node))),
         startLine,
         endLine,
+        sourceSpan,
         ...(identity.nameNode?.startPosition.row + 1 !== startLine && {
             nameLine: identity.nameNode.startPosition.row + 1,
         }),
@@ -3414,6 +3662,7 @@ function memberFromNode(node, className, access, lines, mode) {
         memberType: isConstructor ? 'constructor' : 'method',
         isMethod: true,
         isConstructor,
+        ...(mode === 'cpp' && memberQualifiers(declarator)),
         ...(enclosingNamespace(node) && {
             namespace: enclosingNamespace(node),
         }),
@@ -3442,30 +3691,83 @@ function memberFromNode(node, className, access, lines, mode) {
     };
 }
 
-function fieldMembers(node, access, lines) {
+function fieldMembers(node, access, lines, paths = null) {
     if (node.type !== 'field_declaration') return [];
     if (functionDeclarator(node)) return [];
     const typeNode = node.childForFieldName('type') ||
         node.namedChildren.find(child => TYPE_NODES.has(child.type));
     const fields = [];
-    for (const child of node.namedChildren || []) {
-        if (!IDENTIFIER_NODES.has(child.type) && child.type !== 'field_declarator') continue;
+    const declarators = node.childrenForFieldName('declarator');
+    // Members of an unnamed struct or union (fix #430): without a declarator
+    // (an anonymous member) they are members of the enclosing class; with
+    // declarators they are reached through them (`e.data.start`), recorded
+    // as the member paths from the enclosing class.
+    const nestedBody = (typeNode?.type === 'struct_specifier' || typeNode?.type === 'union_specifier') &&
+        !typeNode.childForFieldName('name') ? typeNode.childForFieldName('body') : null;
+    if (nestedBody) {
+        const declaredNames = declarators.map(child => declaratorIdentity(child).name).filter(Boolean);
+        const nestedPaths = declaredNames.length === 0 ? paths
+            : (paths || [[]]).flatMap(path => declaredNames.map(name => [...path, name]));
+        for (const entry of memberListEntries(nestedBody)) {
+            if (entry.type === 'field_declaration') fields.push(...fieldMembers(entry, access, lines, nestedPaths));
+        }
+    }
+    for (const child of declarators) {
         const identity = declaratorIdentity(child);
         if (!identity.name || identity.name === typeNode?.text) continue;
-        const { startLine, endLine, indent } = nodeToLocation(child, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
+        // Pointer declarators of the field (`State* m_raw`): `->` on it
+        // dereferences the pointer, on an object it calls operator-> (fix #427).
+        let pointers = 0;
+        let arrays = false;
+        for (let current = child; current && !IDENTIFIER_NODES.has(current.type);) {
+            if (current.type === 'pointer_declarator') pointers++;
+            if (current.type === 'array_declarator' || current.type === 'function_declarator') arrays = true;
+            current = current.childForFieldName('declarator') ||
+                (current.namedChildren || []).find(next => next.type.endsWith('_declarator'));
+        }
         fields.push({
             name: identity.name,
             startLine,
             endLine,
+            sourceSpan,
             indent,
             modifiers: access ? [access] : [],
             memberType: 'field',
-            fieldType: typeNode?.text || null,
+            fieldType: nestedBody ? null : typeNode?.text || null,
+            ...(!arrays && { fieldPointers: pointers }),
+            ...(paths?.length && { memberPaths: paths.map(path => [...path]) }),
         });
     }
     return fields;
 }
 
+/** The data members a member variable template declares (fix #430:
+ * `template <class> static constexpr bool value = true;`). */
+function variableTemplateMembers(node, access, lines) {
+    const declaration = (node.namedChildren || []).find(child => child.type === 'declaration');
+    if (!declaration || functionDeclarator(declaration)) return [];
+    const typeNode = declaration.childForFieldName('type');
+    const members = [];
+    for (const child of declaration.childrenForFieldName('declarator')) {
+        const identity = declaratorIdentity(child);
+        if (!identity.name) continue;
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
+        members.push({
+            name: identity.name,
+            startLine,
+            endLine,
+            sourceSpan,
+            indent,
+            modifiers: modifiersOf(declaration, access ? [access] : []),
+            memberType: 'field',
+            fieldType: typeNode?.text || null,
+            ...(templateParameterNames(declaration) && { templateParams: templateParameterNames(declaration) }),
+        });
+    }
+    return members;
+}
+
 /**
  * Member-list entries in document order, with preprocessor conditionals
  * opened (fix #385): `#ifdef _WIN32 bool f() {...} #else bool f() {...}
@@ -3603,11 +3905,12 @@ function classMembers(node, lines, mode) {
                 (child.namedChildren || []).find(candidate =>
                     candidate.type === 'identifier');
             if (nameNode?.text) {
-                const { startLine, endLine, indent } = nodeToLocation(nameNode, lines);
+                const { startLine, endLine, indent, sourceSpan } = nodeToLocation(nameNode, lines);
                 members.push({
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     indent,
                     modifiers: ['public'],
                     memberType: 'field',
@@ -3634,7 +3937,9 @@ function classMembers(node, lines, mode) {
         const member = macroName ? null : memberFromNode(
             child, identity.ownerName || identity.name, effectiveAccess, lines, mode);
         if (member) members.push(member);
-        else if (!macroName) members.push(...fieldMembers(child, effectiveAccess, lines));
+        else if (!macroName && child.type === 'template_declaration') {
+            members.push(...variableTemplateMembers(child, effectiveAccess, lines));
+        } else if (!macroName) members.push(...fieldMembers(child, effectiveAccess, lines));
         if (unknownAccess) {
             for (let i = before; i < members.length; i++) {
                 members[i].accessAfterMacro = { ...unknownAccess };
@@ -3750,7 +4055,7 @@ function typedefEntries(node, lines) {
         const identity = declaratorIdentity(child);
         if (!identity.name || RESERVED_TYPE_KEYWORDS.has(identity.name)) continue;
         if (innerIsClass && (!innerClassName || innerClassName === identity.name)) continue;
-        const { startLine, endLine, indent } = nodeToLocation(child, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
         // A function-pointer typedef aliases a function shape, not the return
         // type — record no aliasOf for it.
         const aliasOf = unwrapDeclarator(child)
@@ -3761,6 +4066,7 @@ function typedefEntries(node, lines) {
             type: 'type',
             startLine,
             endLine,
+            sourceSpan,
             ...(identity.nameNode?.startPosition.row + 1 !== startLine && {
                 nameLine: identity.nameNode.startPosition.row + 1,
             }),
@@ -3778,6 +4084,18 @@ function typedefEntries(node, lines) {
     return entries;
 }
 
+function classNamespaceScope(node, named) {
+    const parts = [];
+    let anonymous = false;
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent.type !== 'namespace_definition') continue;
+        const name = parent.childForFieldName('name');
+        if (name) parts.unshift(name.text);
+        else { parts.unshift('<anonymous>'); anonymous = true; }
+    }
+    return { anonymous, key: anonymous ? `${parts.join('::')}\0${named || ''}` : named || '' };
+}
+
 function findClassesInTree(code, tree, mode, sourceLines = null) {
     const lines = sourceLines || code.split('\n');
     const classes = [];
@@ -3786,7 +4104,7 @@ function findClassesInTree(code, tree, mode, sourceLines = null) {
     // the same name (forward declarations, `struct S` in a parameter or
     // field type position) are references to it, never second definitions.
     const bodiedNames = new Set();
-    const bodylessEntries = new Set();
+    const bodylessEntries = new Map();
     const forwardDeclared = new Set();
     traverseTreeCached(tree.rootNode, node => {
         if (mode === 'cpp' && node.type === 'alias_declaration') {
@@ -3800,13 +4118,14 @@ function findClassesInTree(code, tree, mode, sourceLines = null) {
                     (child.type === 'type_descriptor' ||
                      TYPE_NODES.has(child.type)));
             if (!nameNode?.text) return false;
-            const { startLine, endLine, indent } =
+            const { startLine, endLine, indent, sourceSpan } =
                 nodeToLocation(node, lines);
             classes.push({
                 name: nameNode.text,
                 type: 'type',
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers: ['public'],
                 members: [],
@@ -3827,24 +4146,43 @@ function findClassesInTree(code, tree, mode, sourceLines = null) {
         const identity = classIdentity(node);
         if (!identity?.name) return true;
         const hasBody = !!node.childForFieldName('body');
+        if (!hasBody) {
+            let container = node.parent;
+            while (container && (PP_CONDITIONAL_TYPES.has(container.type) ||
+                container.type === 'template_declaration')) container = container.parent;
+            if (!['translation_unit', 'declaration_list'].includes(container?.type)) return true;
+        }
+        const outer = identity.enclosingType ? null : mode === 'cpp' ? enclosingClass(node) : null;
+        const enclosingType = identity.enclosingType || outer?.name || null;
+        const namespace = identity.ownerQualifier
+            ? [enclosingNamespace(node), identity.ownerQualifier].filter(Boolean).join('::')
+            : enclosingNamespace(node);
+        const namespaceScope = classNamespaceScope(node, namespace);
+        const localScope = functionLocalClassScope(node);
+        const generics = mode === 'cpp' ? templateParameterNames(node) : null;
+        const branch = conditionalBranchLines(node);
+        const tag = node.type === 'union_specifier' || node.type === 'enum_specifier'
+            ? node.type : 'record';
+        const scopeKey = `${namespaceScope.key}\0${enclosingType || ''}\0${identity.ownerName}` +
+            `\0${generics?.length || 0}\0${tag}\0${localScope.lexicalScopeStartLine || 0}`;
         if (hasBody) {
-            bodiedNames.add(identity.name);
+            // A same-scope declaration denotes this class even when its
+            // body is conditional. Keep every alternative body, without an
+            // extra incomplete class competing with its own definition.
+            bodiedNames.add(scopeKey);
         } else {
-            if (bodiedNames.has(identity.name)) return true;
+            if (bodiedNames.has(scopeKey)) return true;
             // A bodyless specifier is only a DECLARATION at declaration
             // level (`struct S;`); in a type position (`void f(struct S *)`)
             // it is a reference. One entry per opaque forward-declared name.
-            const parentType = node.parent?.type;
-            if (parentType !== 'translation_unit' && parentType !== 'declaration_list') return true;
-            if (forwardDeclared.has(identity.name)) return true;
-            forwardDeclared.add(identity.name);
+            if (forwardDeclared.has(scopeKey)) return true;
+            forwardDeclared.add(scopeKey);
         }
         const key = `${node.startIndex}:${identity.name}`;
         if (seen.has(key)) return false;
         seen.add(key);
-        const { startLine, endLine, indent } = nodeToLocation(node, lines);
-        let type = node.type.replace('_specifier', '');
-        if (type === 'union') type = 'type';
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
+        const type = node.type.replace('_specifier', '');
         const baseClause = node.namedChildren.find(child => child.type === 'base_class_clause');
         const bases = baseClause
             ? baseClause.namedChildren
@@ -3858,19 +4196,18 @@ function findClassesInTree(code, tree, mode, sourceLines = null) {
         // A nested class names its enclosing class (fix #396): lexically
         // (`class A { struct B { .. }; }`) or by its qualified definition
         // (`struct A::B { .. }`, whose outer scopes qualify its namespace).
-        const outer = identity.enclosingType ? null : mode === 'cpp' ? enclosingClass(node) : null;
-        const enclosingType = identity.enclosingType || outer?.name || null;
-        const namespace = identity.ownerQualifier
-            ? [enclosingNamespace(node), identity.ownerQualifier].filter(Boolean).join('::')
-            : enclosingNamespace(node);
         const entry = {
             name: identity.name,
             ...(identity.ownerName !== identity.name && {
                 specialization: identity.ownerName,
             }),
             type,
+            ...(!hasBody && { forwardDeclaration: true }),
+            ...(namespaceScope.anonymous && { anonymousNamespace: true }),
+            ...(branch && { ppBranch: branch }),
             startLine,
             endLine,
+            sourceSpan,
             ...(identity.nameNode?.startPosition.row + 1 !== startLine && {
                 nameLine: identity.nameNode.startPosition.row + 1,
             }),
@@ -3881,21 +4218,21 @@ function findClassesInTree(code, tree, mode, sourceLines = null) {
             ...(namespace && { namespace }),
             ...(enclosingType && { enclosingType }),
             ...(bases.length > 0 && { extends: bases.join(', ') }),
-            ...(mode === 'cpp' && templateParameterNames(node) && {
-                generics: templateParameterNames(node),
+            ...(generics && {
+                generics,
             }),
-            ...functionLocalClassScope(node),
+            ...localScope,
             docstring: extractJSDocstring(lines, startLine),
         };
         classes.push(entry);
-        if (!hasBody) bodylessEntries.add(entry);
+        if (!hasBody) bodylessEntries.set(entry, scopeKey);
         return true;
     });
     // A forward declaration can precede its body. Filtering after the single
     // traversal preserves the old "body wins" result without paying a full
     // preliminary tree walk merely to discover future bodied names.
     return classes.filter(entry =>
-        !bodylessEntries.has(entry) || !bodiedNames.has(entry.name));
+        !bodylessEntries.has(entry) || !bodiedNames.has(bodylessEntries.get(entry)));
 }
 
 function findClasses(code, parser, mode) {
@@ -3914,6 +4251,7 @@ function findClasses(code, parser, mode) {
 
 function findFunctionsInTree(code, tree, mode, sourceLines = null) {
     const lines = sourceLines || code.split('\n');
+    let constructorDecorations = null;
     const lineStarts = [0];
     for (let index = 0; index < code.length; index++) {
         if (code.charCodeAt(index) === 10) lineStarts.push(index + 1);
@@ -3931,7 +4269,16 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
         }
         if (!FUNCTION_CONTAINERS.has(node.type)) return true;
         const declarator = functionDeclarator(node);
-        if (!declarator) return true;
+        if (!declarator) {
+            // `M(name) { .. }` read as a definition with no function
+            // declarator (C, fix #427).
+            const generated = node.type === 'function_definition' ? generatedCallableOf(node, lines) : null;
+            if (generated) {
+                functions.push(generated);
+                return false;
+            }
+            return true;
+        }
         // A macro invocation read as a function is not one (fix #385); an
         // invocation with a body at namespace scope defines the callable
         // the expansion declares around that body (fix #391).
@@ -3943,6 +4290,8 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
         const owner = enclosingClass(node);
         const identity = declaratorIdentity(declarator);
         if (!identity.name) return true;
+        // A deduction guide declares no function (fix #427).
+        if (mode === 'cpp' && deductionGuideOf(node)) return false;
         // A name joined by `##` is replacement-list text of a macro the
         // grammar could not read as a directive, never a declared function
         // (fix #387).
@@ -3961,9 +4310,13 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
         const location = nodeToLocation(node, lines);
         const startLine = location.startLine;
         const indent = location.indent;
-        const ownerName = identity.className && identity.className.replace(/<.*>$/s, '');
+        const declaredType = templatedDeclaration(node).childForFieldName('type');
+        const decorationType = mode === 'cpp' && identity.className &&
+            !identity.name.startsWith('operator') && declaredType?.type === 'type_identifier' &&
+            (constructorDecorations ||= new DecorationEvidence(require('./index').getParser(mode), code, tree))
+                .defined(declaredType.text) === 'decoration';
         const isConstructor = mode === 'cpp' && !!identity.className &&
-            (identity.name === ownerName || identity.name === `~${ownerName}`);
+            !identity.name.startsWith('operator') && (!declaredType || decorationType);
         const namespace = [enclosingNamespace(node), identity.className && identity.ownerQualifier]
             .filter(Boolean).join('::');
         const lexicalEnd = functionRangeEnd(
@@ -3972,6 +4325,7 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
             ? location.endLine
             : lineNumberAtIndex(lineStarts, Math.max(0, lexicalEnd - 1));
         const modifiers = modifiersOf(node);
+        if (isConstructor && identity.name.startsWith('~')) modifiers.push('destructor');
         if (friendOf && !modifiers.includes('friend')) modifiers.unshift('friend');
         if (!modifiers.includes('static')) modifiers.push('export');
         const returnedConcreteType = mode === 'cpp' && variableTypes
@@ -3979,8 +4333,10 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
             : null;
         functions.push({
             name: identity.name,
-            params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
-            paramsStructured: structuredParams(paramsNode),
+            sourceSpan: lexicalEnd == null ? location.sourceSpan : { ...location.sourceSpan,
+                end: lexicalEnd, endLine, endColumn: lexicalEnd - lineStarts[endLine - 1] },
+            params: paramsNode ? paramsDisplayText(paramsNode, lines) : '...',
+            paramsStructured: structuredParams(paramsNode, lines),
             returnType: isConstructor ? null :
                 (identity.conversionType || returnTypeOf(node)),
             startLine,
@@ -3996,6 +4352,7 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
                 receiver: identity.className,
                 isMethod: true,
             }),
+            ...(mode === 'cpp' && identity.className && memberQualifiers(declarator)),
             ...(friendOf && { friendOf: friendOf.ownerName || friendOf.name }),
             ...(mode === 'cpp' && isTemplateDependentCallable(node) && {
                 templateDependent: true,
@@ -4119,6 +4476,22 @@ function findFunctions(code, parser, mode) {
 
 function findStateObjectsInTree(tree, lines) {
     const states = [];
+    // An unnamed enum without a typedef owner declares values directly
+    // in its enclosing scope. A typedef's members already carry them.
+    traverseTreeCached(tree.rootNode, node => {
+        if (node.type !== 'enum_specifier' || classIdentity(node)) return true;
+        const body = node.childForFieldName('body');
+        for (const member of body?.namedChildren || []) {
+            if (member.type !== 'enumerator') continue;
+            const name = member.childForFieldName('name');
+            if (!name) continue;
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(name, lines);
+            const namespace = enclosingNamespace(node);
+            states.push({ name: name.text, startLine, endLine, sourceSpan, indent,
+                ...(namespace && { namespace }) });
+        }
+        return true;
+    });
     traverseTreeCached(tree.rootNode, node => {
         if (node.type !== 'declaration') return true;
         if (functionDeclarator(node)) return false;
@@ -4127,18 +4500,29 @@ function findStateObjectsInTree(tree, lines) {
         // an #if/#else remain part of the source inventory even though only
         // one arm can exist in any particular build configuration.
         let scope = node.parent;
-        while (scope && /^preproc_/.test(scope.type)) scope = scope.parent;
+        // A variable template's `template <..>` head is transparent too
+        // (fix #430: `template <class T> inline constexpr bool v = ..;`);
+        // a qualified declarator under it defines a class template's static
+        // member (`template <class T> bool H<T>::x = false;`), no variable.
+        let templated = false;
+        while (scope && (/^preproc_/.test(scope.type) || scope.type === 'template_declaration')) {
+            if (scope.type === 'template_declaration') templated = true;
+            scope = scope.parent;
+        }
         if (scope?.type !== 'translation_unit' && scope?.type !== 'declaration_list') return false;
         for (const child of node.namedChildren || []) {
             const identity = declaratorIdentity(child);
             if (!identity.name || TYPE_NODES.has(child.type)) continue;
-            const { startLine, endLine, indent } = nodeToLocation(child, lines);
+            if (templated && qualifiedDeclarator(child)) continue;
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
             states.push({
                 name: identity.name,
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers: modifiersOf(node),
+                ...(enclosingNamespace(node) && { namespace: enclosingNamespace(node) }),
             });
         }
         return false;
@@ -4400,8 +4784,10 @@ function findCppUsingFacts(tree) {
             if (parent.type === 'namespace_definition' ||
                 parent.type === 'translation_unit') break;
         }
+        const groups = conditionalGroupsOf(node);
         const location = {
             line: node.startPosition.row + 1,
+            ...(groups.length > 0 && { ppGroups: groups }),
             ...(enclosingNamespace(node) && { namespace: enclosingNamespace(node) }),
             ...(block && {
                 scopeStartLine: block.startPosition.row + 1,
@@ -4441,6 +4827,29 @@ const PP_CONDITIONAL_TYPES = new Set([
     'preproc_if', 'preproc_ifdef', 'preproc_elif', 'preproc_elifdef', 'preproc_else',
 ]);
 
+/** Original preprocessor groups containing a declaration (fix #413). */
+function conditionalGroupsOf(node) {
+    const groups = [];
+    const seen = new Set();
+    for (let up = node.parent; up; up = up.parent) {
+        if (!PP_CONDITIONAL_TYPES.has(up.type)) continue;
+        let head = up;
+        while (head.parent && PP_CONDITIONAL_TYPES.has(head.parent.type) &&
+            sameNode(head.parent.childForFieldName('alternative'), head)) head = head.parent;
+        if (seen.has(head.startIndex) || isIncludeGuard(head)) continue;
+        seen.add(head.startIndex);
+        const branches = [];
+        for (let arm = head; arm; arm = arm.childForFieldName('alternative')) {
+            const next = arm.childForFieldName('alternative');
+            branches.push([arm.startPosition.row + 1,
+                next ? next.startPosition.row : arm.endPosition.row + 1]);
+        }
+        groups.push({ start: head.startPosition.row + 1,
+            end: head.endPosition.row + 1, branches });
+    }
+    return groups;
+}
+
 /** `#ifndef G` whose first directive is `#define G` and that has no else. */
 function isIncludeGuard(node) {
     if (node.type !== 'preproc_ifdef' || node.child(0)?.type !== '#ifndef') return false;
@@ -4824,7 +5233,22 @@ function generatedCallableOf(node, lines) {
     let macroNode;
     let argsNode;
     let body;
-    if (node.type === 'function_definition') {
+    if (node.type === 'function_definition' &&
+        node.childForFieldName('declarator')?.type === 'parenthesized_declarator') {
+        // C reads `M(name) { .. }` as a definition of `name` returning the
+        // type `M` (fix #427); a function definition needs a function
+        // declarator, so the shape is an invocation with a body.
+        const declarator = node.childForFieldName('declarator');
+        const typeNode = node.childForFieldName('type');
+        body = node.childForFieldName('body');
+        if (body?.type !== 'compound_statement' || typeNode?.type !== 'type_identifier' ||
+            declarator.namedChildCount !== 1 || declarator.namedChild(0).type !== 'identifier' ||
+            (node.namedChildren || []).some(child => child.type === 'storage_class_specifier' ||
+                child.type === 'type_qualifier')) return null;
+        macroNode = { type: 'identifier', text: typeNode.text };
+        argsNode = declarator;
+        head = node;
+    } else if (node.type === 'function_definition') {
         const declarator = node.childForFieldName('declarator');
         body = node.childForFieldName('body');
         if (body?.type !== 'compound_statement' || declarator?.type !== 'function_declarator') return null;
@@ -4882,20 +5306,100 @@ function generatedCallableOf(node, lines) {
     const startLine = head.startPosition.row + 1;
     const endLine = body.endPosition.row + 1;
     const namespace = enclosingNamespace(head);
+    // The function the expansion declares, when the project defines the
+    // macro (fix #427): the file's own definition in effect, else the
+    // headers' function-head macros.
+    let templates = definition ? [definition] : null;
+    if (!templates && externalMacroContext?.functionHeads?.has(macroName)) {
+        templates = externalMacroContext.functionHeads.get(macroName);
+        externalMacroContext.consulted?.add(macroName);
+    }
+    const expanded = templates && expandedFunctionHead(templates, argsNode.text, isCppTree(node.tree));
     return {
-        name,
-        params: '...',
-        returnType: null,
+        name: expanded?.name || name,
+        params: expanded?.params ?? '...',
+        ...(expanded && { paramsStructured: expanded.paramsStructured }),
+        returnType: expanded?.returnType || null,
         startLine,
         endLine,
         indent: head.startPosition.column,
-        modifiers: [],
+        modifiers: expanded?.modifiers || [],
         ...(namespace && { namespace }),
-        generatedByMacro: { name: macroName, ...(names.length > 0 && { args: names }) },
+        generatedByMacro: { name: macroName, ...(names.length > 0 && { args: names }),
+            ...(expanded && { expanded: true }) },
         docstring: extractJSDocstring(lines, startLine),
     };
 }
 
+/**
+ * The function a function-like macro invocation's expansion declares (fix
+ * #427): the replacement list with the invocation's arguments substituted
+ * (`#` stringizes, `##` pastes), read as a function head. Its name,
+ * parameters, return type and storage class, when every definition gives
+ * one unqualified function; null otherwise (a nested macro, a member, a
+ * head the grammar cannot read).
+ */
+function expandedFunctionHead(templates, argsText, cpp) {
+    const args = splitInvocationArguments(argsText).map(arg => arg.trim());
+    let result = null;
+    for (const template of templates) {
+        const params = template.params || [];
+        const variadicIndex = params.indexOf('__VA_ARGS__');
+        if (variadicIndex < 0 ? args.length !== params.length && !(params.length === 0 && args.length === 1 && !args[0])
+            : args.length < variadicIndex) return null;
+        const valueOf = param => {
+            const at = params.indexOf(param);
+            if (at < 0) return null;
+            return at === variadicIndex ? args.slice(at).join(', ') : (args[at] ?? '');
+        };
+        const tokens = lexPP(String(template.body || ''));
+        const out = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.v === '#' && tokens[i + 1]?.k === 'id' && valueOf(tokens[i + 1].v) != null) {
+                out.push(JSON.stringify(valueOf(tokens[i + 1].v)));
+                i++;
+                continue;
+            }
+            if (token.v === '##') {
+                const right = tokens[i + 1];
+                if (!right || out.length === 0) return null;
+                const value = right.k === 'id' && valueOf(right.v) != null ? valueOf(right.v) : right.v;
+                out[out.length - 1] = `${out[out.length - 1]}${value}`;
+                i++;
+                continue;
+            }
+            out.push(token.k === 'id' && valueOf(token.v) != null ? valueOf(token.v) : token.v);
+        }
+        const text = out.join(' ');
+        const parser = require('./index').getParser(cpp ? 'cpp' : 'c');
+        const tree = parser && safeParse(parser, `${text} { }`, undefined, PARSE_OPTIONS);
+        try {
+            const definition = tree && !tree.rootNode.hasError && tree.rootNode.namedChildCount === 1
+                ? tree.rootNode.namedChild(0) : null;
+            if (definition?.type !== 'function_definition') return null;
+            const declarator = functionDeclarator(definition);
+            const identity = declarator && declaratorIdentity(declarator);
+            if (!identity?.name || identity.className || !/^[A-Za-z_]\w*$/.test(identity.name)) return null;
+            const paramsNode = parameterListOf(declarator);
+            const modifiers = modifiersOf(definition);
+            if (!modifiers.includes('static')) modifiers.push('export');
+            const head = {
+                name: identity.name,
+                params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '',
+                paramsStructured: structuredParams(paramsNode),
+                returnType: returnTypeOf(definition),
+                modifiers,
+            };
+            if (result && (result.name !== head.name || result.params !== head.params)) return null;
+            result = head;
+        } finally {
+            tree?.delete?.();
+        }
+    }
+    return result;
+}
+
 function macroInvocationDeclaration(node) {
     if (!FUNCTION_CONTAINERS.has(node.type) || node.childForFieldName('type')) return false;
     const declarator = node.childForFieldName('declarator');
@@ -5081,6 +5585,8 @@ function buildVariableTypes(tree) {
     const memberReceiverUses = [];
     const ambiguousDirectInitializers = [];
     const autoElementInitializers = [];
+    const autoCopyInitializers = [];
+    const decltypeDeclarations = [];
     const declaratorStaticType = (type, declarator, holder) => {
         // The declaration's type node carries only the base type. Preserve
         // array rank from the AST declarator for overload arguments:
@@ -5096,7 +5602,10 @@ function buildVariableTypes(tree) {
             if (current.type === 'array_declarator') arrays++;
             for (const child of current.namedChildren || []) stack.push(child);
         }
-        if (arrays > 0) return `${type}${'[]'.repeat(arrays)}`;
+        const qualifiers = (holder?.children || []).filter(child => child.type === 'type_qualifier')
+            .map(child => child.text).join(' ');
+        const qualified = qualifiers ? `${qualifiers} ${type}` : type;
+        if (arrays > 0) return `${qualified}${'[]'.repeat(arrays)}`;
         // Pointer levels are part of the argument's type (fix #393):
         // `const char* format` passes a C string, never a `char`. The chain
         // of declarators is followed (an initializer's own declarators are
@@ -5105,7 +5614,7 @@ function buildVariableTypes(tree) {
         // decides overloads (`f(char*)` versus `f(const char*)`).
         let pointers = 0;
         for (let current = declarator; current;) {
-            if (current.type === 'function_declarator') return type;
+            if (current.type === 'function_declarator') return qualified;
             if (current.type === 'pointer_declarator') pointers++;
             current = current.type === 'init_declarator' || current.type === 'pointer_declarator' ||
                 current.type === 'reference_declarator' || current.type === 'parenthesized_declarator'
@@ -5114,12 +5623,18 @@ function buildVariableTypes(tree) {
                         child.type.endsWith('declarator') || child.type === 'identifier'))
                 : null;
         }
-        if (pointers === 0) return type;
-        const pointeeConst = (holder?.children || []).some(child =>
-            child.type === 'type_qualifier' && child.text === 'const');
-        return `${pointeeConst ? 'const ' : ''}${type} ${'*'.repeat(pointers)}`;
+        if (pointers === 0) return qualified;
+        return `${qualified} ${'*'.repeat(pointers)}`;
     };
-    const addBindings = (node, type, pointeeType, scope, declarators, containerElementType, typeNamespace) => {
+    const addBindings = (node, type, pointeeType, scope, declarators, containerElementType, typeNamespace,
+        constKnown = true) => {
+        const writtenType = node.childForFieldName('type');
+        const staticBase = writtenType && typeName(writtenType) === type ? writtenType.text : type;
+        // The decl-specifier `const` qualifies the object a value or
+        // reference names, or what a pointer points at (fix #427).
+        const declConst = constKnown
+            ? (node.children || []).some(child => child.type === 'type_qualifier' && child.text === 'const')
+            : undefined;
         for (const declarator of declarators) {
             const identity = declaratorIdentity(declarator);
             if (!identity.name) continue;
@@ -5146,13 +5661,15 @@ function buildVariableTypes(tree) {
                 ...(elementType && { elementType }),
                 name: identity.name,
                 type,
-                staticType: declaratorStaticType(type, declarator, node),
+                staticType: declaratorStaticType(staticBase, declarator, node),
+                staticOrigin: writtenType && typeName(writtenType) === type ? argumentTypeContext(writtenType) : null,
                 origin: typeOrigin(node.type === 'declaration' &&
                     (declarator.type === 'identifier' ||
                      declarator.childForFieldName('value')?.type === 'new_expression')
                     ? 'constructor' : 'annotation', declarator),
                 ...(pointeeType && { pointeeType }),
                 ...(pointers === 0 && arrays === 0 && { valueDeclarator: true }),
+                ...(declConst !== undefined && arrays === 0 && pointers <= 1 && { declConst, pointers }),
                 ...(typeNamespace?.name === type && { typeNamespace: typeNamespace.namespace }),
                 declaredAt: node.type === 'parameter_declaration'
                     ? scope.startIndex : declarator.startIndex,
@@ -5190,6 +5707,19 @@ function buildVariableTypes(tree) {
         }
         const typeNode = node.childForFieldName('type') ||
             (node.namedChildren || []).find(child => TYPE_NODES.has(child.type));
+        // `decltype(x) v` declares v with x's declared type; any other
+        // decltype (`decltype(auto)`, an expression) leaves v untyped, never
+        // a type named by the decltype's text (fix #427).
+        if (typeNode?.type === 'decltype' || (typeNode?.type === 'placeholder_type_specifier' &&
+            (typeNode.namedChildren || []).some(child => child.type === 'decltype'))) {
+            const operand = typeNode.type === 'decltype' && typeNode.namedChildCount === 1
+                ? typeNode.namedChild(0) : null;
+            if (operand?.type === 'identifier') {
+                decltypeDeclarations.push({ node, operand, scope: variableBindingScope(node),
+                    declarators: variableDeclarators(node) });
+            }
+            return true;
+        }
         const type = typeName(typeNode);
         if (type === 'auto') {
             // `auto &c = items[i]` binds the declared element (fix #359);
@@ -5203,6 +5733,20 @@ function buildVariableTypes(tree) {
                     autoElementInitializers.push({
                         node, declarator, root, scope: variableBindingScope(node),
                     });
+                    continue;
+                }
+                // `auto x = b`, `auto &r = b`, `auto *p = &b` deduce b's type
+                // (fix #434): an object copied, referenced, or pointed at by
+                // the declarator's own pointer. A pointer source keeps its
+                // value untyped (the declarator would read as an object).
+                const declared = declarator.childForFieldName('declarator');
+                const pointerDeclarator = declared?.type === 'pointer_declarator';
+                const source = pointerDeclarator
+                    ? (value?.type === 'pointer_expression' && value.children.some(child => child.type === '&')
+                        ? value.childForFieldName('argument') : null)
+                    : value;
+                if (source?.type === 'identifier') {
+                    autoCopyInitializers.push({ node, declarator, source, scope: variableBindingScope(node) });
                 }
             }
             return true;
@@ -5295,6 +5839,40 @@ function buildVariableTypes(tree) {
                 [candidate.declarator]);
         }
     }
+    // In source order, each sees the bindings before it (fix #434).
+    autoCopyInitializers.sort((a, b) => a.node.startIndex - b.node.startIndex);
+    for (const candidate of autoCopyInitializers) {
+        const at = candidate.source.startIndex;
+        const sources = bindings.filter(binding =>
+            binding.name === candidate.source.text &&
+            binding.scopeStart <= at && at < binding.scopeEnd &&
+            binding.declaredAt <= at);
+        sources.sort((a, b) => (a.scopeEnd - a.scopeStart) - (b.scopeEnd - b.scopeStart) ||
+            b.declaredAt - a.declaredAt);
+        const source = sources[0];
+        if (source?.type && source.valueDeclarator && !source.pointeeType) {
+            addBindings(candidate.node, source.type, undefined, candidate.scope, [candidate.declarator],
+                undefined, undefined, false);
+        }
+    }
+    // In source order: `decltype(copy) c2` sees the binding `copy` got.
+    decltypeDeclarations.sort((a, b) => a.node.startIndex - b.node.startIndex);
+    for (const candidate of decltypeDeclarations) {
+        const at = candidate.operand.startIndex;
+        const operands = bindings.filter(binding =>
+            binding.name === candidate.operand.text &&
+            binding.scopeStart <= at && at < binding.scopeEnd &&
+            binding.declaredAt <= at);
+        operands.sort((a, b) => (a.scopeEnd - a.scopeStart) - (b.scopeEnd - b.scopeStart) ||
+            b.declaredAt - a.declaredAt);
+        const operand = operands[0];
+        // An object (not a pointer) of a named type: the declared variable
+        // has its type.
+        if (operand?.type && operand.valueDeclarator && !operand.pointeeType) {
+            addBindings(candidate.node, operand.type, undefined, candidate.scope, candidate.declarators,
+                undefined, undefined, false);
+        }
+    }
     // Bindings are complete before call extraction. Partition by spelling
     // once: every argument and receiver lookup otherwise scans all locals
     // in the translation unit, including unrelated functions.
@@ -5318,6 +5896,7 @@ function buildVariableTypes(tree) {
     return {
         get: (name, atNode) => resolveBinding(name, atNode)?.type,
         getStatic: (name, atNode) => resolveBinding(name, atNode)?.staticType,
+        getStaticOrigin: (name, atNode) => resolveBinding(name, atNode)?.staticOrigin,
         evidence: (name, atNode) => {
             const binding = resolveBinding(name, atNode);
             return { receiverTypeSource: binding?.origin?.source || 'unknown',
@@ -5327,6 +5906,14 @@ function buildVariableTypes(tree) {
         },
         getPointee: (name, atNode) =>
             resolveBinding(name, atNode)?.pointeeType,
+        // Is the object `name` denotes (through `->` when `arrow`) const?
+        // true / false where the declaration decides, else undefined.
+        objectConst: (name, atNode, arrow) => {
+            const binding = resolveBinding(name, atNode);
+            if (!binding || binding.declConst === undefined) return undefined;
+            if (arrow ? binding.pointers !== 1 : binding.pointers !== 0) return undefined;
+            return binding.declConst;
+        },
         // fix #379: `v->m()` on a variable declared as an object (no
         // pointer declarator) goes through the class's operator->: the
         // declared type is a smart pointer or iterator (possibly behind an
@@ -5396,14 +5983,20 @@ function staticArgumentKind(node, variableTypes) {
     }
     if (node.type === 'number_literal') {
         const text = node.text || '';
+        // Integer literal zero is a null pointer constant, including its
+        // base, digit separators and standard integer suffixes.
+        if (/^(?:0[xX]0+|0[bB]0+|0+)(?:[uU](?:ll|LL|[lLzZ])?|(?:ll|LL|[lLzZ])[uU]?)?$/
+            .test(text.replace(/'/g, ''))) return 'number:zero';
+        const hexadecimal = /^0[xX]/.test(text);
         const floating = text.includes('.') ||
             /[pP][+-]?[0-9]/.test(text) ||
-            /[eE][+-]?[0-9]/.test(text) ||
-            /[fF]$/.test(text);
+            !hexadecimal && (/[eE][+-]?[0-9]/.test(text) || /[fF]$/.test(text));
         return floating ? 'number:floating' : 'number:integer';
     }
     if (node.type === 'true' || node.type === 'false') return 'bool';
-    if (node.type === 'null' || node.type === 'nullptr') return 'null';
+    // The grammar also calls NULL a null node, but that macro can expand
+    // to integer zero. Only the keyword has nullptr's conversion rules.
+    if (node.type === 'null' || node.type === 'nullptr') return node.text === 'nullptr' ? 'null' : 'expr';
     if (node.type === 'identifier') {
         const type = variableTypes?.getStatic(node.text, node) ||
             variableTypes?.get(node.text, node);
@@ -5414,21 +6007,21 @@ function staticArgumentKind(node, variableTypes) {
             (node.namedChildren || []).find(child =>
                 TYPE_NODES.has(child.type) || child.type === 'type_descriptor');
         const type = typeName(typeNode);
-        return type ? `type:${type}` : 'expr';
+        return type ? `type:${typeNode.text}` : 'expr';
     }
     if (node.type === 'new_expression') {
         const typeNode = node.childForFieldName('type') ||
             (node.namedChildren || []).find(child =>
                 TYPE_NODES.has(child.type) || child.type === 'type_descriptor');
         const type = typeName(typeNode);
-        return type ? `type:${type}` : 'expr';
+        return type ? `type:${typeNode.text}*` : 'expr';
     }
     if (node.type === 'cast_expression') {
         const typeNode = node.childForFieldName('type') ||
             (node.namedChildren || []).find(child =>
                 TYPE_NODES.has(child.type) || child.type === 'type_descriptor');
         const type = typeName(typeNode);
-        return type ? `type:${type}` : 'expr';
+        return type ? `type:${typeNode.text}` : 'expr';
     }
     if (node.type === 'call_expression') {
         const fnNode = node.childForFieldName('function');
@@ -5439,7 +6032,7 @@ function staticArgumentKind(node, variableTypes) {
                 (fnNode?.namedChildren || []).find(child =>
                     child.type === 'type_descriptor' || TYPE_NODES.has(child.type));
             const type = typeName(typeNode);
-            if (type) return `type:${type}`;
+            if (type) return `type:${typeNode.text}`;
         }
         // Bare-identifier producers are name-resolvable (fix #299B): mark
         // them `bcall:` so the overload discipline can type the argument
@@ -5458,13 +6051,34 @@ function staticArgumentKind(node, variableTypes) {
     return 'expr';
 }
 
+function argumentTypeContext(node) {
+    const typeParameters = [];
+    for (const [name, ranges] of templateScopes(node.tree)) {
+        if (ranges.some(range => range.start <= node.startIndex && node.endIndex <= range.end)) typeParameters.push(name);
+    }
+    return { line: node.startPosition.row + 1, ...(typeParameters.length && { typeParameters }) };
+}
+
+function argumentTypeOrigin(node, variableTypes) {
+    if (node.type === 'parenthesized_expression') return argumentTypeOrigin(node.namedChild(0), variableTypes);
+    if (node.type === 'identifier') return variableTypes?.getStaticOrigin(node.text, node) || null;
+    return argumentTypeContext(node);
+}
+
+function argumentFacts(values, variableTypes) {
+    const argKinds = values.map(value => staticArgumentKind(value, variableTypes));
+    const argTypeOrigins = values.map((value, i) => argKinds[i].startsWith('type:')
+        ? argumentTypeOrigin(value, variableTypes) : null);
+    return { argKinds, ...(argTypeOrigins.some(Boolean) && { argTypeOrigins }) };
+}
+
 function callArguments(node, variableTypes) {
     const args = node.childForFieldName('arguments');
     if (!args) return { argCount: 0, argKinds: [] };
     const values = args.namedChildren.filter(child => !child.type.endsWith('comment'));
     return {
         argCount: values.length,
-        argKinds: values.map(value => staticArgumentKind(value, variableTypes)),
+        ...argumentFacts(values, variableTypes),
         firstArg: values[0],
     };
 }
@@ -5485,8 +6099,11 @@ function templateScopes(tree) {
             if (!parameter.type.endsWith('parameter_declaration') ||
                 parameter.type === 'parameter_declaration' ||
                 parameter.type === 'optional_parameter_declaration') continue;
-            const nameNode = parameter.childForFieldName('name') ||
-                (parameter.namedChildren || []).find(child =>
+            const namedParameter = parameter.type === 'template_template_parameter_declaration'
+                ? parameter.namedChildren.find(child => child.type.endsWith('type_parameter_declaration'))
+                : parameter;
+            const nameNode = namedParameter?.childForFieldName('name') ||
+                (namedParameter?.namedChildren || []).find(child =>
                     child.type === 'type_identifier');
             if (nameNode?.text) names.push(nameNode.text);
         }
@@ -5558,12 +6175,12 @@ function callIdentity(fnNode) {
         const globalQualified = fnNode.text.startsWith('::') &&
             (!scopeNode || sameNode(scopeNode, rawNameNode));
         if (globalQualified) {
+            const nested = callIdentity(rawNameNode);
             return {
-                name: rawNameNode?.text,
-                nameNode: rawNameNode,
-                isMethod: false,
+                ...nested,
                 isPathCall: true,
-                globalQualified: true,
+                ...(nested.receiver ? { receiver: `::${nested.receiver}` }
+                    : { isMethod: false, globalQualified: true }),
             };
         }
         const nested = rawNameNode?.type === 'template_function' ||
@@ -5630,8 +6247,7 @@ function recoveredExplicitCallOperator(node, variableTypes) {
             isMethod: false,
             explicitTemplateCall: true,
             argCount: values.length,
-            argKinds: values.map(value =>
-                staticArgumentKind(value, variableTypes)),
+            ...argumentFacts(values, variableTypes),
             enclosingFunction: enclosingFunctionOf(node),
         };
     }
@@ -5666,8 +6282,7 @@ function recoveredExplicitCallOperator(node, variableTypes) {
         isMethod: false,
         explicitTemplateCall: true,
         argCount: values.length,
-        argKinds: values.map(value =>
-            staticArgumentKind(value, variableTypes)),
+        ...argumentFacts(values, variableTypes),
         enclosingFunction: enclosingFunctionOf(node),
     };
 }
@@ -5763,26 +6378,105 @@ function enclosingMacroArguments(node) {
  * #401): the shape of `T v(X());` that is an object initialized by a call
  * whenever X is not a type. null for any other parameter.
  */
-function vexingParseCallName(node) {
+function vexingParseCallIdentity(node) {
     const list = node.parent;
     const declarator = list?.type === 'parameter_list' ? list.parent : null;
     const declaration = declarator?.type === 'function_declarator' ? declarator.parent : null;
     if (declaration?.type !== 'declaration' || declaration.parent?.type !== 'compound_statement') return null;
     const typeNode = node.childForFieldName('type');
     const abstract = node.childForFieldName('declarator');
-    if (typeNode?.type !== 'type_identifier' || abstract?.type !== 'abstract_function_declarator') return null;
+    if (!['type_identifier', 'template_type'].includes(typeNode?.type) ||
+        abstract?.type !== 'abstract_function_declarator') return null;
     const params = abstract.childForFieldName('parameters');
     if (!params || params.namedChildCount !== 0) return null;
     if (node.namedChildren.some(child => child.type === 'type_qualifier')) return null;
-    return typeNode.text;
+    const identity = callIdentity(typeNode);
+    // A template-template parameter is a type even when a project function
+    // has the same name. Its empty function-type parameter is no call.
+    if (typeNode.type === 'template_type' && enclosedByTemplateParameter(node, identity.name)) return null;
+    return identity;
+}
+
+function constructorFieldNames(owner) {
+    const fields = new Set();
+    const visit = body => {
+        for (const field of body?.namedChildren || []) {
+            if (field.type !== 'field_declaration' || functionDeclarator(field)) continue;
+            const declarators = field.namedChildren.filter(child =>
+                child.type === 'field_identifier' || child.type.endsWith('declarator'));
+            for (const child of declarators) {
+                const identity = declaratorIdentity(child);
+                if (identity.name) fields.add(identity.name);
+            }
+            const aggregate = field.childForFieldName('type');
+            if (!declarators.length && ['union_specifier', 'struct_specifier'].includes(aggregate?.type) &&
+                !aggregate.childForFieldName('name')) visit(aggregate.childForFieldName('body'));
+        }
+    };
+    visit(owner.childForFieldName('body'));
+    return fields;
+}
+
+function implicitConstructorInfo(node, ownerName, owner) {
+    const declarator = functionDeclarator(node);
+    if (!declarator || declaratorIdentity(declarator).name !== ownerName) return null;
+    const name = declarator.childForFieldName('declarator');
+    if (!name) return null;
+    const { baseSpelling } = require('./constructor-bases');
+    const fields = constructorFieldNames(owner);
+    const initializers = node.namedChildren.find(child => child.type === 'field_initializer_list');
+    const initialized = (initializers?.namedChildren || []).map(child => baseSpelling(child.namedChild(0), '::'))
+        .filter(Boolean).map(entry => ({ ...entry, field: !entry.qualifier && fields.has(entry.name) }));
+    const defaulted = node.namedChildren.some(child => child.type === 'default_method_clause');
+    const parameters = parameterListOf(declarator);
+    return { node, name, initialized,
+        params: parameters ? nodeTextWithoutComments(parameters).replace(/^\(|\)$/g, '').trim() : null,
+        body: node.childForFieldName('body') || (defaulted ? node : null),
+        potential: defaulted,
+        suppressed: node.namedChildren.some(child => child.type === 'delete_method_clause') ||
+            defaulted && parameterListOf(declarator)?.namedChildCount > 0 ||
+            initialized.some(entry => !entry.field && !entry.qualifier && entry.name === ownerName) };
+}
+
+/**
+ * The call a mem-initializer of an out-of-class constructor definition makes
+ * (fix #421), or null when the definition is no constructor. Its own class
+ * name (unqualified, or qualified as the definition qualifies the class)
+ * delegates; any other name is a base or a member, decided by the engine.
+ */
+function outOfClassMemInitializer(definition, target, args, variableTypes) {
+    const identity = declaratorIdentity(functionDeclarator(definition));
+    const className = String(identity.className || '').replace(/<.*$/s, '').trim();
+    if (!identity.name || identity.name !== className) return null;
+    const name = typeName(target);
+    if (!name) return null;
+    const scope = target.childForFieldName('scope');
+    const delegates = name === className && (!scope || scope.text.replace(/\s+/g, '') === identity.ownerQualifier);
+    const values = args.namedChildren.filter(child => !child.type.endsWith('comment'));
+    return { name, isMethod: false, isConstructor: true, constructorSyntax: 'delegation',
+        ctorDelegation: delegates ? 'this' : 'super',
+        ...(scope && { constructorQualifier: scope.text }),
+        ...(!delegates && { memberInitializer: true }),
+        argCount: values.length, ...argumentFacts(values, variableTypes) };
+}
+
+function implicitOwnerScope(node) {
+    const identity = classIdentity(node);
+    const namespace = identity.ownerQualifier
+        ? [enclosingNamespace(node), identity.ownerQualifier].filter(Boolean).join('::') : enclosingNamespace(node);
+    return { namespace, enclosingType: identity.enclosingType || enclosingClass(node)?.name || null,
+        anonymousNamespace: classNamespaceScope(node, namespace).anonymous };
 }
 
 function findCallsInTree(code, parser, _options = {}, existingTree = null,
-    includeMacroBodies = true) {
+    includeMacroBodies = true, mode = 'cpp') {
     const tree = existingTree || parseTree(parser, code);
     const variableTypes = buildVariableTypes(tree);
     const fieldTypes = variableTypes.fieldTypes;
     const calls = [];
+    const implicitConfig = require('./index').langTraits(mode)?.implicitBaseConstruction;
+    const implicitOwners = implicitConfig ? getCachedNodeList(tree.rootNode).nodes
+        .filter(node => implicitConfig.classes.includes(node.type)) : null;
     traverseTreeCached(tree.rootNode, node => {
         const recoveredOperator = recoveredExplicitCallOperator(
             node, variableTypes);
@@ -5794,10 +6488,12 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
         // grammar reads a function declaration whose parameter is an
         // unnamed function type; when `CurrentOptions` is no type (decided at
         // query time) it is a call initializing the object.
-        if (node.type === 'parameter_declaration' && vexingParseCallName(node)) {
-            const nameNode = node.childForFieldName('type');
+        const declarationCall = node.type === 'parameter_declaration' ? vexingParseCallIdentity(node) : null;
+        if (declarationCall) {
+            const nameNode = declarationCall.nameNode;
             calls.push({
-                name: nameNode.text,
+                name: declarationCall.name,
+                ...(declarationCall.explicitTemplateCall && { explicitTemplateCall: true }),
                 line: nameNode.startPosition.row + 1,
                 column: nameNode.startPosition.column,
                 callStart: node.startIndex,
@@ -5911,6 +6607,15 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                 ...(functionNode?.type === 'identifier' &&
                     cLocalBindingNames(tree).has(identity.name) &&
                     cBareNameShadowedByLocal(node, identity.name) && { localShadow: true }),
+                // `(N)(x)` (fix #427): a call of N, or a cast to the type N;
+                // which one depends on what N names where it is written.
+                ...(functionNode?.type === 'parenthesized_expression' && functionNode.namedChildCount === 1 &&
+                    ['identifier', 'qualified_identifier'].includes(functionNode.namedChild(0).type) && {
+                    parenthesizedCallee: true,
+                    ...(functionNode.namedChild(0).type === 'identifier' &&
+                        cLocalBindingNames(tree).has(identity.name) &&
+                        cBareNameShadowedByLocal(node, identity.name) && { localShadow: true }),
+                }),
                 ...(identity.receiver && { receiver: identity.receiver }),
                 ...(identity.isPathCall && { isPathCall: true }),
                 ...(identity.globalQualified && { globalQualified: true }),
@@ -5929,6 +6634,12 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                 // as an object records its declared type for that lookup.
                 ...(identity.pointerAccess && receiverNode?.type === 'identifier' &&
                     receiverFields.length === 0 && { receiverArrow: true }),
+                // The implicit object's constness where the declaration of
+                // a plain variable receiver decides it (fix #427).
+                ...(receiverNode?.type === 'identifier' && receiverFields.length === 0 && !arrowThroughObject &&
+                    variableTypes.objectConst?.(receiverNode.text, node, identity.pointerAccess) !== undefined && {
+                    receiverConst: variableTypes.objectConst(receiverNode.text, node, identity.pointerAccess),
+                }),
                 ...(arrowThroughObject && variableTypes.get(receiverRoot, node) && {
                     receiverArrowObject: variableTypes.get(receiverRoot, node),
                     receiverArrowObjectAt: variableTypes.evidence(receiverRoot, node)
@@ -5963,10 +6674,14 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                     receiverField: receiverFields[0],
                     receiverFields,
                     ...(receiverRootType && { receiverRootType }),
+                    // `field->m()` (fix #427): the member is looked up in
+                    // what `->` yields from the last field's declared type.
+                    ...(identity.pointerAccess && { receiverFieldArrow: true }),
                 }),
                 ...(assignedTo && { assignedTo }),
                 argCount: args.argCount,
                 argKinds: args.argKinds,
+                ...(args.argTypeOrigins && { argTypeOrigins: args.argTypeOrigins }),
                 enclosingFunction,
                 ...(first && {
                     firstStringArg: first.value,
@@ -5983,7 +6698,10 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
             // parenthesized-value shape and recover its base/path identity.
             const typeNode = node.childForFieldName('type');
             const valueNode = node.childForFieldName('value');
-            if (typeNode?.type === 'type_descriptor' &&
+            // A declarator or a qualifier in the parentheses (`(BYTE*)(p)`,
+            // `(const T)(x)`) only spells a type (fix #427).
+            if (typeNode?.type === 'type_descriptor' && !typeNode.childForFieldName('declarator') &&
+                !(typeNode.namedChildren || []).some(child => child.type === 'type_qualifier') &&
                 valueNode?.type === 'parenthesized_expression') {
                 const identity = callIdentity(typeNode);
                 if (identity.name) {
@@ -5997,15 +6715,50 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                         isMethod: identity.isMethod,
                         ...(identity.receiver && { receiver: identity.receiver }),
                         ...(identity.isPathCall && { isPathCall: true }),
+                        parenthesizedCallee: true,
                         argCount: values.length,
-                        argKinds: values.map(value =>
-                            staticArgumentKind(value, variableTypes)),
+                        ...argumentFacts(values, variableTypes),
                         enclosingFunction: enclosingFunctionOf(node),
                     });
                     return false;
                 }
             }
         }
+        if (mode === 'cpp' && node.type === 'field_initializer') {
+            let owner = node.parent, definition = null;
+            while (owner && !['class_specifier', 'struct_specifier', 'union_specifier'].includes(owner.type)) {
+                if (!definition && owner.type === 'function_definition') definition = owner;
+                owner = owner.parent;
+            }
+            const target = node.namedChild(0), args = node.namedChildren.find(child => child.type === 'argument_list');
+            if (!owner && definition && target && args) {
+                // An out-of-class constructor definition (`W::W(..) : W(..)`,
+                // `D::D() : B(..)`, fix #421): its class body is in another
+                // place, so a name other than the class's own may be a
+                // member. The engine decides that by the class at query time.
+                const outOfClass = outOfClassMemInitializer(definition, target, args, variableTypes);
+                if (outOfClass) calls.push({ ...outOfClass, line: target.startPosition.row + 1,
+                    column: target.startPosition.column, callStart: node.startIndex, callEnd: node.endIndex,
+                    enclosingFunction: enclosingFunctionOf(node) });
+            }
+            if (owner && target && args) {
+                const hidden = constructorFieldNames(owner).has(target.text);
+                const self = owner.childForFieldName('name');
+                const bases = owner.namedChildren.find(child => child.type === 'base_class_clause')?.namedChildren || [];
+                const written = [self, ...bases].filter(Boolean).find(type => typeName(type) === typeName(target));
+                if (!hidden && written) {
+                    const values = args.namedChildren.filter(child => !child.type.endsWith('comment'));
+                    const scope = target.childForFieldName('scope') || written.childForFieldName('scope');
+                    calls.push({ name: typeName(target), line: target.startPosition.row + 1,
+                        column: target.startPosition.column, callStart: node.startIndex, callEnd: node.endIndex,
+                        isMethod: false, isConstructor: true, constructorSyntax: 'delegation',
+                        ctorDelegation: sameNode(written, self) ? 'this' : 'super',
+                        ...(scope && { constructorQualifier: scope.text }),
+                        argCount: values.length, ...argumentFacts(values, variableTypes),
+                        enclosingFunction: enclosingFunctionOf(node) });
+                }
+            }
+        }
         if (node.type === 'new_expression') {
             const typeNode = node.childForFieldName('type') ||
                 node.namedChildren.find(child => child.type === 'type_identifier' ||
@@ -6020,18 +6773,87 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                     column: typeNode.startPosition.column,
                     isMethod: false,
                     isConstructor: true,
+                    ...(mode === 'cpp' && node.childForFieldName('arguments')?.type === 'initializer_list' && {
+                        constructorSyntax: 'list',
+                    }),
+                    ...(typeNode.childForFieldName('scope') && {
+                        constructorQualifier: typeNode.childForFieldName('scope').text,
+                    }),
                     argCount: args.argCount,
                     argKinds: args.argKinds,
+                ...(args.argTypeOrigins && { argTypeOrigins: args.argTypeOrigins }),
                     enclosingFunction: enclosingFunctionOf(node),
                 });
             }
         }
+        if (mode === 'cpp' && node.type === 'init_declarator' && node.parent?.type === 'declaration') {
+            const declared = node.childForFieldName('declarator');
+            const value = node.childForFieldName('value');
+            const type = node.parent.childForFieldName('type');
+            if (declared?.type === 'identifier' && ['argument_list', 'initializer_list'].includes(value?.type) &&
+                ['type_identifier', 'qualified_identifier', 'template_type'].includes(type?.type)) {
+                const name = typeName(type);
+                const values = value.namedChildren.filter(child => !child.type.endsWith('comment'));
+                if (name) calls.push({
+                    name, line: declared.startPosition.row + 1, column: declared.startPosition.column,
+                    callStart: node.startIndex, callEnd: node.endIndex,
+                    isMethod: false, isConstructor: true,
+                    constructorSyntax: value.type === 'initializer_list' ? 'list' : 'direct',
+                    ...(type.childForFieldName('scope') && { constructorQualifier: type.childForFieldName('scope').text }),
+                    argCount: values.length, ...argumentFacts(values, variableTypes),
+                    enclosingFunction: enclosingFunctionOf(node),
+                });
+            }
+        }
+        // `Box b;`, `static Box s;`, `Box a[2];` (fix #421): default
+        // initialization runs the default constructor of a class type. The
+        // engine keeps the record only where the name denotes a class.
+        if (mode === 'cpp' && node.type === 'declaration') {
+            const type = node.childForFieldName('type');
+            const external = node.namedChildren.some(child => child.type === 'storage_class_specifier' && child.text === 'extern');
+            const name = !external && ['type_identifier', 'qualified_identifier', 'template_type'].includes(type?.type)
+                ? typeName(type) : null;
+            for (const declarator of name ? node.childrenForFieldName('declarator') : []) {
+                const target = declarator.type === 'array_declarator' ? declarator.childForFieldName('declarator') : declarator;
+                if (target?.type !== 'identifier') continue;
+                calls.push({ name, line: target.startPosition.row + 1, column: target.startPosition.column,
+                    callStart: declarator.startIndex, callEnd: declarator.endIndex,
+                    isMethod: false, isConstructor: true, constructorSyntax: 'default',
+                    ...(type.childForFieldName('scope') && { constructorQualifier: type.childForFieldName('scope').text }),
+                    argCount: 0, argKinds: [], enclosingFunction: enclosingFunctionOf(node) });
+            }
+        }
+        if (mode === 'cpp' && node.type === 'compound_literal_expression') {
+            const type = node.childForFieldName('type'), value = node.childForFieldName('value');
+            const name = type && typeName(type);
+            if (name && value?.type === 'initializer_list') {
+                const values = value.namedChildren.filter(child => !child.type.endsWith('comment'));
+                calls.push({ name, line: type.startPosition.row + 1, column: type.startPosition.column,
+                    callStart: node.startIndex, callEnd: node.endIndex,
+                    isMethod: false, isConstructor: true, constructorSyntax: 'list',
+                    ...(type.childForFieldName('scope') && { constructorQualifier: type.childForFieldName('scope').text }),
+                    argCount: values.length, ...argumentFacts(values, variableTypes),
+                    enclosingFunction: enclosingFunctionOf(node) });
+            }
+        }
         return true;
     });
     if (includeMacroBodies) calls.push(...findMacroBodyCalls(tree, code, parser));
+    calls.push(...require('./constructor-bases').implicitBaseCalls(tree.rootNode, mode, null, implicitOwners));
     return calls;
 }
 
+/** Omitted base initializer calls of one class, read as findCallsInCode reads them (fix #421). */
+function implicitBaseCallsOf(code, parser, ownerLine, ownerEndLine, mode) {
+    const { implicitBaseCallsOfOwner } = require('./constructor-bases');
+    const tree = parseTree(parser, code);
+    const primary = implicitBaseCallsOfOwner(tree.rootNode, mode, null, ownerLine, ownerEndLine);
+    const literal = literalRecoveryTree(parser, code, tree);
+    if (!literal) return primary;
+    return mergeExtracted(primary, implicitBaseCallsOfOwner(literal.rootNode, mode, null, ownerLine, ownerEndLine)
+        .map(call => ({ ...call, configurationVariant: true })), callIdentityKey);
+}
+
 function callIdentityKey(call) {
     return [
         call.name,
@@ -6126,6 +6948,36 @@ function directiveRanges(code) {
     return ranges;
 }
 
+/**
+ * A namespace-scope function declared `static` keeps internal linkage in
+ * every later declaration of the file that omits the storage class, its
+ * definition included (C11 6.2.2p4-5; C++ [dcl.stc]: successive
+ * declarations of an entity agree on linkage). Those declarations are
+ * recorded `static` (fix #427). A `static` declaration in a conditional
+ * branch reaches only the later declarations inside that branch.
+ */
+function inheritDeclaredLinkage(functions, mode) {
+    const paramKey = fn => (fn.paramsStructured || []).map(param => param.variadic ? '...'
+        : String(param.type || (param.unnamed ? param.name : '') || '').replace(/\s+/g, '')).join(',');
+    const keyOf = fn => mode === 'cpp' ? `${fn.namespace || ''}\0${fn.name}\0${paramKey(fn)}` : fn.name;
+    const free = fn => !fn.className && !fn.receiver && !fn.isMethod && !fn.friendOf &&
+        !fn.lexicalScopeStartLine && Array.isArray(fn.modifiers);
+    const internal = new Map();
+    const ordered = functions.filter(free).sort((a, b) => a.startLine - b.startLine);
+    for (const fn of ordered) {
+        const key = keyOf(fn);
+        if (fn.modifiers.includes('static')) {
+            if (!internal.has(key)) internal.set(key, []);
+            internal.get(key).push(fn);
+            continue;
+        }
+        const reaches = (internal.get(key) || []).some(prior => prior.startLine < fn.startLine &&
+            (!prior.ppBranch || (fn.startLine >= prior.ppBranch[0] && fn.startLine <= prior.ppBranch[1])));
+        if (!reaches) continue;
+        fn.modifiers = [...fn.modifiers.filter(modifier => modifier !== 'export'), 'static'];
+    }
+}
+
 function attributeCallsToLexicalFunctions(calls, functions) {
     const bodies = functions.filter(fn => !fn.isSignature)
         .sort((a, b) =>
@@ -6133,7 +6985,8 @@ function attributeCallsToLexicalFunctions(calls, functions) {
             b.startLine - a.startLine);
     for (const call of calls) {
         const owner = bodies.find(fn =>
-            fn.startLine <= call.line && call.line <= fn.endLine);
+            fn.startLine <= call.line && call.line <= fn.endLine &&
+            require('../core/callable-scope').containsCall(fn, call) !== false);
         if (!owner) continue;
         call.enclosingFunction = {
             name: owner.name,
@@ -6301,13 +7154,13 @@ function findCallsInCode(code, parser, options = {}, existingTree = null,
     // in preprocessor-configuration conservation.
     if (existingTree) {
         const calls = findCallsInTree(
-            code, parser, options, existingTree, includeMacroBodies);
+            code, parser, options, existingTree, includeMacroBodies, mode);
         const functions = findFunctionsInTree(code, existingTree, mode);
         return markDirectiveBodyCalls(code, attributeCallsToLexicalFunctions(calls, functions));
     }
     const tree = parseTree(parser, code);
     const primary = findCallsInTree(
-        code, parser, options, tree, includeMacroBodies);
+        code, parser, options, tree, includeMacroBodies, mode);
     const literal = literalRecoveryTree(parser, code, tree);
     if (!literal) {
         return markDirectiveBodyCalls(code, attributeCallsToLexicalFunctions(
@@ -6315,7 +7168,7 @@ function findCallsInCode(code, parser, options = {}, existingTree = null,
     }
     try {
         const literalCalls = findCallsInTree(
-            code, parser, options, literal, includeMacroBodies)
+            code, parser, options, literal, includeMacroBodies, mode)
             .map(call => ({ ...call, configurationVariant: true }));
         // Selected-configuration facts retain their stronger evidence.  Only
         // literal-only sites carry configurationVariant and are therefore
@@ -6343,6 +7196,32 @@ function findCallsInCode(code, parser, options = {}, existingTree = null,
  * for conservation but marked as lexical parameter dispatch; they must never
  * resolve to an unrelated project function that happens to share `fn`'s name.
  */
+/**
+ * A replacement list with its stringizing operators read as the string
+ * literals they produce, every byte kept in place (fix #430):
+ * `AssertPred1Helper(#pred, #v1, pred, v1)` is a call of four arguments, not
+ * a parse error of three. Token pasting stays as written: the pasted
+ * parameter is what the macro's parameter effects read.
+ */
+function withoutPreprocessingOperators(body, parameters) {
+    if (!body.includes('#')) return body;
+    const tokens = lexPP(body);
+    const chars = body.split('');
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.k !== 'punct') continue;
+        if (token.v === '#' && tokens[i + 1]?.k === 'id' &&
+            (parameters.has(tokens[i + 1].v) || tokens[i + 1].v === '__VA_ARGS__')) {
+            const end = tokens[i + 1].start + tokens[i + 1].v.length;
+            for (let at = token.start; at < end; at++) chars[at] = 'x';
+            chars[token.start] = '"';
+            chars[end - 1] = '"';
+            i++;
+        }
+    }
+    return chars.join('');
+}
+
 function findMacroBodyCalls(tree, code, parser, onlyName = null) {
     const calls = [];
     for (const node of macroDefinitionNodes(tree)) {
@@ -6363,7 +7242,7 @@ function findMacroBodyCalls(tree, code, parser, onlyName = null) {
         const parameters = new Set(parameterNames);
         // Replace only the continuation backslash. Keeping the newline and
         // every other byte makes source-line/column and span remapping exact.
-        const body = valueNode.text.replace(/\\(?=\r?\n)/g, ' ');
+        const body = withoutPreprocessingOperators(valueNode.text.replace(/\\(?=\r?\n)/g, ' '), parameters);
         const prefix = 'void __ucn_macro_body__(void) {\n';
         const synthetic = `${prefix}${body}\n;}`;
         // Synthetic replacement-list wrappers are one-shot parse inputs. Do
@@ -6408,6 +7287,7 @@ function findMacroBodyCalls(tree, code, parser, onlyName = null) {
                 : valueNode.startIndex + call.callEnd - prefix.length;
             calls.push({
                 ...withoutParameterReceiverTypes(call, parameters),
+                ...(call.argTypeOrigins && { argTypeOrigins: call.argTypeOrigins.map(() => null) }),
                 line,
                 column,
                 ...(callStart != null && callStart >= valueNode.startIndex && {
@@ -6494,7 +7374,77 @@ function findImportsInCode(code, parser) {
     } finally { /* cached with the selected tree */ }
 }
 
-const CALLEE_WRAPPER_NODES = new Set(['template_method', 'dependent_name', 'field_expression']);
+// Follow only the terminal name of a template, qualifier or member access.
+// Template arguments and receiver tokens keep their own expression roles.
+function usageNameExpression(node) {
+    let current = node;
+    while (current.parent) {
+        const parent = current.parent;
+        let head;
+        switch (parent.type) {
+            case 'template_function': case 'template_method': case 'template_type':
+            case 'qualified_identifier':
+                head = parent.childForFieldName('name');
+                break;
+            case 'field_expression':
+                head = parent.childForFieldName('field');
+                break;
+            case 'dependent_name': case 'parenthesized_expression':
+                head = parent.namedChildCount === 1 ? parent.namedChild(0) : null;
+                break;
+            default:
+                return current;
+        }
+        if (!sameNode(head, current)) return current;
+        current = parent;
+    }
+    return current;
+}
+
+function invokesNameExpression(expression) {
+    return expression.parent?.type === 'call_expression' &&
+        sameNode(expression.parent.childForFieldName('function'), expression);
+}
+
+function isInvokedName(node, options = {}) {
+    const expression = usageNameExpression(node);
+    if (!invokesNameExpression(expression)) return false;
+    if (options.unqualified) {
+        const identity = callIdentity(expression);
+        if (identity.isMethod || identity.isPathCall) return false;
+    }
+    return true;
+}
+
+// The name introduced by a declarator, including `A::f`, pointer/array
+// wrappers and data members. Keep this separate from the public usage kind:
+// an explicit instantiation still references a function the index declares
+// elsewhere. Refactoring uses the flag only on indexed declaration lines.
+function isDeclarationNameToken(node) {
+    let current = node;
+    for (let depth = 0; current?.parent && depth < 16; depth++) {
+        const parent = current.parent;
+        if (parent.type === 'qualified_identifier') {
+            if (!sameNode(parent.childForFieldName('name'), current)) return false;
+        } else if (parent.type.endsWith('_declarator')) {
+            const declarator = parent.childForFieldName('declarator') ||
+                (parent.type === 'parenthesized_declarator' && parent.namedChildCount === 1
+                    ? parent.namedChild(0) : null);
+            if (!sameNode(declarator, current)) return false;
+            if (parent.type === 'function_declarator') return true;
+        } else {
+            if (['declaration', 'field_declaration', 'function_definition', 'type_definition',
+                'parameter_declaration', 'optional_parameter_declaration', 'alias_declaration',
+                'enumerator', 'namespace_definition', 'namespace_alias_definition'].includes(parent.type)) {
+                return sameNode(parent.childForFieldName('name'), current) ||
+                    parent.childrenForFieldName('declarator').some(declarator => sameNode(declarator, current));
+            }
+            return false;
+        }
+        current = parent;
+    }
+    return false;
+}
 
 function findUsagesInCode(code, name, parser, existingTree, options = {}) {
     // Usage is the raw literal-name inventory. The literal C/C++ tree retains
@@ -6506,6 +7456,9 @@ function findUsagesInCode(code, name, parser, existingTree, options = {}) {
         safeParse(parser, code, undefined, PARSE_OPTIONS);
     const usages = [];
     const scopeMemo = options.lexicalScopes && options.mode === 'c' ? new Map() : null;
+    // Occurrence accounts consume positions and kinds, never receiver facts.
+    // Keep the same invocation classifier while omitting unrelated ownership.
+    const kindsOnly = options.usageKindsOnly && !options.lexicalScopes;
     const seenUsages = new Set();
     const addUsage = usage => {
         const key = `${usage.line}:${usage.column ?? ''}:${usage.usageType}:${usage.receiver || ''}`;
@@ -6519,27 +7472,10 @@ function findUsagesInCode(code, name, parser, existingTree, options = {}) {
         let receiver = null;
         const parent = node.parent;
         if (parent) {
-            let call = parent.type === 'call_expression'
-                ? parent
-                : parent.parent?.type === 'call_expression' ? parent.parent : null;
-            // `obj.template conv<long>()` nests the member name up to three
-            // levels below the call (fix #378).
-            if (!call && CALLEE_WRAPPER_NODES.has(parent.type)) {
-                let up = parent.parent;
-                for (let depth = 0; up && depth < 3 && CALLEE_WRAPPER_NODES.has(up.type); depth++) {
-                    up = up.parent;
-                }
-                if (up?.type === 'call_expression') call = up;
-            }
-            // Only the callable's terminal name is a call usage. The previous
-            // descendant test also matched receiver identifiers, classifying
-            // `copy.descriptor()` as a call to a free function named `copy`.
-            // callIdentity already unwraps qualified/template/parenthesized
-            // callees while preserving the exact terminal name node.
-            const calledIdentity = call
-                ? callIdentity(call.childForFieldName('function')) : null;
-            if (calledIdentity?.nameNode &&
-                sameNode(calledIdentity.nameNode, node)) {
+            const expression = usageNameExpression(node);
+            const invoked = invokesNameExpression(expression);
+            const identity = kindsOnly && !invoked ? null : callIdentity(expression);
+            if (invoked && sameNode(identity.nameNode, node)) {
                 usageType = 'call';
             } else if ((parent.type === 'function_declarator' ||
                 parent.type === 'parameter_declaration') &&
@@ -6562,22 +7498,14 @@ function findUsagesInCode(code, name, parser, existingTree, options = {}) {
             } else if (parent.type === 'preproc_include') {
                 usageType = 'import';
             }
-            if (parent.type === 'qualified_identifier' &&
-                sameNode(parent.childForFieldName('name'), node)) {
-                receiver = typeName(parent.childForFieldName('scope') ||
-                    parent.namedChild(0));
-            } else if (parent.type === 'field_expression' &&
-                sameNode(parent.childForFieldName('field'), node)) {
-                const argument = parent.childForFieldName('argument') ||
-                    parent.namedChild(0);
-                receiver = argument?.text || null;
-            }
+            // A generic wrapper does not erase an explicit receiver.
+            if (!kindsOnly && sameNode(identity.nameNode, node)) receiver = identity.receiver || null;
         }
         // A bare name lexically inside a class method participates in C++
         // member lookup on that class. This is ownership evidence for test
         // discovery and usage presentation; receiver-qualified forms above
         // retain their explicit receiver instead.
-        if (!receiver) receiver = enclosingClassName(node);
+        if (!kindsOnly && !receiver) receiver = enclosingClassName(node);
         // Where a bare C reference resolves (fix #396): block declarations,
         // parameters and `for` initializers bind it, else file scope.
         const scope = scopeMemo && usageType === 'reference' && !receiver
@@ -6586,6 +7514,8 @@ function findUsagesInCode(code, name, parser, existingTree, options = {}) {
             line: node.startPosition.row + 1,
             column: node.startPosition.column,
             usageType,
+            ...(options.lexicalScopes && usageType === 'reference' &&
+                isDeclarationNameToken(node) && { declarationName: true }),
             ...(receiver && { receiver }),
             ...scope,
         });
@@ -6601,7 +7531,7 @@ function findUsagesInCode(code, name, parser, existingTree, options = {}) {
             .map(usage => `${usage.line}:${usage.column ?? ''}`));
         const macroCalls = findMacroBodyCalls(tree, code, parser, name);
         for (const call of macroCalls) {
-            if (call.name !== name) continue;
+            if (call.name !== name || call.constructorSyntax === 'implicit') continue;
             const key = `${call.line}:${call.column ?? ''}`;
             if (seenCalls.has(key)) continue;
             seenCalls.add(key);
@@ -6635,7 +7565,8 @@ function parse(code, parser, mode, options = {}) {
     if (options.externalMacros && !externalMacroContext) {
         return withExternalMacros(options.externalMacros, () => parse(code, parser, mode, options));
     }
-    const tree = parseTree(parser, code);
+    const rawCapture = mode === 'cpp' ? { source: code, tree: null } : null;
+    const tree = parseTree(parser, code, rawCapture);
     const literal = literalRecoveryTree(parser, code, tree);
     try {
         const lines = code.split('\n');
@@ -6664,11 +7595,11 @@ function parse(code, parser, mode, options = {}) {
                 item => `${item.module}:${item.line}:${item.type}`,
             )
             : findImportsInTree(code, tree);
-        const primaryCalls = findCallsInTree(code, parser, {}, tree, true);
+        const primaryCalls = findCallsInTree(code, parser, {}, tree, true, mode);
         const calls = literal
             ? mergeExtracted(
                 primaryCalls,
-                findCallsInTree(code, parser, {}, literal, true)
+                findCallsInTree(code, parser, {}, literal, true, mode)
                     .map(call => ({ ...call, configurationVariant: true })),
                 callIdentityKey,
             )
@@ -6689,6 +7620,7 @@ function parse(code, parser, mode, options = {}) {
             classes.sort(byLine);
             calls.sort(byLine);
         }
+        inheritDeclaredLinkage(functions, mode);
         attributeCallsToLexicalFunctions(calls, functions);
         markDirectiveBodyCalls(code, calls);
         const result = {
@@ -6728,9 +7660,20 @@ function parse(code, parser, mode, options = {}) {
             result.externalMacroNames = [...externalMacroContext.consulted].sort();
         }
         if (mode === 'cpp') {
+            result.cppBaseSyntax = require('./cpp-site-syntax').cppBaseSyntax(code, parser,
+                calls.filter(call => call.implicitBase?.header).map(call => call.implicitBase.header),
+                rawCapture.tree || (selectedSourceByTree.get(tree) === code ? tree : null));
+            result.typeParameterNames = require('./utils').declaredTypeParameterNames(tree, literal);
             const markers = findMacroScopeMarkers(code, tree, lines);
             if (markers.length > 0) result.macroScopeMarkers = markers;
-            const usings = findCppUsingFacts(tree);
+            const primaryUsings = findCppUsingFacts(tree);
+            const originalUsings = literal ? findCppUsingFacts(literal) : primaryUsings;
+            const key = fact => `${fact.line}:${fact.kind}:${fact.target}`;
+            const original = new Map(originalUsings.map(fact => [key(fact), fact]));
+            const usings = mergeExtracted(primaryUsings, originalUsings, key).map(fact => {
+                const groups = original.get(key(fact))?.ppGroups;
+                return groups ? { ...fact, ppGroups: groups } : fact;
+            });
             if (usings.length > 0) result.cppUsings = usings;
         }
         // Adapter-only full-analysis fact: keep the public parse result shape
@@ -6743,6 +7686,7 @@ function parse(code, parser, mode, options = {}) {
         });
         return result;
     } finally {
+        if (rawCapture?.tree && rawCapture.tree !== tree && rawCapture.tree !== literal) rawCapture.tree.delete?.();
         if (options.releaseAnalysisTree) {
             releaseCFamilyTree(parser, code, tree);
         }
@@ -6766,7 +7710,7 @@ function languageBranchExtraction(code, mode) {
         return {
             functions: findFunctionsInTree(branch.source, tree, branch.language, lines).map(tag),
             classes,
-            calls: findCallsInTree(branch.source, branchParser, {}, tree, true).map(tag),
+            calls: findCallsInTree(branch.source, branchParser, {}, tree, true, branch.language).map(tag),
         };
     } finally {
         if (isMainThread) tree.delete?.();
@@ -6793,6 +7737,8 @@ function createCFamilyLanguage(mode) {
         findMacros,
         findCallsInCode: (code, parser, options, existingTree, includeMacroBodies) =>
             findCallsInCode(code, parser, options, existingTree, includeMacroBodies, mode),
+        implicitBaseCallsOf: (code, parser, ownerLine, ownerEndLine) =>
+            implicitBaseCallsOf(code, parser, ownerLine, ownerEndLine, mode),
         findImportsInCode,
         findExportsInCode: (code, parser) => findExportsInCodeShallow(code, parser, mode),
         findUsagesInCode: (code, name, parser, existingTree, options) =>
@@ -6859,11 +7805,19 @@ function objectMacroReading(parser, bodies) {
 }
 
 module.exports = {
+    deductionGuideOf,
+    endsFunctionHead,
+    withoutDecorationMacros,
+    implicitOwnerScope,
+    implicitConstructorInfo,
+    isInvokedName,
     createCFamilyLanguage,
     objectMacroReading,
     withExternalMacros,
+    hasExternalMacroContext: () => externalMacroContext !== null,
     // Deterministic test seams for the recovery memory/order contracts.
     conditionalRecoverySources,
+    conditionalHeaderText,
     mergeExtracted,
     macroAccessEffect,
 };