TheTechOddBug
diff --git a/‎CHANGELOG.md‎
Lines changed: 2 additions & 1 deletion b/‎CHANGELOG.md‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎__tests__/extraction.test.ts‎
Lines changed: 136 additions & 0 deletions b/‎__tests__/extraction.test.ts‎
Lines changed: 136 additions & 0 deletions
diff --git a/‎__tests__/fixtures/kernel-parity/torture.c‎
Lines changed: 84 additions & 0 deletions b/‎__tests__/fixtures/kernel-parity/torture.c‎
Lines changed: 84 additions & 0 deletions
diff --git a/‎__tests__/fixtures/kernel-parity/torture.cpp‎
Lines changed: 140 additions & 0 deletions b/‎__tests__/fixtures/kernel-parity/torture.cpp‎
Lines changed: 140 additions & 0 deletions
@@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### New Features
 
-- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, and Go projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, and django-scale codebases (Lombok-generated members included). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely.
+- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, and C++ projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, and protobuf-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely.
 - Reference resolution now runs in parallel on large projects. When a project has enough pending references to make it worthwhile (roughly 150k+, typical for big Java/Kotlin/Spring codebases), resolution fans out across worker threads while results are applied in the exact order the single-threaded path would have used — the graph comes out byte-for-byte identical, about twice as fast end-to-end on a 4,000-file Java project in our testing. Small projects keep the single-threaded path automatically (the fan-out costs more than it saves there). Set `CODEGRAPH_NO_PARALLEL_RESOLVE=1` to disable, or `CODEGRAPH_PARALLEL_RESOLVE_MIN=<count>` to tune when it engages.
 - Indexing large projects got another sizeable speedup — about a quarter less wall-clock on the same 4,000-file Java project, with the graph still byte-for-byte identical. Two changes: the database no longer interleaves expensive checkpoint housekeeping into the middle of resolution on a fresh index (it's folded once at the end instead), and while one batch's results are being written out, the worker threads are already resolving the next batch instead of sitting idle.
 - The dynamic-dispatch analysis that runs at the end of indexing (callback, event, and framework wiring) now runs its passes in parallel on large projects, cutting that stage roughly in half there — and a pass that crashes now retries safely instead of failing the whole index, which also makes very large codebases that previously died in this stage more likely to index to completion. Graphs remain byte-for-byte identical.
@@ -34,6 +34,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Deleting a whole directory is now picked up by watch mode: the files inside it are removed from the index on the next auto-sync instead of lingering as stale records until an unrelated edit happened to trigger one. Operating systems often report a directory deletion as a single event on the directory itself (with no per-file events for its contents), which the watcher previously discarded. (#1285)
 - `codegraph sync` now gets the same slow-disk fix that made full indexing fast in 1.4.0: database checkpointing is deferred for the whole incremental run instead of firing every few megabytes of writes. On mechanical drives and other high-latency storage, a small sync on a large index no longer stalls for minutes at near-zero CPU — the cost of a sync scales with what changed, not with the size of the existing index. The same `CODEGRAPH_NO_WAL_DEFER=1` switch turns it off. (#1248)
 - C functions declared with a project-specific attribute macro in front of a typedef'd return type (`SEC_ATTR UINT32 MyFunc(VOID)` — common in embedded and kernel code) are now indexed under their real names. Previously the parser tripped over the unknown macro and stored the parameter list as the function name, leaving entries like `"(VOID)"` in the graph and making the real function unfindable. (#1211)
+- Macro-heavy C and C++ code indexes much more completely. Six ubiquitous idioms that previously tripped the parser into error recovery — dropping or garbling the surrounding symbols — now parse cleanly: the `#ifdef __cplusplus` / `extern "C" {` compatibility guard in C headers, iterator macros in statement position (`list_for_each_entry(pos, head, member) { … }` and the whole Linux-kernel/git/jemalloc family, braced or single-statement), the Linux/sparse declaration annotations (`static int __init foo(void)`, `void __user *buf`, `container_of(p, struct T, m)`), trailing parameter annotations (`int argc UNUSED`, git's house style), namespace-management macros alone on a line (`FMT_BEGIN_NAMESPACE`, Qt's `Q_OBJECT`), and function attribute macros in front of C++ return types. On git's own repository this nearly doubles the number of indexed symbols, and on the Linux kernel's `kernel/` and `mm/` directories it triples them; blast radius and callers get correspondingly more complete. A related fix stops the existing macro handling from corrupting `#define` lines that mention the same macro names, which removed a class of phantom parse errors in fmt-style headers.
 - C++ methods defined out-of-line inside a namespace (`namespace sim { Output MyClass::Apply(...) { ... } }`) now carry the namespace in their qualified name, matching their class. Fully-qualified call sites from other files (`sim::MyClass::Apply(...)`) resolve to the definition again, so `codegraph callers` and file impact no longer come up empty for this pattern. (#1291)
 - C++ methods defined out-of-line on a template class (`template <typename T> T Box<T>::get() { ... }`) no longer keep the template parameter list in their qualified name. They now index as `Box::get` — identical to an inline definition of the same method — so they link to their class and resolve from call sites again, and pathological multi-line template parameter lists can no longer blow the qualified name past filesystem name limits. (#1286)
 - Go route detection no longer misidentifies ordinary method calls that share HTTP verb names — `cache.Put("key", value)`, `store.Get("config", out)`, `bus.Handle("user.created", handler)` and the like were being indexed as HTTP routes, polluting route listings in cache-heavy codebases. A registration now has to look like one: its first argument must be a `/`-prefixed path (all routers) or a Go 1.22 `"METHOD /path"` pattern on `Handle`/`HandleFunc`, which now also extracts the method instead of listing the route as `ANY`. (#1259)
 
@@ -11162,3 +11162,139 @@ import DataStore from '../data/DataStore';
     });
   });
 });
