@quolu/lattice 0.69.5 → 0.71.0

package/sensor/dist/extraction/languages/c-cpp.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cppExtractor = exports.cExtractor = void 0;
 exports.normalizeCppReturnType = normalizeCppReturnType;
 exports.stripCppTemplateArgs = stripCppTemplateArgs;
+exports.isCppPureVirtualMethodDecl = isCppPureVirtualMethodDecl;
 exports.blankCppExportMacros = blankCppExportMacros;
 exports.blankCppInlineMacros = blankCppInlineMacros;
 exports.recoverMangledCppName = recoverMangledCppName;
 exports.blankMetalAttributes = blankMetalAttributes;
+exports.maskCppRawStrings = maskCppRawStrings;
 exports.blankCppAnnotationMacroCalls = blankCppAnnotationMacroCalls;
 exports.blankLoneMacroLines = blankLoneMacroLines;
 exports.blankCppApiPrefixMacros = blankCppApiPrefixMacros;
@@ -25,6 +27,8 @@ exports.blankCFileScopePrefixedDeclMacros = blankCFileScopePrefixedDeclMacros;
 exports.rewriteCPrefixedDeclMacroInitializers = rewriteCPrefixedDeclMacroInitializers;
 exports.blankCVaArgQualifiedTypeArgs = blankCVaArgQualifiedTypeArgs;
 exports.blankCNamedVariadicDefineDots = blankCNamedVariadicDefineDots;
