Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

fix(parsing): recover export-macro-hidden type definitions (#1989)

XIYBHKfcf451c6a6dd
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.c
index 51c14eca1..2f475229a 100644
--- a/internal/cbm/cbm.c
+++ b/internal/cbm/cbm.c
@@ -1514,6 +1514,63 @@ static bool cbm_span_contains_callable_def(const char *src, int src_len, uint32_
return false;
}
+/* #1989: type-def counterpart of cbm_span_contains_callable_def. A rescued
+ * class/struct/enum definition has its name followed by a base clause (':') or
+ * a body ('{'), not a parameter list, so the callable validator would reject
+ * every type def pulled from the expanded tree. */
+static bool cbm_span_contains_type_def(const char *src, int src_len, uint32_t start_line,
+ uint32_t end_line, const char *name) {
+ if (!src || src_len <= 0 || !name || !name[0] || start_line == 0 || end_line < start_line) {
+ return false;
+ }
+ int span_start = 0;
+ uint32_t line = 1;
+ while (span_start < src_len && line < start_line) {
+ if (src[span_start++] == '\n') {
+ line++;
+ }
+ }
+ if (line != start_line) {
+ return false;
+ }
+ int span_end = span_start;
+ while (span_end < src_len && line <= end_line) {
+ if (src[span_end++] == '\n') {
+ line++;
+ }
+ }
+ size_t name_len = strlen(name);
+ for (int pos = span_start; pos + (int)name_len <= span_end; pos++) {
+ if (strncmp(src + pos, name, name_len) != 0 ||
+ (pos > 0 && cbm_identifier_char(src[pos - 1])) ||
+ (pos + (int)name_len < src_len && cbm_identifier_char(src[pos + name_len]))) {
+ continue;
+ }
+ int open = pos + (int)name_len;
+ while (open < span_end && isspace((unsigned char)src[open])) {
+ open++;
+ }
+ // Base clause (": public B"), body ("{"), or template args ("<...").
+ if (open < span_end && (src[open] == ':' || src[open] == '{' || src[open] == '<')) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* #1989: label buckets for the misparse-correction gates. A raw def extracted
+ * from a broken `class MOD_API Foo` shape lands under a callable label while
+ * the expanded tree yields a proper type label for the same name. */
+static bool cbm_def_label_is_type(const char *label) {
+ return label != NULL && (strcmp(label, "Class") == 0 || strcmp(label, "Enum") == 0 ||
+ strcmp(label, "Interface") == 0 || strcmp(label, "Type") == 0 ||
+ strcmp(label, "Struct") == 0 || strcmp(label, "Union") == 0);
+}
+
+static bool cbm_def_label_is_callable(const char *label) {
+ return label != NULL && (strcmp(label, "Function") == 0 || strcmp(label, "Method") == 0);
+}
+
/* Remap an expanded-source definition back to the original input file. Every
* line in the definition must be attributable to the main file; generated
* macro bodies, included headers, and ambiguous spans fail closed. */
@@ -2133,6 +2190,14 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
// Defs keep original-source line numbers; only CALLS are extracted from expanded source.
if (language == CBM_LANG_C || language == CBM_LANG_CPP || language == CBM_LANG_CUDA) {
uint64_t pp_start = now_ns();
+ /* #1989: collect build-system export-macro candidates from the raw
+ * source. They are predefined empty in the expanded buffer (see
+ * preprocessor.cpp) so `class MOD_API Foo` parses with its real name,
+ * and the rescue loop below can adopt corrected type defs. Bounded:
+ * at most CBM_EXPORT_MACRO_MAX names per file. */
+ char export_cands[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int export_cand_count =
+ cbm_export_macro_candidates(source, source_len, export_cands, CBM_EXPORT_MACRO_MAX);
CBMPreprocessedSource *preprocessed = cbm_preprocess_with_map(
source, source_len, rel_path, extra_defines, include_paths, language != CBM_LANG_C);
if (preprocessed && preprocessed->source) {
@@ -2213,17 +2278,52 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
* recover defs from it — adopting ONLY those that
* intersect a raw ERROR region, whose name is visible on
* the raw source line, and whose QN the raw pass did not
- * already extract. */
- if (ts_node_has_error(root)) {
+ * already extract.
+ *
+ * #1989: build-system export macros (<MOD>_API,
+ * <lib>_EXPORT, ...) are empty on the real compile line but
+ * opaque to tree-sitter, so `class MOD_API Foo` misparses
+ * with the macro as the type name — often with NO raw ERROR
+ * region at all (the class_specifier "succeeds" with the
+ * wrong name; enums and free functions do error out). When
+ * export-macro candidates were collected for this file, also
+ * adopt expanded defs that replace a raw def literally named
+ * as a candidate, or that correct a raw misparse label (the
+ * raw pass extracted the same name as Function/Method from
+ * the broken function_definition shape; the expanded tree
+ * yields a proper type def). Superseded raw defs are
+ * dropped so the corrected definition is not shadowed by
+ * the qualified-name dedup. With no candidates the block
+ * reduces to the original #961 behavior. */
+ if (ts_node_has_error(root) || export_cand_count > 0) {
cbm_error_regions_t raw_regs = {{0}, {0}, 0, 0};
cbm_collect_error_regions(root, &raw_regs, source, source_len);
- if (raw_regs.count > 0) {
+ if (raw_regs.count > 0 || export_cand_count > 0) {
int defs_before = result->defs.count;
cbm_extract_definitions(&pp_ctx);
int w = defs_before;
+ char *superseded = NULL;
+ if (export_cand_count > 0 && defs_before > 0) {
+ superseded =
+ (char *)cbm_calloc(CBM_MEM_CLASS_EXTRACT, (size_t)defs_before);
+ }
+ /* #1989: spans of defs already adopted from the
+ * expanded tree. A def nested inside one of these
+ * (an inline method of a rescued class) was dropped
+ * by the raw pass — the misparsed
+ * `class MOD_API Foo {...}` parsed as a
+ * function_definition, and nested defs in its body
+ * are never walked. Bounded: one span per adopted
+ * def, capped at 64. */
+ struct {
+ uint32_t start;
+ uint32_t end;
+ } rescued_spans[64];
+ int rescued_count = 0;
for (int i = defs_before; i < result->defs.count; i++) {
CBMDefinition *d = &result->defs.items[i];
bool adopt = false;
+ int supersede_j = -1;
if (cbm_remap_preprocessed_def(d, preprocessed)) {
for (int rj = 0; rj < raw_regs.count && !adopt; rj++) {
if (d->start_line <= raw_regs.ends[rj] &&
@@ -2231,26 +2331,159 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
adopt = true;
}
}
+ if (!adopt && export_cand_count > 0 && d->name) {
+ for (int ci = 0; ci < export_cand_count && !adopt; ci++) {
+ for (int j = 0; j < defs_before && !adopt; j++) {
+ CBMDefinition *r = &result->defs.items[j];
+ if (!r->name ||
+ strcmp(r->name, export_cands[ci]) != 0) {
+ continue;
+ }
+ if (r->start_line <= d->end_line &&
+ d->start_line <= r->end_line &&
+ cbm_span_contains_type_def(
+ source, source_len, d->start_line,
+ d->end_line, d->name)) {
+ adopt = true;
+ supersede_j = j;
+ }
+ }
+ }
+ if (!adopt && d->label && cbm_def_label_is_type(d->label)) {
+ for (int j = 0; j < defs_before && !adopt; j++) {
+ CBMDefinition *r = &result->defs.items[j];
+ /* Widened past callables (#1989): the
+ * misparse also mints value-label raw
+ * defs for types (`class X_API FEmpty {}`
+ * -> Variable FEmpty). Same name,
+ * overlapping span, raw label is NOT a
+ * type => raw is the misparse artifact. */
+ if (!r->name || !r->label || !d->name ||
+ strcmp(r->name, d->name) != 0 ||
+ cbm_def_label_is_type(r->label)) {
+ continue;
+ }
+ if (r->start_line <= d->end_line &&
+ d->start_line <= r->end_line) {
+ adopt = true;
+ supersede_j = j;
+ }
+ }
+ }
+ /* Nested rescue (#1989): a def nested inside
+ * an already-adopted def's span — the inline
+ * method of a rescued class, dropped by the
+ * raw pass because the class parsed as a
+ * function body. The same validation gates
+ * (name-on-line, shape, QN dedup) still run
+ * below before it lands. */
+ if (!adopt && rescued_count > 0) {
+ for (int k = 0; k < rescued_count && !adopt; k++) {
+ if (d->start_line >= rescued_spans[k].start &&
+ d->end_line <= rescued_spans[k].end) {
+ adopt = true;
+ }
+ }
+ }
+ }
}
- if (adopt && (!d->name ||
- !cbm_line_contains(source, source_len, d->start_line,
- d->name) ||
- !cbm_span_contains_callable_def(
- source, source_len, d->start_line, d->end_line,
- d->name))) {
+ if (adopt &&
+ (!d->name ||
+ !cbm_line_contains(source, source_len, d->start_line,
+ d->name) ||
+ (!cbm_span_contains_callable_def(source, source_len,
+ d->start_line, d->end_line,
+ d->name) &&
+ !cbm_span_contains_type_def(source, source_len, d->start_line,
+ d->end_line, d->name)))) {
adopt = false;
}
for (int j = 0; j < defs_before && adopt; j++) {
+ if (j == supersede_j || (superseded && superseded[j])) {
+ continue; // being replaced by this very def
+ }
const char *q = result->defs.items[j].qualified_name;
if (q && d->qualified_name &&
strcmp(q, d->qualified_name) == 0) {
+ /* #1989: a raw def holding the same QN is
+ * usually a reject — unless it is the
+ * misparse artifact this very def came to
+ * replace (raw "Function FCalc" from the
+ * broken `class MOD_API FCalc` shape vs the
+ * rescued "Class FCalc"). Same name, same
+ * span, raw label is not a type: supersede
+ * instead of dropping the correction. */
+ CBMDefinition *r = &result->defs.items[j];
+ if (d->label && cbm_def_label_is_type(d->label) &&
+ r->label && r->name && d->name &&
+ strcmp(r->name, d->name) == 0 &&
+ !cbm_def_label_is_type(r->label) &&
+ r->start_line == d->start_line &&
+ r->end_line == d->end_line && superseded) {
+ superseded[j] = 1;
+ continue;
+ }
adopt = false;
}
}
if (adopt) {
+ if (supersede_j >= 0 && supersede_j < defs_before &&
+ superseded) {
+ superseded[supersede_j] = 1;
+ }
+ /* Phantom-artifact suppression (#1989): on the
+ * raw tree `class MOD_API Foo : public Base
+ * {...}` parses as a function_definition whose
+ * declarator is the BASE-CLASS name, so the raw
+ * pass mints a bogus Function def named after
+ * the base spanning the whole class. Fingerprint:
+ * a raw callable def with an IDENTICAL span to
+ * the adopted type def whose name is one of the
+ * adopted def's base classes. A real method is
+ * a strict subset of the class span and never
+ * carries a base-class name. */
+ if (d->label && cbm_def_label_is_type(d->label) && superseded &&
+ d->base_classes) {
+ for (int j = 0; j < defs_before; j++) {
+ CBMDefinition *r = &result->defs.items[j];
+ if (!r->label || !r->name ||
+ !cbm_def_label_is_callable(r->label) ||
+ r->start_line != d->start_line ||
+ r->end_line != d->end_line) {
+ continue;
+ }
+ for (const char **b = d->base_classes; *b; b++) {
+ if (strcmp(*b, r->name) == 0) {
+ superseded[j] = 1;
+ break;
+ }
+ }
+ }
+ }
+ if (rescued_count < 64) {
+ rescued_spans[rescued_count].start = d->start_line;
+ rescued_spans[rescued_count].end = d->end_line;
+ rescued_count++;
+ }
result->defs.items[w++] = *d;
}
}
+ if (superseded) {
+ int rw = 0;
+ for (int j = 0; j < defs_before; j++) {
+ if (!superseded[j]) {
+ result->defs.items[rw++] = result->defs.items[j];
+ }
+ }
+ int shift = defs_before - rw;
+ if (shift > 0 && w > defs_before) {
+ memmove(&result->defs.items[rw],
+ &result->defs.items[defs_before],
+ (size_t)(w - defs_before) * sizeof(CBMDefinition));
+ }
+ w -= shift;
+ cbm_free(CBM_MEM_CLASS_EXTRACT, superseded);
+ }
result->defs.count = w;
}
}
diff --git a/internal/cbm/preprocessor.cpp b/internal/cbm/preprocessor.cpp
index 54cb073fe..9be6298f3 100644
--- a/internal/cbm/preprocessor.cpp
+++ b/internal/cbm/preprocessor.cpp
@@ -42,6 +42,283 @@ static bool has_preprocessor_work(const char *source, int source_len) {
return false;
}
+// ── Export-macro candidates (#1989) ─────────────────────────────────────────
+// Build systems define symbol-export macros empty on the compiler command line
+// (UE's UBT: `/D "MODULE_API="`; CMake generate_export_header: `<lib>_EXPORT`),
+// so they never appear as #define lines in the source. tree-sitter has no
+// preprocessor state either, and `class MODULE_API Foo` misparses with the
+// macro token as the type name (worse: enums and free functions are lost to
+// ERROR regions entirely). To mirror the real compile line, the preprocessed
+// second pass predefines the conventional export-macro-shaped identifiers found
+// in the file as empty. The shape is deliberately narrow — ALL_CAPS identifier
+// ending in a known export suffix, with a non-trivial prefix — and the list is
+// capped, so ordinary all-caps identifiers cannot be swept in wholesale.
+static const char *kExportMacroSuffixes[] = {"_API", "_EXPORT", "_IMPORT",
+ "_DLLEXPORT", "_DEPRECATED", NULL};
+
+static bool is_export_macro_shape(const char *id, size_t len) {
+ if (id[0] < 'A' || id[0] > 'Z') {
+ return false;
+ }
+ for (size_t i = 0; i < len; i++) {
+ char c = id[i];
+ bool upper = c >= 'A' && c <= 'Z';
+ bool digit = c >= '0' && c <= '9';
+ if (!upper && !digit && c != '_') {
+ return false;
+ }
+ }
+ for (int s = 0; kExportMacroSuffixes[s]; s++) {
+ size_t slen = strlen(kExportMacroSuffixes[s]);
+ // Require at least two prefix characters before the suffix so a bare
+ // "X_API"-style token (single-letter, easily a genuine symbol) stays out.
+ if (len >= slen + 2 && strncmp(id + len - slen, kExportMacroSuffixes[s], slen) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool is_identifier_start(char c) {
+ return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_';
+}
+
+static bool is_identifier_char(char c) {
+ return is_identifier_start(c) || (c >= '0' && c <= '9');
+}
+
+// C++ raw string literals (R"delim(...)delim"). Returns the index one past
+// the closing quote, or -1 when the form cannot be confidently recognized
+// (unterminated, malformed delimiter) — the caller then STOPS collecting so
+// the mis-modeled literal cannot poison the scan state of the rest of the
+// file (#1989 review).
+static int skip_raw_string(const char *source, int source_len, int quote) {
+ int j = quote + 1;
+ int delim_start = j;
+ while (j < source_len) {
+ char c = source[j];
+ if (c == '(') {
+ break;
+ }
+ // Delimiter chars: the standard d-char set excludes space, parens,
+ // backslash, and the line breaks — a double quote IS a legal d-char
+ // (R"""(...)""" compiles), so it must not end the delimiter (#1989
+ // review round 3).
+ if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ')' || c == '\\' ||
+ j - delim_start >= 16) {
+ return -1;
+ }
+ j++;
+ }
+ if (j >= source_len || source[j] != '(') {
+ return -1;
+ }
+ int delim_len = j - delim_start;
+ j++; // past the opening "("
+ while (j < source_len) {
+ if (source[j] == ')') {
+ int k = j + 1;
+ int m = 0;
+ while (m < delim_len && k + m < source_len &&
+ source[k + m] == source[delim_start + m]) {
+ m++;
+ }
+ if (m == delim_len && k + m < source_len && source[k + m] == '"') {
+ return k + m + 1;
+ }
+ }
+ j++;
+ }
+ return -1; // unterminated raw string: uncertain
+}
+
+// If the identifier just scanned is a raw-string prefix (R, LR, uR, UR, u8R)
+// immediately followed by a quote, return skip_raw_string(...). Returns 0 for
+// an ordinary identifier (including an identifier merely ENDING in R — only a
+// standalone prefix token starts a raw string) and -1 on an unrecognizable
+// raw form.
+static int raw_string_after_prefix(const char *source, int source_len, int start, int end) {
+ static const char *prefixes[] = {"R", "LR", "uR", "UR", "u8R", NULL};
+ size_t idlen = (size_t)(end - start);
+ bool is_prefix = false;
+ for (int p = 0; prefixes[p]; p++) {
+ if (idlen == strlen(prefixes[p]) && strncmp(source + start, prefixes[p], idlen) == 0) {
+ is_prefix = true;
+ break;
+ }
+ }
+ if (!is_prefix || end >= source_len || source[end] != '"') {
+ return 0;
+ }
+ return skip_raw_string(source, source_len, end);
+}
+
+// Advance past comments and string/char literals so only real code tokens
+// consume the candidate budget (#1989 review). Handles line-spliced //
+// comments (a backslash before the newline continues the comment — line
+// splicing happens before comment recognition) and, via the identifier-scan
+// hook in the callers, C++ raw string literals. A digit separator (1'000'000)
+// can still over-skip — that fails safe, toward NOT collecting a candidate.
+static int skip_non_code(const char *source, int source_len, int i) {
+ while (i < source_len) {
+ char c = source[i];
+ if (c == '/' && i + 1 < source_len && source[i + 1] == '/') {
+ i += 2;
+ for (;;) {
+ while (i < source_len && source[i] != '\n') {
+ i++;
+ }
+ if (i >= source_len) {
+ break;
+ }
+ // Line splice: a backslash right before the newline (allowing
+ // \r\n) means the comment continues on the next line.
+ int back = i - 1;
+ if (back >= 0 && source[back] == '\r') {
+ back--;
+ }
+ if (back >= 0 && source[back] == '\\') {
+ i++; // spliced: keep consuming inside the comment
+ continue;
+ }
+ i++; // real end-of-comment newline
+ break;
+ }
+ } else if (c == '/' && i + 1 < source_len && source[i + 1] == '*') {
+ i += 2;
+ while (i + 1 < source_len && !(source[i] == '*' && source[i + 1] == '/')) {
+ i++;
+ }
+ if (i + 1 < source_len) {
+ i += 2; // past the closing "*/"
+ } else {
+ i = source_len; // unterminated comment runs to EOF
+ }
+ } else if (c == '"' || c == '\'') {
+ char quote = c;
+ i++;
+ while (i < source_len) {
+ if (source[i] == '\\') {
+ i += 2;
+ continue;
+ }
+ if (source[i] == quote) {
+ i++;
+ break;
+ }
+ i++;
+ }
+ } else {
+ return i;
+ }
+ }
+ return i;
+}
+
+// Count-only scan used by the early gate (no storage).
+static bool has_export_macro_candidates(const char *source, int source_len) {
+ if (!source || source_len <= 0) {
+ return false;
+ }
+ int i = 0;
+ while (i < source_len) {
+ i = skip_non_code(source, source_len, i);
+ if (i >= source_len) {
+ break;
+ }
+ if (!is_identifier_start(source[i])) {
+ i++;
+ continue;
+ }
+ int start = i;
+ while (i < source_len && is_identifier_char(source[i])) {
+ i++;
+ }
+ // A raw-string prefix consumes everything up to its closing quote;
+ // an unrecognizable raw form poisons the scan state, so fail toward
+ // NOT running the second pass (raw behavior preserved).
+ int raw = raw_string_after_prefix(source, source_len, start, i);
+ if (raw < 0) {
+ return false;
+ }
+ if (raw > 0) {
+ i = raw;
+ continue;
+ }
+ if (is_export_macro_shape(source + start, (size_t)(i - start))) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static int collect_export_macro_candidates(const char *source, int source_len,
+ char (*out)[CBM_EXPORT_MACRO_NAME_MAX], int max_out) {
+ if (!source || source_len <= 0 || !out || max_out <= 0) {
+ return 0;
+ }
+ int stored = 0;
+ int i = 0;
+ while (i < source_len) {
+ i = skip_non_code(source, source_len, i);
+ if (i >= source_len) {
+ break;
+ }
+ if (!is_identifier_start(source[i])) {
+ i++;
+ continue;
+ }
+ int start = i;
+ while (i < source_len && is_identifier_char(source[i])) {
+ i++;
+ }
+ // Raw string (see has_export_macro_candidates): skip its body, or stop
+ // collecting entirely when the form cannot be confidently recognized —
+ // continuing would mis-tokenize the rest of the file and could both
+ // mint phantom candidates and mask real ones (#1989 review).
+ int raw = raw_string_after_prefix(source, source_len, start, i);
+ if (raw < 0) {
+ break;
+ }
+ if (raw > 0) {
+ i = raw;
+ continue;
+ }
+ size_t len = (size_t)(i - start);
+ /* Length gate FIRST: the dedup below reads out[k][0..len] against rows
+ * of CBM_EXPORT_MACRO_NAME_MAX bytes — an over-long candidate must be
+ * rejected before any compare touches them. */
+ if (len >= CBM_EXPORT_MACRO_NAME_MAX) {
+ continue;
+ }
+ if (!is_export_macro_shape(source + start, len)) {
+ continue;
+ }
+ bool dup = false;
+ for (int k = 0; k < stored; k++) {
+ if (strncmp(out[k], source + start, len) == 0 && out[k][len] == '\0') {
+ dup = true;
+ break;
+ }
+ }
+ if (dup) {
+ continue;
+ }
+ if (stored >= max_out) {
+ break; // bounded: stop collecting once the cap is reached
+ }
+ memcpy(out[stored], source + start, len);
+ out[stored][len] = '\0';
+ stored++;
+ }
+ return stored;
+}
+
+int cbm_export_macro_candidates(const char *source, int source_len,
+ char (*out)[CBM_EXPORT_MACRO_NAME_MAX], int max_out) {
+ return collect_export_macro_candidates(source, source_len, out, max_out);
+}
+
static int count_expanded_lines(const std::string &text) {
int count = 1;
for (char c : text) {
@@ -146,7 +423,11 @@ static bool build_line_map(const std::string &expanded, const std::string &main_
CBMPreprocessedSource *cbm_preprocess_with_map(const char *source, int source_len,
const char *filename, const char **extra_defines,
const char **include_paths, int cpp_mode) {
- if (!has_preprocessor_work(source, source_len)) {
+ // Run the second pass when there are directives to evaluate OR when the file
+ // carries export-macro-shaped identifiers to predefine empty (#1989) — a UE
+ // plugin header with only `#pragma once` + `#include` lines still needs it.
+ if (!has_preprocessor_work(source, source_len) &&
+ !has_export_macro_candidates(source, source_len)) {
return NULL; // NULL = no expansion needed, use original
}
@@ -156,6 +437,28 @@ CBMPreprocessedSource *cbm_preprocess_with_map(const char *source, int source_le
for (int i = 0; extra_defines[i]; i++)
dui.defines.push_back(extra_defines[i]);
}
+ // Predefine collected export-macro candidates as empty, mirroring the
+ // real compile command line (`/D "MODULE_API="`). Names already provided
+ // by the caller win — never override an explicit define.
+ char export_cands[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int export_cand_count =
+ collect_export_macro_candidates(source, source_len, export_cands, CBM_EXPORT_MACRO_MAX);
+ for (int i = 0; i < export_cand_count; i++) {
+ bool provided = false;
+ for (std::list<std::string>::const_iterator it = dui.defines.begin();
+ it != dui.defines.end(); ++it) {
+ const std::string &def = *it;
+ size_t eq = def.find('=');
+ std::string name = (eq == std::string::npos) ? def : def.substr(0, eq);
+ if (name == export_cands[i]) {
+ provided = true;
+ break;
+ }
+ }
+ if (!provided) {
+ dui.defines.push_back(std::string(export_cands[i]) + "=");
+ }
+ }
if (include_paths) {
for (int i = 0; include_paths[i]; i++)
dui.includePaths.push_back(include_paths[i]);
diff --git a/internal/cbm/preprocessor.h b/internal/cbm/preprocessor.h
index 72828c012..1b108b335 100644
--- a/internal/cbm/preprocessor.h
+++ b/internal/cbm/preprocessor.h
@@ -4,6 +4,15 @@
#include <stddef.h>
#include <stdint.h>
+/* #1989: build-system export macros (UE "<MOD>_API", CMake generate_export_header
+ * "<lib>_EXPORT", ...) are defined empty on the real compile command line but are
+ * invisible to tree-sitter, so `class MOD_API Foo` misparses with the macro token
+ * as the type name. The preprocessed second pass predefines the conventional
+ * export-macro-shaped identifiers found in a source file as empty, mirroring the
+ * real build line. The candidate list is bounded. */
+#define CBM_EXPORT_MACRO_MAX 32
+#define CBM_EXPORT_MACRO_NAME_MAX 96
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -15,6 +24,12 @@ typedef struct {
int expanded_line_count;
} CBMPreprocessedSource;
+// Collect conventional export-macro-shaped identifiers (ALL_CAPS ending in
+// _API/_EXPORT/_IMPORT/_DLLEXPORT/_DEPRECATED) from the source, up to max_out
+// unique names. Returns the number of names stored in out.
+int cbm_export_macro_candidates(const char *source, int source_len,
+ char (*out)[CBM_EXPORT_MACRO_NAME_MAX], int max_out);
+
// Preprocess C/C++ source: expand macros, evaluate #ifdef, resolve #include.
// Returns malloc-allocated expanded source, or NULL if no expansion needed/on failure.
// extra_defines: NULL-terminated array of "NAME=VALUE" strings (can be NULL).
diff --git a/tests/test_extraction.c b/tests/test_extraction.c
index a61083755..e5800f8da 100644
--- a/tests/test_extraction.c
+++ b/tests/test_extraction.c
@@ -8,6 +8,7 @@
#include "test_framework.h"
#include "cbm.h"
#include "foundation/constants.h" /* CBM_SZ_* */
+#include "preprocessor.h" /* cbm_export_macro_candidates (#1989) */
#include "../src/foundation/compat.h" /* cbm_clock_gettime (wide-flat scaling guard) */
#include "../src/foundation/compat_fs.h"
#include <time.h>
@@ -5751,6 +5752,370 @@ TEST(extract_c_clean_file_no_recovery_duplicates_issue961) {
PASS();
}
+/* #1989: build-system export macros (UE "<MOD>_API", CMake generate_export_header
+ * "<lib>_EXPORT") are empty on the real compile line but opaque to tree-sitter,
+ * so `class MOD_API Foo` misparses. The preprocessed second pass predefines the
+ * conventional export-macro-shaped identifiers found in the file as empty, and
+ * the recovery loop adopts the corrected type defs (superseding the raw
+ * misparse artifacts). */
+TEST(extract_cpp_export_macro_class_recovery_issue1989) {
+ CBMFileResult *r = extract("#pragma once\n"
+ "UCLASS()\n"
+ "class DUMMY_API UFoo : public UObject\n"
+ "{\n"
+ " GENERATED_BODY()\n"
+ "public:\n"
+ " int32 X = 0;\n"
+ "};\n",
+ CBM_LANG_CPP, "p", "ue.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "UFoo");
+ ASSERT_NOT_NULL(cls); /* was missing entirely before the fix */
+ ASSERT_EQ(cls->start_line, 3u);
+ ASSERT_NULL(find_def(r, "DUMMY_API")); /* macro-as-name artifact superseded */
+ /* The raw misparse also mints a phantom Function def NAMED AFTER THE BASE
+ * CLASS spanning the whole class ("UObject" from the declarator of the
+ * broken function_definition shape) — it must be suppressed, not just the
+ * macro-named artifact. */
+ ASSERT_NULL(find_def(r, "UObject"));
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_cpp_export_macro_struct_recovery_issue1989) {
+ /* The struct case is the SILENT failure: the raw tree parses "successfully"
+ * with the macro token as the name and raises no error flag at all. */
+ CBMFileResult *r = extract("#pragma once\n"
+ "USTRUCT()\n"
+ "struct DUMMY_API FBar\n"
+ "{\n"
+ " int32 Y;\n"
+ "};\n",
+ CBM_LANG_CPP, "p", "ue_struct.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *st = find_def(r, "FBar");
+ ASSERT_NOT_NULL(st);
+ ASSERT(st->label && strcmp(st->label, "Class") == 0); /* struct_specifier -> Class */
+ ASSERT_NULL(find_def(r, "DUMMY_API"));
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_cpp_export_macro_enum_recovery_issue1989) {
+ /* `enum class MOD_API EKind` is lost to an ERROR region entirely. */
+ CBMFileResult *r = extract("#pragma once\n"
+ "UENUM()\n"
+ "enum class DUMMY_API EKind : uint8\n"
+ "{\n"
+ " A,\n"
+ " B\n"
+ "};\n",
+ CBM_LANG_CPP, "p", "ue_enum.h");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NOT_NULL(find_def(r, "EKind"));
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_cpp_export_macro_free_function_recovery_issue1989) {
+ /* A free function DEFINED with the export macro is lost to an ERROR region
+ * on the raw tree (prototypes never mint defs — same as clean code). */
+ CBMFileResult *r = extract("#pragma once\n"
+ "DUMMY_API int Add(int a, int b)\n"
+ "{\n"
+ " return a + b;\n"
+ "}\n",
+ CBM_LANG_CPP, "p", "ue_fn.h");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NOT_NULL(find_def(r, "Add"));
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_cpp_export_macro_inline_method_recovery_issue1989) {
+ /* The misparsed class parsed as a function body on the raw tree, so the
+ * raw walk never extracted its inline methods — the rescued class def must
+ * carry them in via the nested-span adoption. */
+ CBMFileResult *r = extract("#pragma once\n"
+ "class DUMMY_API FCalc\n"
+ "{\n"
+ "public:\n"
+ " int Add(int a, int b) { return a + b; }\n"
+ "};\n",
+ CBM_LANG_CPP, "p", "ue_inline.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "FCalc");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0); /* not the raw "Function" mislabel */
+ const CBMDefinition *m = find_def(r, "Add");
+ ASSERT_NOT_NULL(m);
+ ASSERT(m->label && strcmp(m->label, "Method") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Negative control the maintainer asked for: ordinary ALL_CAPS identifiers
+ * (constants, enum values) must NOT be swept in as export-macro candidates and
+ * stripped from the graph. Only the narrow _API/_EXPORT/... suffix shape is. */
+TEST(extract_cpp_export_macro_negative_control_ordinary_caps_issue1989) {
+ CBMFileResult *r = extract("#pragma once\n"
+ "#define MAX_CONNECTIONS 16\n"
+ "const int TIMEOUT_MS = 250;\n"
+ "enum class State { IDLE, RUNNING };\n"
+ "struct Config { int MAX_RETRIES; };\n",
+ CBM_LANG_CPP, "p", "caps.h");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NOT_NULL(find_def(r, "Config"));
+ ASSERT_TRUE(has_def(r, "Variable", "TIMEOUT_MS"));
+ cbm_free_result(r);
+ PASS();
+}
+
+/* C files get the same rescue (SQLITE_API-style prefixes are C, not C++). */
+TEST(extract_c_export_macro_recovery_issue1989) {
+ CBMFileResult *r = extract("typedef struct sqlite3 sqlite3;\n"
+ "SQLITE_API int sqlite3_open(const char *path)\n"
+ "{\n"
+ " return 0;\n"
+ "}\n",
+ CBM_LANG_C, "p", "db.c");
+ ASSERT_NOT_NULL(r);
+ ASSERT_NOT_NULL(find_def(r, "sqlite3_open"));
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review (P1): an over-long candidate-shaped identifier (>= 96 chars)
+ * arriving AFTER a stored candidate must be rejected BEFORE the dedup
+ * compares — the pre-fix dedup ran strncmp(out[k], src, len) with
+ * len >= CBM_EXPORT_MACRO_NAME_MAX against 96-byte rows (out-of-bounds read;
+ * sanitizer lanes crash). Locally unsanitized, so this pins the behavior
+ * (normal candidate still recovers, no crash); CI's sanitized lanes guard
+ * the memory error itself. */
+TEST(extract_cpp_export_macro_overlong_candidate_safe_issue1989) {
+ char src[4096];
+ int off = snprintf(src, sizeof(src), "class MOD_API First { int v; };\nclass ");
+ ASSERT_GTE(off, 0);
+ memset(src + off, 'A', 100);
+ off += 100;
+ ASSERT_GTE(snprintf(src + off, sizeof(src) - (size_t)off, "_API Long { int w; };\n"), 0);
+ CBMFileResult *r = extract(src, CBM_LANG_CPP, "p", "overlong.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *first = find_def(r, "First");
+ ASSERT_NOT_NULL(first);
+ ASSERT(first->label && strcmp(first->label, "Class") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review (P2): candidate-shaped tokens inside comments and string
+ * literals must NOT consume the bounded budget — 32 of them ahead of the real
+ * class would otherwise exhaust the cap and leave the real macro undefined. */
+TEST(extract_cpp_export_macro_comment_string_budget_issue1989) {
+ char src[8192];
+ int off = 0;
+ for (int n = 0; n < 31; n++) {
+ ASSERT_GTE(snprintf(src + off, sizeof(src) - (size_t)off, "// see DOC%02d_API notes\n", n),
+ 0);
+ off += (int)strlen(src + off);
+ }
+ ASSERT_GTE(snprintf(src + off, sizeof(src) - (size_t)off,
+ "static const char *kRef = \"STRING_DOC_API\";\n"
+ "class REALMOD_API Real { int v; };\n"),
+ 0);
+ CBMFileResult *r = extract(src, CBM_LANG_CPP, "p", "budget.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "Real");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review: the bounded-budget contract — 33 distinct candidates collect
+ * only the first CBM_EXPORT_MACRO_MAX (32, in source order); the 33rd stays
+ * unpredefined and its class keeps the raw misparse (value label, not Class). */
+TEST(extract_cpp_export_macro_candidate_cap_issue1989) {
+ char src[8192];
+ int off = 0;
+ for (int n = 0; n < 33; n++) {
+ ASSERT_GTE(
+ snprintf(src + off, sizeof(src) - (size_t)off, "class CAP%02d_API K%02d {};\n", n, n),
+ 0);
+ off += (int)strlen(src + off);
+ }
+ CBMFileResult *r = extract(src, CBM_LANG_CPP, "p", "cap.h");
+ ASSERT_NOT_NULL(r);
+ int recovered = 0;
+ for (int n = 0; n < 33; n++) {
+ char name[8];
+ snprintf(name, sizeof(name), "K%02d", n);
+ const CBMDefinition *d = find_def(r, name);
+ if (d && d->label && strcmp(d->label, "Class") == 0) {
+ recovered++;
+ }
+ }
+ ASSERT_EQ(recovered, 32);
+ /* The cap contract's other half: the 33rd candidate (K32) must STILL be
+ * present with its raw misparse — dropping the def entirely would be a
+ * regression, not a graceful cap. */
+ const CBMDefinition *cap_tail = find_def(r, "K32");
+ ASSERT_NOT_NULL(cap_tail);
+ ASSERT_TRUE(!cap_tail->label || strcmp(cap_tail->label, "Class") != 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review round 2: line-spliced // comments. A backslash before the
+ * newline continues the comment (splicing happens before comment
+ * recognition), so "FAKE_API" below is comment text and must NOT consume
+ * budget. 32 spliced fake comments would otherwise exhaust the cap and leave
+ * the real class unrecovered. */
+TEST(extract_cpp_export_macro_spliced_comment_budget_issue1989) {
+ char src[8192];
+ int off = 0;
+ for (int n = 0; n < 31; n++) {
+ ASSERT_GTE(
+ snprintf(src + off, sizeof(src) - (size_t)off, "// fake \\\nFAKE%02d_API notes\n", n),
+ 0);
+ off += (int)strlen(src + off);
+ }
+ ASSERT_GTE(snprintf(src + off, sizeof(src) - (size_t)off,
+ "// last \\\r\nSPLICEFAKE_API notes\n"
+ "class REALMOD_API Real { int v; };\n"),
+ 0);
+ CBMFileResult *r = extract(src, CBM_LANG_CPP, "p", "spliced.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "Real");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review round 2: C++ raw string literals. Tokens inside R"(...)"
+ * must not be collected, and code after the literal must still be scanned —
+ * an unmodeled raw string previously let "BAR_API" leak in AND masked the
+ * real candidate after the literal's closing quote. An unrecognizable raw
+ * form (unterminated/malformed delimiter) stops collection entirely so scan
+ * state cannot be poisoned. */
+TEST(extract_cpp_export_macro_raw_string_issue1989) {
+ CBMFileResult *r = extract("const char *s = R\"(foo \" BAR_API)\";\n"
+ "class REALMOD_API Real { int v; };\n",
+ CBM_LANG_CPP, "p", "raw.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "Real");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_cpp_export_macro_raw_string_delimited_issue1989) {
+ CBMFileResult *r = extract("auto log = R\"log(FOO_API \"quote\")log\";\n"
+ "class DELIMMOD_API Delim { int v; };\n",
+ CBM_LANG_CPP, "p", "raw_delim.h");
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "Delim");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review: every conventional suffix variant must be collected and
+ * recovered, not just _API. */
+TEST(extract_cpp_export_macro_suffix_variants_issue1989) {
+ CBMFileResult *r = extract("class LIB_EXPORT A1 { int v; };\n"
+ "class LIB_IMPORT B2 { int v; };\n"
+ "class LIB_DLLEXPORT C3 { int v; };\n"
+ "class LIB_DEPRECATED D4 { int v; };\n",
+ CBM_LANG_CPP, "p", "suffix.h");
+ ASSERT_NOT_NULL(r);
+ const char *names[] = {"A1", "B2", "C3", "D4"};
+ for (int n = 0; n < 4; n++) {
+ const CBMDefinition *d = find_def(r, names[n]);
+ ASSERT_NOT_NULL(d);
+ ASSERT(d->label && strcmp(d->label, "Class") == 0);
+ }
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #1989 review: caller-provided defines win — the collector must not push a
+ * define for a name the caller already provided (a duplicate could flip the
+ * expansion and silently change what parses). With an explicit empty define
+ * the class still recovers; with a caller define that corrupts the header,
+ * the injected empty define must NOT clobber it back into parsing. */
+TEST(extract_cpp_export_macro_explicit_define_priority_issue1989) {
+ const char *src = "class MYMOD_API Foo { int v; };\n";
+
+ const char *empty_defines[] = {"MYMOD_API=", NULL};
+ CBMFileResult *r = cbm_extract_file(src, (int)strlen(src), CBM_LANG_CPP, "p", "prio_empty.h", 0,
+ empty_defines, NULL);
+ ASSERT_NOT_NULL(r);
+ const CBMDefinition *cls = find_def(r, "Foo");
+ ASSERT_NOT_NULL(cls);
+ ASSERT(cls->label && strcmp(cls->label, "Class") == 0);
+ cbm_free_result(r);
+
+ const char *body_defines[] = {"MYMOD_API=Junk", NULL};
+ CBMFileResult *r2 = cbm_extract_file(src, (int)strlen(src), CBM_LANG_CPP, "p", "prio_body.h", 0,
+ body_defines, NULL);
+ ASSERT_NOT_NULL(r2);
+ const CBMDefinition *foo2 = find_def(r2, "Foo");
+ ASSERT_TRUE(foo2 == NULL || (foo2->label && strcmp(foo2->label, "Class") != 0));
+ cbm_free_result(r2);
+ PASS();
+}
+
+/* #1989 review round 2: the collector CONTRACT itself, called directly (the
+ * reviewer's method): the raw string's inner token is not a candidate and the
+ * code after the literal IS. */
+TEST(extract_cpp_export_macro_collector_raw_string_contract_issue1989) {
+ const char *src = "const char *s = R\"(foo \" BAR_API)\";\n"
+ "class REALMOD_API Real { int v; };\n";
+ char out[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int n = cbm_export_macro_candidates(src, (int)strlen(src), out, CBM_EXPORT_MACRO_MAX);
+ ASSERT_EQ(n, 1);
+ ASSERT(strcmp(out[0], "REALMOD_API") == 0);
+ PASS();
+}
+
+/* Delimiter form R"log(...)log" works the same way. */
+TEST(extract_cpp_export_macro_collector_raw_string_delim_contract_issue1989) {
+ const char *src = "auto log = R\"log(FOO_API \"q\")log\";\n"
+ "class DELIMMOD_API Delim { int v; };\n";
+ char out[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int n = cbm_export_macro_candidates(src, (int)strlen(src), out, CBM_EXPORT_MACRO_MAX);
+ ASSERT_EQ(n, 1);
+ ASSERT(strcmp(out[0], "DELIMMOD_API") == 0);
+ PASS();
+}
+
+/* A double quote is a legal raw-string delimiter character. Keep scanning
+ * after R"""(...)""" so a later export macro is still collected. */
+TEST(extract_cpp_export_macro_collector_raw_string_quote_delim_issue1989) {
+ const char *src = "const char *s = R\"\"\"(FOO_API)\"\"\";\n"
+ "class QUOTEMOD_API Quoted { int v; };\n";
+ char out[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int n = cbm_export_macro_candidates(src, (int)strlen(src), out, CBM_EXPORT_MACRO_MAX);
+ ASSERT_EQ(n, 1);
+ ASSERT(strcmp(out[0], "QUOTEMOD_API") == 0);
+ PASS();
+}
+
+/* Unterminated raw literal: the scan stops rather than mis-tokenizing the
+ * rest of the file (uncertain state -> fail toward raw behavior). */
+TEST(extract_cpp_export_macro_collector_raw_string_unterminated_issue1989) {
+ const char *src = "const char *s = R\"(never closed BAR_API\n"
+ "class REALMOD_API Real { int v; };\n";
+ char out[CBM_EXPORT_MACRO_MAX][CBM_EXPORT_MACRO_NAME_MAX];
+ int n = cbm_export_macro_candidates(src, (int)strlen(src), out, CBM_EXPORT_MACRO_MAX);
+ ASSERT_EQ(n, 0);
+ PASS();
+}
+
/* #668: walk_defs used a fixed `walk_defs_frame_t stack[4096]` — a ~160 KB
* C-stack frame that overflowed small thread stacks (the reporter's crash was in
* the "definitions pass" on a large SQL file), and whose `top < 4096` push guards
@@ -7974,6 +8339,25 @@ SUITE(extraction) {
RUN_TEST(extract_cpp_preproc_macro_generated_callable_skipped_issue949);
RUN_TEST(extract_c_ifdef_split_brace_after_include_remapped_issue949);
RUN_TEST(extract_c_clean_file_no_recovery_duplicates_issue961);
+ RUN_TEST(extract_cpp_export_macro_class_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_struct_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_enum_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_free_function_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_inline_method_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_negative_control_ordinary_caps_issue1989);
+ RUN_TEST(extract_c_export_macro_recovery_issue1989);
+ RUN_TEST(extract_cpp_export_macro_overlong_candidate_safe_issue1989);
+ RUN_TEST(extract_cpp_export_macro_comment_string_budget_issue1989);
+ RUN_TEST(extract_cpp_export_macro_candidate_cap_issue1989);
+ RUN_TEST(extract_cpp_export_macro_spliced_comment_budget_issue1989);
+ RUN_TEST(extract_cpp_export_macro_raw_string_issue1989);
+ RUN_TEST(extract_cpp_export_macro_raw_string_delimited_issue1989);
+ RUN_TEST(extract_cpp_export_macro_collector_raw_string_contract_issue1989);
+ RUN_TEST(extract_cpp_export_macro_collector_raw_string_delim_contract_issue1989);
+ RUN_TEST(extract_cpp_export_macro_collector_raw_string_quote_delim_issue1989);
+ RUN_TEST(extract_cpp_export_macro_collector_raw_string_unterminated_issue1989);
+ RUN_TEST(extract_cpp_export_macro_suffix_variants_issue1989);
+ RUN_TEST(extract_cpp_export_macro_explicit_define_priority_issue1989);
RUN_TEST(walk_defs_no_truncation_over_4096_issue668);
RUN_TEST(extract_rust_test_attr_marks_is_test_issue855);
RUN_TEST(extract_c_test_dir_marks_is_test_issue1294);