+
+// R7a preParse additions — the blanking passes added so macro-heavy C/C++
+// parses clean enough for the kernel route (each also improves the wasm
+// path's own graphs). Offset preservation is load-bearing everywhere.
+describe('C/C++ kernel-port preParse blanks (R7a)', () => {
+  it('blankCCplusplusGuardBodies blanks extern-C guard bodies, keeps directives', async () => {
+    const { blankCCplusplusGuardBodies } = await import('../src/extraction/languages/c-cpp');
+    const src = [
+      '#ifdef __cplusplus',
+      'extern "C" {',
+      '#endif',
+      'int real_decl(void);',
+      '#ifdef __cplusplus',
+      '}',
+      '#endif',
+      '',
+    ].join('\n');
+    const out = blankCCplusplusGuardBodies(src);
+    expect(out.length).toBe(src.length);
+    expect(out).not.toContain('extern "C"');
+    expect(out).toContain('#ifdef __cplusplus'); // directives stay
+    expect(out).toContain('int real_decl(void);');
+    // A guard with a nested directive bails (needs real preprocessing).
+    const nested = [
+      '#ifdef __cplusplus',
+      '#define EXTERNC extern "C"',
+      '#endif',
+      '',
+    ].join('\n');
+    expect(blankCCplusplusGuardBodies(nested)).toBe(nested);
+    // The `#ifndef` inverse guard is C-visible and must be untouched.
+    const inverse = ['#ifndef __cplusplus', 'int c_only(void);', '#endif', ''].join('\n');
+    expect(blankCCplusplusGuardBodies(inverse)).toBe(inverse);
+  });
+
+  it('blankLoneMacroLines blanks namespace-management macros, spares expression operands', async () => {
+    const { blankLoneMacroLines } = await import('../src/extraction/languages/c-cpp');
+    const src = ['FMT_BEGIN_NAMESPACE', 'struct S { int x; };', 'FMT_END_NAMESPACE', ''].join('\n');
+    const out = blankLoneMacroLines(src);
+    expect(out.length).toBe(src.length);
+    expect(out).not.toContain('FMT_BEGIN_NAMESPACE');
+    expect(out).toContain('struct S { int x; };');
+    // An ALL-CAPS operand alone on a line inside a multi-line expression is
+    // NOT a lone macro — the next line starts with an operator.
+    const expr = ['int x = 0', '  | FLAG_ONE', '  | FLAG_TWO;', ''].join('\n');
+    expect(blankLoneMacroLines(expr)).toBe(expr);
+    const cont = ['int y =', 'SOME_FLAG', '| OTHER;', ''].join('\n');
+    expect(blankLoneMacroLines(cont)).toBe(cont);
+    // Underscore-free solid words are too risky and stay.
+    const bare = ['NDEBUG', 'int z;', ''].join('\n');
+    expect(blankLoneMacroLines(bare)).toBe(bare);
+  });
+
+  it('blankCStatementMacroCalls blanks indented iterator macros, keeps the block', async () => {
+    const { blankCStatementMacroCalls } = await import('../src/extraction/languages/c-cpp');
+    const src = [
+      'static void walk(struct list *head) {',
+      '\tlist_for_each_entry(pos, head, member) {',
+      '\t\tuse(pos);',
+      '\t}',
+      '}',
+      '',
+    ].join('\n');
+    const out = blankCStatementMacroCalls(src);
+    expect(out.length).toBe(src.length);
+    expect(out).not.toContain('list_for_each_entry');
+    expect(out).toContain('use(pos);');
+    // A real call statement ends with `;` — untouched.
+    expect(out).toContain('use(pos);');
+    const call = ['void f(void) {', '\tdo_thing(a, b);', '}', ''].join('\n');
+    expect(blankCStatementMacroCalls(call)).toBe(call);
+    // Column-0 `name(args) {` is an implicit-int function definition — untouched.
+    const kandr = ['main(argc, argv)', '{', '\treturn 0;', '}', ''].join('\n');
+    expect(blankCStatementMacroCalls(kandr)).toBe(kandr);
+    // Control-flow keywords are never macros.
+    const ctrl = ['void g(int x) {', '\twhile (x) {', '\t\tx--;', '\t}', '}', ''].join('\n');
+    expect(blankCStatementMacroCalls(ctrl)).toBe(ctrl);
+  });
+
+  it('blankCTrailingParamAttrMacros blanks `name UNUSED` params, spares call args', async () => {
+    const { blankCTrailingParamAttrMacros } = await import('../src/extraction/languages/c-cpp');
+    const src = 'static int run(int argc UNUSED, const char **argv UNUSED)\n{\n\treturn 0;\n}\n';
+    const out = blankCTrailingParamAttrMacros(src);
+    expect(out.length).toBe(src.length);
+    expect(out).not.toContain('UNUSED');
+    expect(out).toContain('int argc ');
+    // A macro CONSTANT as a call argument is preceded by `,`/`(`, never by a
+    // bare identifier — untouched.
+    const call = 'void f(void) {\n\tconnect(sock, DEFAULT_TIMEOUT);\n}\n';
+    expect(blankCTrailingParamAttrMacros(call)).toBe(call);
+  });
+
+  it('blankCKernelAnnotations blanks sparse/section dunders, spares parameterized ones and real types', async () => {
+    const { blankCKernelAnnotations } = await import('../src/extraction/languages/c-cpp');
+    const src = [
+      'static int __init audit_init(void) { return 0; }',
+      'void copy(void __user *dst, const char *src);',
+      '__bpf_kfunc void bpf_iter_destroy(struct bpf_iter_num *it);',
+      '__printf(1, 2) void log_fmt(const char *fmt, ...);',
+      'struct e *entry = container_of(r, struct audit_entry, rule);',
+      '__u32 count = 0;',
+      '',
+    ].join('\n');
+    const out = blankCKernelAnnotations(src);
+    expect(out.length).toBe(src.length);
+    expect(out).not.toContain('__init');
+    expect(out).not.toContain('__user');
+    expect(out).not.toContain('__bpf_kfunc');
+    // Parameterized annotations keep their name — blanking it would strand
+    // the argument list as a floating parenthesis.
+    expect(out).toContain('__printf(1, 2)');
+    // container_of's type-keyword argument blanks; other `struct` keywords stay.
+    expect(out).toContain('container_of(r,        audit_entry, rule)');
+    expect(out).toContain('struct e *entry');
+    // Real dunder TYPES are not annotations.
+    expect(out).toContain('__u32 count');
+  });
+
+  it('restoreDirectiveLines keeps #define lines out of the blanking blast radius', async () => {
+    const { extractFromSource } = await import('../src/extraction');
+    // FMT_API matches the _API-suffix member blank; without the directive
+    // restore the #define loses its NAME and the file gains a parse error.
+    const src = [
+      '#define FMT_API FMT_VISIBILITY("default")',
+      'class Widget {',
+      ' public:',
+      '  int size() const { return 1; }',
+      '};',
+      '',
+    ].join('\n');
+    const result = extractFromSource('lib.hpp', src, 'cpp');
+    expect(result.errors).toEqual([]);
+    expect(result.nodes.some((n) => n.kind === 'class' && n.name === 'Widget')).toBe(true);
+    expect(result.nodes.some((n) => n.kind === 'method' && n.name === 'size')).toBe(true);
+  });
+});
@@ -0,0 +1,84 @@
+/* Torture fixture for the C kernel walker (R7a) — exercises every c-path
+ * branch of the checklist: fn-ptr tables, typedef enum/struct, file-scope
+ * consts incl. multi-declarator, the macro-prototype misparse skip,
+ * value-refs (+ shadow prune), the leading-attr-macro preParse blank, and
+ * the C call shapes. Must parse ERROR-FREE post-preParse or the kernel arm
+ * defers. */
+#include <stdio.h>
+#include <sys/socket.h>
+#include "local_ops.h"
+
+/** Retry budget for the poller. */
+static const int MAX_RETRIES = 3;
+static const int LOW_WATER = 2, HIGH_WATER = 8;
+static int counter = 0;
+static const char *BANNER = "torture";
+
+/* Bare identifier declarators are the macro-prototype misparse shape and are
+ * skipped by design (uninit scalars are the accepted loss). */
+int bare_global;
+MYLIB_API config_handle;
+
+/* Leading attribute macro — blanked by preParseCSource (#1211), so the real
+ * name survives on both arms. */
+SEC_ATTR UINT32 masked_entry(VOID) { return 0; }
+
+typedef enum { STATE_IDLE, STATE_RUNNING, STATE_DONE } run_state_t;
+
+typedef struct {
+  int fd;
+  void (*on_recv)(int);
+} conn_t;
+
+typedef struct conn_pool conn_pool_t;
+
+typedef int (*cb_t)(int);
+
+enum wire_flags { WIRE_A = 1, WIRE_B = 2 };
+
+struct packet {
+  int len;
+  unsigned char body[64];
+  struct packet *next;
+  cb_t *async_cb;
+};
+
+/** Sum helper (docstring). */
+static int add(int a, int b) { return a + b; }
+
+static int cb_a(int x) { return add(x, 1); }
+static int cb_b(int x) { return add(x, 2); }
+
+/* fn-ptr table at file scope — the ungated 'list' capture positions. */
+static cb_t DISPATCH_TABLE[] = { cb_a, cb_b };
+
+static void handle_recv(int fd);
+
+/* struct initializer — the ungated 'value' capture positions. */
+static const struct handler_ops OPS = { .recv = handle_recv, .flags = WIRE_A };
+
+static void handle_recv(int fd) {
+  struct packet pkt;
+  pkt.len = fd;
+  printf("fd=%d retries=%d\n", fd, MAX_RETRIES);
+}
+
+/* Local shadow of a file-scope const — the shadow prune drops HIGH_WATER as a
+ * value-ref target while LOW_WATER stays live. */
+static int shadowed_reader(void) {
+  int HIGH_WATER = 99;
+  return HIGH_WATER + LOW_WATER;
+}
+
+static int use_table(int idx, int v) {
+  cb_t fn = DISPATCH_TABLE[idx];
+  int r = (*fn)(v);
+  conn_t c = { 1, 0 };
+  c.on_recv(r);
+  return counter + r;
+}
+
+static void spawn_workers(void) {
+  register_handler(cb_a);
+  signal_connect(&cb_b);
+}
@@ -0,0 +1,140 @@
+/// Torture fixture for the C++ kernel walker (R7a) — namespaces (incl. C++17
+/// nested + anonymous), out-of-line Cls::method defs, templates + template
+/// bases, operator definitions, stack construction, local fn-ptrs, UE-macro
+/// shapes THROUGH the hoisted preParse, using-aliases, access specifiers,
+/// static-member value reads, and the cpp call shapes. Must parse ERROR-FREE
+/// post-preParse or the kernel arm defers (spaced operator CALL SITES live in
+/// torture-defer.cpp — they produce ERROR nodes by design).
+#include <vector>
+#include "widget_base.hpp"
+
+namespace app {
+
+/** Engine config (docstring). */
+class Config {
+public:
+  int retries;
+  void apply();
+  int helper_count() const { return 2; }
+
+private:
+  int secret;
+};
+
+void Config::apply() { retries = helper_count(); }
+
+namespace detail {
+struct Counter {
+  int value;
+  Counter *next;
+};
+}  // namespace detail
+
+int detail_probe() { return 1; }
+
+}  // namespace app
+
+namespace app::net {
+class Session {
+public:
+  void open();
+  virtual ~Session() {}
+};
+void Session::open() {}
+}  // namespace app::net
+
+namespace {
+int hidden_helper() { return 3; }
+}  // namespace
+
+template <typename T>
+class Base {
+public:
+  T item;
+};
+
+template <typename T>
+class Box : public Base<T> {
+public:
+  T get() const { return value_; }
+  T unwrap();
+
+private:
+  T value_;
+};
+
+template <typename T>
+T Box<T>::unwrap() {
+  return value_;
+}
+
+class Derived : public Base<int>, private app::Config {
+public:
+  Derived() : total_(0) {}
+  int total() const { return total_; }
+
+private:
+  int total_;
+};
+
+struct Vec2 {
+  float x, y;
+  Vec2 operator+(const Vec2 &o) const { return {x + o.x, y + o.y}; }
+  explicit operator bool() const { return x != 0 || y != 0; }
+  Vec2 origin();
+};
+
+enum class Mode : unsigned char { Off, On };
+enum Legacy { LEGACY_A, LEGACY_B };
+typedef struct {
+  int id;
+} packet_t;
+using Handle = app::Config;
+
+// UE-macro shapes — every one below is recovered by the hoisted preParse
+// (export macro, reflection markup, inline specifier, API member prefix).
+class MYMODULE_API Widget : public app::Config {
+public:
+  UPROPERTY(EditAnywhere, Category = "State")
+  float Health;
+  FORCEINLINE float GetHealth() const { return Health; }
+  ENGINE_API virtual void Tick(float Delta);
+};
+
+void Widget::Tick(float Delta) { Health += Delta; }
+
+Config GlobalConfig;
+int build_number = 7;
+
+template <typename T>
+T compute_seed(T v) {
+  return v + 1;
+}
+
+float drive_helper(float v) { return v; }
+
+Widget *make_widget() { return new Widget(); }
+
+float drive() {
+  Widget local;
+  app::Config cfg;
+  Vec2 a{1, 2};
+  Vec2 b(a);
+  Vec2 c2(1.5f, 2.5f);
+  float f = a.x + b.y + c2.x;
+  make_widget()->Tick(0.5f);
+  auto kernel = &compute_seed<float>;
+  if (f > 1) {
+    kernel = &drive_helper;
+  }
+  float r = kernel(f);
+  int flags = GlobalConfig.retries;
+  Mode m = Mode::Off;
+  int leg = LEGACY_A;
+  app::detail_probe();
+  compute_seed<int>(2);
+  auto mp = &app::Config::apply;
+  (void)mp;
+  (void)m;
+  return r + f + flags + leg;
+}