+exports.blankCDesignatedMacroArgs = blankCDesignatedMacroArgs;
+exports.isCppConstructorDeclaration = isCppConstructorDeclaration;
 const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
 /**
  * Find the function NAME's `qualified_identifier` (`Foo::bar`) inside a
@@ -51,6 +55,67 @@ function findDeclaratorQualifiedId(declarator) {
     }
     return undefined;
 }
+/**
+ * Single-argument macros are ambiguous without their definition (#1373).
+ * Require a preceding local #define whose replacement uses its sole parameter
+ * as the function declarator; registration, token-pasting, and K&R forms stay
+ * untouched. Walk enclosing scopes, but never guess across conditional macros.
+ */
+function recoverSingleArgMacroDefinedName(node, source) {
+    if (node.type !== 'function_definition')
+        return undefined;
+    const declarator = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
+    let macro = null;
+    let argument = null;
+    if (declarator?.type === 'parenthesized_declarator' && declarator.namedChildCount === 1) {
+        // C: NATIVE_FN is parsed as the return type, (name) as the declarator.
+        macro = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        argument = declarator.namedChild(0);
+        if (macro?.type !== 'type_identifier' || argument?.type !== 'identifier')
+            return undefined;
+    }
+    else if (declarator?.type === 'function_declarator' && !(0, tree_sitter_helpers_1.getChildByField)(node, 'type')) {
+        // C++: NATIVE_FN(name) is parsed as an implicit-return-type function.
+        macro = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'declarator');
+        const params = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'parameters');
+        const param = params?.namedChild(0);
+        if (macro?.type !== 'identifier' || params?.namedChildCount !== 1 ||
+            param?.type !== 'parameter_declaration' || param.namedChildCount !== 1)
+            return undefined;
+        argument = param.namedChild(0);
+        if (argument?.type !== 'type_identifier')
+            return undefined;
+    }
+    if (!macro || !argument)
+        return undefined;
+    const macroName = (0, tree_sitter_helpers_1.getNodeText)(macro, source);
+    for (let scope = node; scope; scope = scope.parent) {
+        if (scope.type === 'preproc_else' || scope.type.startsWith('preproc_elif'))
+            return undefined;
+        for (let prev = scope.previousNamedSibling; prev; prev = prev.previousNamedSibling) {
+            if (prev.type.startsWith('preproc_if'))
+                return undefined;
+            if (prev.type === 'preproc_call' && (0, tree_sitter_helpers_1.getChildByField)(prev, 'directive')?.text === '#undef' &&
+                (0, tree_sitter_helpers_1.getChildByField)(prev, 'argument')?.text.trim() === macroName)
+                return undefined;
+            if (prev.type !== 'preproc_function_def' && prev.type !== 'preproc_def')
+                continue;
+            if ((0, tree_sitter_helpers_1.getChildByField)(prev, 'name')?.text !== macroName)
+                continue;
+            const params = (0, tree_sitter_helpers_1.getChildByField)(prev, 'parameters');
+            const param = params?.namedChild(0);
+            const value = (0, tree_sitter_helpers_1.getChildByField)(prev, 'value');
+            if (params?.namedChildCount !== 1 || param?.type !== 'identifier' || !value)
+                return undefined;
+            const replacement = (0, tree_sitter_helpers_1.getNodeText)(value, source).replace(/\\\r?\n/g, ' ').trim();
+            const match = replacement.match(/^(?:[A-Za-z_][A-Za-z0-9_:]*\s+)+[*&\s]*([A-Za-z_]\w*)\s*\([^(){};#]*\)\s*$/);
+            if (!match || /\btypedef\b/.test(replacement) || match[1] !== param.text)
+                return undefined;
+            return (0, tree_sitter_helpers_1.getNodeText)(argument, source);
+        }
+    }
+    return undefined;
+}
 /**
  * Recover the real function name from the macro-definition idiom
  * `MACRO_NAME(real_name, typed args…) { body }` — flash-attention's
@@ -102,7 +167,7 @@ function recoverCppMacroDefinedName(node, source) {
     return name;
 }
 function extractCppQualifiedMethodName(node, source) {
-    const macroDefined = recoverCppMacroDefinedName(node, source);
+    const macroDefined = recoverSingleArgMacroDefinedName(node, source) ?? recoverCppMacroDefinedName(node, source);
     if (macroDefined)
         return macroDefined;
     const declarator = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
@@ -208,6 +273,32 @@ function stripCppTemplateArgs(name) {
     }
     return out.trim();
 }
+/**
+ * Is this C++ `field_declaration` a pure-virtual method (`virtual int read(int key) = 0;`)?
+ * tree-sitter-cpp shapes those as a field_declaration whose declarator unwraps to a
+ * `function_declarator`, with the pure-virtual `= 0` as a DIRECT `number_literal` "0"
+ * child of the field_declaration (default-arg `= 0` lives inside parameter_declaration
+ * and must not match). Bodiless method prototypes (`int foo();`) and data members
+ * (`int x = 0;`) are excluded — prototypes usually have an out-of-line definition that
+ * already mints the method node; pure virtuals never do (#1727).
+ */
+function isCppPureVirtualMethodDecl(node) {
+    if (node.type !== 'field_declaration')
+        return false;
+    let declarator = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
+    if (!declarator)
+        return false;
+    while (declarator.type === 'pointer_declarator' ||
+        declarator.type === 'reference_declarator') {
+        const inner = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'declarator') || declarator.namedChild(0);
+        if (!inner)
+            return false;
+        declarator = inner;
+    }
+    if (declarator.type !== 'function_declarator')
+        return false;
+    return node.namedChildren.some((c) => c.type === 'number_literal' && c.text === '0');
+}
 /**
  * A function/method's return type lives in the `function_definition`'s `type`
  * field (`Metrics& Metrics::instance()` → `Metrics`). Constructors, destructors,
@@ -220,6 +311,7 @@ function extractCppReturnType(node, source) {
     return normalizeCppReturnType((0, tree_sitter_helpers_1.getNodeText)(typeNode, source));
 }
 exports.cExtractor = {
+    resolveName: recoverSingleArgMacroDefinedName,
     // CUDA in C-detected headers (content-gated blank; see preParseCSource).
     preParse: preParseCSource,
     // Universal net: recover a real name from any macro-mangled function name.
@@ -229,6 +321,9 @@ exports.cExtractor = {
     methodTypes: [],
     interfaceTypes: [],
     structTypes: ['struct_specifier'],
+    // A bodiless `union U;` is a forward declaration; the aggregate extractor
+    // applies the same body requirement it uses for C structs.
+    unionTypes: ['union_specifier'],
     enumTypes: ['enum_specifier'],
     enumMemberTypes: ['enumerator'],
     typeAliasTypes: ['type_definition'], // typedef
@@ -246,15 +341,20 @@ exports.cExtractor = {
     resolveTypeAliasKind: (node, _source) => {
         // C typedef: `typedef enum { ... } name;` or `typedef struct { ... } name;`
         // The inner enum_specifier/struct_specifier is anonymous, but we want the typedef name
-        // to become the enum/struct node name.
+        // to become the enum/struct node name. `typedef union { ... } name;` takes the
+        // same route — otherwise the union body would mint a second, `<anonymous>` node
+        // beside the alias.
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (!child)
                 continue;
             if (child.type === 'enum_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
                 return 'enum';
-            if (child.type === 'struct_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+            if (child.type === 'struct_specifier' &&
+                (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
                 return 'struct';
+            if (child.type === 'union_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'union';
         }
         return undefined;
     },
@@ -479,6 +579,58 @@ function blankMetalAttributes(source) {
         return source;
     return source.replace(METAL_ATTRIBUTE_RE, (m) => ' '.repeat(m.length));
 }
+/**
+ * Hide C++ raw literals from the offset-preserving preParse scans (#1505).
+ * Neither macro-shaped text in a raw body nor its `)delim"` closer is code.
+ * Mask the whole literal with non-whitespace, non-paren tokens, keeping line
+ * endings, so even line-based scanners treat a multiline raw argument as opaque.
+ * Restore untouched bytes afterward; a real enclosing annotation can still be
+ * removed in full. The pipeline masks once, and individual paren blankers also
+ * use this helper so they are safe when called directly.
+ */
+function maskCppRawStrings(source) {
+    const unchanged = { source, restore: (blanked) => blanked };
+    if (source.indexOf('R"') === -1)
+        return unchanged;
+    // Skip comments and ordinary literals before looking for a raw opener. The
+    // char-literal boundary leaves numeric digit separators (1'000) alone.
+    const re = /\/\/[^\r\n]*|\/\*[\s\S]*?(?:\*\/|$)|\b(?:u8|[LuU])?R"([^ \t\v\f\r\n()\\]{0,16})\(|"(?:\\[\s\S]|[^"\\])*(?:"|$)|(?<!\w)(?:u8|[LuU])?'(?:\\[\s\S]|[^'\\])*(?:'|$)/g;
+    const spans = [];
+    const parts = [];
+    let last = 0;
+    let m;
+    while ((m = re.exec(source)) !== null) {
+        if (m[1] === undefined)
+            continue;
+        const closer = `)${m[1]}"`;
+        const close = source.indexOf(closer, re.lastIndex);
+        // An unterminated raw literal owns the rest of the file too.
+        const end = close < 0 ? source.length : close + closer.length;
+        spans.push({ start: m.index, end });
+        parts.push(source.slice(last, m.index), source.slice(m.index, end).replace(/[^\r\n]/g, '\0'));
+        last = re.lastIndex = end;
+    }
+    if (spans.length === 0)
+        return unchanged;
+    parts.push(source.slice(last));
+    const masked = parts.join('');
+    return {
+        source: masked,
+        restore(blanked) {
+            // A length-changing rewrite cannot be restored at the original offsets.
+            if (blanked === masked || blanked.length !== source.length)
+                return source;
+            const chars = blanked.split('');
+            for (const { start, end } of spans) {
+                for (let i = start; i < end; i++) {
+                    if (chars[i] === '\0')
+                        chars[i] = source[i];
+                }
+            }
+            return chars.join('');
+        },
+    };
+}
 /**
  * Blank annotation-style macro invocations that decorate a declaration but carry
  * NO terminating semicolon — the pervasive Unreal-Engine reflection markup
@@ -519,6 +671,8 @@ function blankMetalAttributes(source) {
 function blankCppAnnotationMacroCalls(source) {
     if (!/^[ \t]*[A-Z][A-Z0-9_]{2,}\s*\(/m.test(source))
         return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     const chars = source.split('');
     const re = /^([ \t]*)([A-Z][A-Z0-9_]{2,})(\s*)\(/gm;
     let m;
@@ -565,7 +719,7 @@ function blankCppAnnotationMacroCalls(source) {
         }
         re.lastIndex = end;
     }
-    return chars.join('');
+    return rawStrings.restore(chars.join(''));
 }
 /**
  * Blank a macro that is the ONLY token on its line — no parens, no semicolon:
@@ -685,6 +839,8 @@ const CPP_INLINE_ANNOTATION_RE = /\b(?:UMETA|UPARAM|UE_DEPRECATED\w*)\s*\(/g;
 function blankCppInlineAnnotationMacros(source) {
     if (!/\b(?:UMETA|UPARAM|UE_DEPRECATED)/.test(source))
         return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     const chars = source.split('');
     const re = new RegExp(CPP_INLINE_ANNOTATION_RE.source, 'g');
     let m;
@@ -722,7 +878,7 @@ function blankCppInlineAnnotationMacros(source) {
         }
         re.lastIndex = end;
     }
-    return chars.join('');
+    return rawStrings.restore(chars.join(''));
 }
 /**
  * Blank CUDA-specific constructs before parsing `.cu`/`.cuh` files (parsed with
@@ -834,6 +990,32 @@ function restoreDirectiveLines(original, blanked) {
     }
     return changed ? b.join('\n') : blanked;
 }
+/** Recover MSVC's COM alias only at type-definition sites. Match on a lexical
+ * mask so comments, literals and directives cannot supply declaration evidence;
+ * replace just the keyword, preserving source offsets on both parser arms. */
+function normalizeCppComInterfaces(source) {
+    if (!source.includes('interface'))
+        return source;
+    // Raw strings have already been masked by preParseCppSource.
+    let code = source.replace(/\/\/(?:\\\r?\n|[^\r\n])*|\/\*[\s\S]*?(?:\*\/|$)|"(?:\\[\s\S]|[^"\\])*(?:"|$)|(?<!\w)(?:u8|[LuU])?'(?:\\[\s\S]|[^'\\])*(?:'|$)/g, (m) => m.replace(/[^\r\n]/g, ' '));
+    const hasAlias = /^[ \t]*#[ \t]*define[ \t]+interface[ \t]+struct\b/m.test(code);
+    code = code.replace(/^[ \t]*#(?:\\\r?\n|[^\r\n])*/gm, (m) => m.replace(/[^\r\n]/g, '\0'));
+    const declaration = /(^|[;{}])\s*\binterface\s+[A-Za-z_]\w*\s*(:[^;{}]+)?\{/gm;
+    const offsets = [];
+    let match;
+    while ((match = declaration.exec(code)) !== null) {
+        const bodyEnd = code.indexOf('}', declaration.lastIndex);
+        const hasVirtual = /\bvirtual\b/.test(code.slice(declaration.lastIndex, bodyEnd < 0 ? code.length : bodyEnd));
+        if (!hasAlias && !match[2] && !hasVirtual)
+            continue;
+        offsets.push(match.index + match[0].indexOf('interface'));
+        declaration.lastIndex--; // allow the opening brace to start a nested declaration
+    }
+    for (const offset of offsets) {
+        source = source.slice(0, offset) + 'struct   ' + source.slice(offset + 9);
+    }
+    return source;
+}
 /** C/C++ source pre-processing before tree-sitter: recover macro-annotated class
  * definitions, macro-prefixed function definitions, macro-prefixed members, and
  * macro-decorated members (Unreal-Engine reflection markup) — plus the non-C++
@@ -842,10 +1024,12 @@ function restoreDirectiveLines(original, blanked) {
  * or by content, for CUDA living in `.h`/`.hpp` headers). Offset-preserving;
  * directive lines are restored at the end (see restoreDirectiveLines). */
 function preParseCppSource(source, filePath) {
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     // blankCLeadingAttrMacros runs AFTER the api-prefix blank so a stacked
     // `FMT_NORETURN FMT_API void f(…)` reduces to the `MACRO Ret name(` shape
     // it matches (the _API token is already spaces by then).
-    let blanked = blankLoneMacroLines(blankCLeadingAttrMacros(blankCppAnnotationMacroCalls(blankCppInlineAnnotationMacros(blankCppApiPrefixMacros(blankCppInlineMacros(blankCppExportMacros(source)))))));
+    let blanked = blankLoneMacroLines(blankCLeadingAttrMacros(blankCppAnnotationMacroCalls(blankCppInlineAnnotationMacros(blankCppApiPrefixMacros(blankCppInlineMacros(blankCppExportMacros(normalizeCppComInterfaces(source))))))));
     const lower = filePath ? filePath.toLowerCase() : '';
     if (lower.endsWith('.metal')) {
         blanked = blankMetalAttributes(blanked);
@@ -853,7 +1037,7 @@ function preParseCppSource(source, filePath) {
     else if (lower.endsWith('.cu') || lower.endsWith('.cuh') || looksLikeCudaSource(source)) {
         blanked = blankCudaConstructs(blanked);
     }
-    return restoreDirectiveLines(source, blanked);
+    return rawStrings.restore(restoreDirectiveLines(source, blanked));
 }
 /**
  * Blank an unknown attribute macro sitting in front of a C function
@@ -977,6 +1161,8 @@ const C_STMT_MACRO_KEYWORDS = new Set([
     'if', 'while', 'for', 'switch', 'return', 'do', 'else', 'sizeof',
 ]);
 function blankCStatementMacroCalls(source) {
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     const lines = source.split('\n');
     let changed = false;
     const content = (l) => l.replace(/\r$/, '').trim();
@@ -1093,7 +1279,7 @@ function blankCStatementMacroCalls(source) {
         }
         changed = true;
     }
-    return changed ? lines.join('\n') : source;
+    return rawStrings.restore(changed ? lines.join('\n') : source);
 }
 /**
  * Blank a lowercase compiler-annotation word SANDWICHED between a storage
@@ -1246,9 +1432,8 @@ const C_PARAM_ANNOTATION_RE = new RegExp(`\\b(${[...C_PARAMETERIZED_ANNOTATIONS]
 function blankCParameterizedAnnotationMacros(source) {
     if (source.indexOf('__') === -1)
         return source;
-    C_PARAM_ANNOTATION_RE.lastIndex = 0;
-    if (!C_PARAM_ANNOTATION_RE.test(source))
-        return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     C_PARAM_ANNOTATION_RE.lastIndex = 0;
     let result = '';
     let last = 0;
@@ -1269,7 +1454,7 @@ function blankCParameterizedAnnotationMacros(source) {
         result += source.slice(last, start) + source.slice(start, end).replace(/[^\n\r]/g, ' ');
         last = end;
     }
-    return result + source.slice(last);
+    return rawStrings.restore(result + source.slice(last));
 }
 /**
  * Blank a bare `struct`/`union`/`enum` TYPE-keyword argument inside a macro
@@ -1312,6 +1497,8 @@ const C_TYPE_ARG_SCAN_CAP = 600;
 function blankCTypeKeywordArgs(source) {
     if (!/\b(?:struct|union|enum)[ \t\r\n]/.test(source))
         return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     let chars = null;
     C_TYPE_ARG_HEAD_RE.lastIndex = 0;
     let m;
@@ -1389,7 +1576,7 @@ function blankCTypeKeywordArgs(source) {
             atArgStart = false;
         }
     }
-    return chars ? chars.join('') : source;
+    return rawStrings.restore(chars ? chars.join('') : source);
 }
 /**
  * Blank a file-scope `static`/`extern`-prefixed ALL-CAPS declaration macro —
@@ -1417,6 +1604,8 @@ const C_PREFIXED_DECL_MACRO_RE = /^[ \t]*(?:static|extern)[ \t]+[A-Z][A-Z0-9_]{2
 function blankCFileScopePrefixedDeclMacros(source) {
     if (!/^[ \t]*(?:static|extern)[ \t]+[A-Z]/m.test(source))
         return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
     const lines = source.split('\n');
     let changed = false;
     for (let i = 0; i < lines.length; i++) {
@@ -1456,7 +1645,7 @@ function blankCFileScopePrefixedDeclMacros(source) {
         lines[i] = line.replace(/[^\n\r]/g, ' ');
         changed = true;
     }
-    return changed ? lines.join('\n') : source;
+    return rawStrings.restore(changed ? lines.join('\n') : source);
 }
 /**
  * REWRITE (the one non-blank pass in this family — it moves a token) a
@@ -1567,14 +1756,84 @@ function blankCNamedVariadicDefineDots(source) {
  * C-detected headers in CUDA projects (llm.c keeps `__device__` helpers and
  * kernel prototypes in plain `.h`) — the same content-gated CUDA blank as
  * C++. Offset-preserving. */
+/**
+ * Blank the argument list of a statement-level `MACRO( … );` call whose
+ * arguments are designated initializers — betaflight's
+ *
+ *     RESET_CONFIG(pidProfile_t, pidProfile,
+ *         .pid = { [PID_ROLL] = PID_ROLL_DEFAULT, … },
+ *         .pidSumLimit = PIDSUM_LIMIT,
+ *         …
+ *     );
+ *
+ * tree-sitter-c has no rule for `.field = value` as a call argument. Even a
+ * small statement-level `M(a, b, .x = 1, .y = { 1, 2 },);` with a trailing
+ * comma recovers by extending the enclosing `function_definition` to EOF —
+ * the next function vanishes and later ones nest under the first (#1729 —
+ * 310 functions in 73 files on a betaflight tree, which name matching then
+ * treated as unreachable closures). Emptying the argument list to spaces,
+ * newlines kept, leaves `RESET_CONFIG(\n\n…\n);` — a call the grammar parses
+ * cleanly — at the cost of the references inside the initializer, which the
+ * broken parse was not yielding either. Statement-level only (`);` follows),
+ * macro-cased name only, offsets preserved. Runs before the kernel route
+ * point, so both the wasm and kernel C arms see the same bytes.
+ */
+function blankCDesignatedMacroArgs(source) {
+    if (source.indexOf('=') === -1)
+        return source;
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
+    const out = source.split('');
+    const re = /^[ \t]*([A-Z_][A-Z0-9_]*)\s*\(/gm;
+    let m;
+    while ((m = re.exec(source))) {
+        const open = m.index + m[0].length - 1;
+        let depth = 1;
+        let i = open + 1;
+        for (; i < source.length && depth > 0; i++) {
+            const c = source[i];
+            if (c === '(')
+                depth++;
+            else if (c === ')')
+                depth--;
+        }
+        if (depth !== 0)
+            continue;
+        const close = i - 1;
+        const args = source.slice(open + 1, close);
+        // A designator at argument depth: `.name =` or `[index] =`.
+        if (!/(^|[,{(\s])(\.[A-Za-z_]\w*|\[[^\]]+\])\s*=[^=]/.test(args))
+            continue;
+        if (!/^\s*;/.test(source.slice(close + 1)))
+            continue;
+        for (let k = open + 1; k < close; k++)
+            if (out[k] !== '\n')
+                out[k] = ' ';
+        re.lastIndex = close;
+    }
+    return rawStrings.restore(out.join(''));
+}
 function preParseCSource(source) {
-    const inner = blankCKernelAnnotations(blankCCplusplusGuardBodies(source));
+    const rawStrings = maskCppRawStrings(source);
+    source = rawStrings.source;
+    const inner = blankCDesignatedMacroArgs(blankCKernelAnnotations(blankCCplusplusGuardBodies(source)));
     let blanked = blankCLeadingAttrMacros(blankLoneMacroLines(blankCStatementMacroCalls(blankCTrailingParamAttrMacros(blankCppAnnotationMacroCalls(rewriteCPrefixedDeclMacroInitializers(blankCFileScopePrefixedDeclMacros(blankCVaArgQualifiedTypeArgs(blankCTypeKeywordArgs(blankCParameterizedAnnotationMacros(blankCAutoInference(blankCSandwichedAnnotations(inner))))))))))));
     if (looksLikeCudaSource(blanked))
         blanked = blankCudaConstructs(blanked);
     // The named-variadic `#define` pass runs AFTER the directive restore — it
     // deliberately edits directive lines (see its doc comment).
-    return blankCNamedVariadicDefineDots(restoreDirectiveLines(source, blanked));
+    return rawStrings.restore(blankCNamedVariadicDefineDots(restoreDirectiveLines(source, blanked)));
+}
+/** A constructor prototype carries defaults even when its body is in another file. */
+function isCppConstructorDeclaration(node) {
+    if (node.type !== 'declaration' || (0, tree_sitter_helpers_1.getChildByField)(node, 'type'))
+        return false;
+    const owner = node.parent?.parent;
+    if (!owner || !['class_specifier', 'struct_specifier', 'union_specifier'].includes(owner.type))
+        return false;
+    const declarator = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
+    return declarator?.type === 'function_declarator'
+        && (0, tree_sitter_helpers_1.getChildByField)(declarator, 'declarator')?.text === (0, tree_sitter_helpers_1.getChildByField)(owner, 'name')?.text;
 }
 exports.cppExtractor = {
     // Recover macro-annotated class/struct definitions (`class MYMODULE_API Foo : Base`,
@@ -1591,9 +1850,23 @@ exports.cppExtractor = {
     // get picked as the blast-radius representative over — the single real
     // definition, exactly as bodiless struct/enum specifiers are already skipped. (#1093)
     skipBodilessClass: true,
-    methodTypes: ['function_definition'],
+    // `function_definition` covers inline / out-of-line bodies; `field_declaration`
+    // covers pure-virtual methods (`virtual int read(int key) = 0;`), which have no
+    // body and would otherwise mint no node — so calls through the abstract base and
+    // cpp-override synthesis had nothing to attach to (#1727). classifyMethodNode
+    // keeps ordinary data members / prototypes on the children-walk path.
+    methodTypes: ['function_definition', 'field_declaration'],
+    classifyMethodNode: (node) => {
+        if (node.type !== 'field_declaration')
+            return 'method';
+        return isCppPureVirtualMethodDecl(node) ? 'method' : 'skip';
+    },
+    isAbstract: (node) => (isCppPureVirtualMethodDecl(node) ? true : undefined),
     interfaceTypes: [],
     structTypes: ['struct_specifier'],
+    // C++ unions additionally carry member functions, which extract through the
+    // same aggregate-body walk as structs while preserving their distinct kind.
+    unionTypes: ['union_specifier'],
     enumTypes: ['enum_specifier'],
     enumMemberTypes: ['enumerator'],
     typeAliasTypes: ['type_definition', 'alias_declaration'], // typedef and using
@@ -1606,6 +1879,20 @@ exports.cppExtractor = {
     resolveName: extractCppQualifiedMethodName,
     getReceiverType: extractCppReceiverType,
     getReturnType: extractCppReturnType,
+    // Constructors (definitions and class-body declarations) carry their
+    // parameter list as the signature; a trailing semicolon marks a prototype, so a local `T obj(args)` can be matched
+    // to the one overload with a compatible arity (#1839). Macro-shaped
+    // definitions whose real name was recovered from an argument are excluded:
+    // their "parameters" are macro arguments. Mirrored in the kernel.
+    getSignature: (node, source) => {
+        if ((node.type !== 'function_definition' && !isCppConstructorDeclaration(node)) || (0, tree_sitter_helpers_1.getChildByField)(node, 'type'))
+            return undefined;
+        if (recoverCppMacroDefinedName(node, source))
+            return undefined;
+        const declarator = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
+        const parameters = declarator && (0, tree_sitter_helpers_1.getChildByField)(declarator, 'parameters');
+        return parameters ? (0, tree_sitter_helpers_1.getNodeText)(parameters, source) + (node.type === 'declaration' ? ';' : '') : undefined;
+    },
     getVisibility: (node) => {
         // Check for access specifier in parent
         const parent = node.parent;
@@ -1626,15 +1913,19 @@ exports.cppExtractor = {
         return undefined;
     },
     resolveTypeAliasKind: (node, _source) => {
-        // C++ typedef: `typedef enum { ... } name;` or `typedef struct { ... } name;`
+        // C++ typedef: `typedef enum { ... } name;`, `typedef struct { ... } name;`,
+        // or `typedef union { ... } name;` — see the C extractor.
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (!child)
                 continue;
             if (child.type === 'enum_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
                 return 'enum';
-            if (child.type === 'struct_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+            if (child.type === 'struct_specifier' &&
+                (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
                 return 'struct';
+            if (child.type === 'union_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'union';
         }
         return undefined;
     },