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.

690 KB
Raw Blame
/*
 * test_extraction.c — Regression tests for the extraction module.
 *
 * Port of internal/cbm/regression_test.go (1282 LOC, ~80 test cases).
 * Exercises cbm_extract_file() on code snippets across 30+ languages,
 * verifying definitions, calls, and imports are correctly extracted.
 */
#include "test_framework.h"
#include "cbm.h"
#include "foundation/platform.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 <stdint.h>
#include <time.h>
#include "macro_table.h"
#include "result_spill.h"
#include "pipeline/pass_lsp_cross.h"
#include "iris_export_xml.h"
#include "helpers.h"    /* cbm_count_branching (walker stack cap) */
#include "lang_specs.h" /* cbm_lang_spec, cbm_ts_language */

/* Deep-nesting probes: extraction on a worker-sized stack, crash-isolated. */
#include "pipeline/worker_pool.h"            /* CBM_WORKER_STACK_SIZE */
#include "../src/foundation/compat_thread.h" /* cbm_thread_create */
#if !defined(_WIN32)
#include <sys/wait.h> /* fork/waitpid */
#endif

/* ── Helpers ───────────────────────────────────────────────────── */

/* Check if any definition with the given label has the given name. */
static int has_def(CBMFileResult *r, const char *label, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, label) == 0 && strcmp(r->defs.items[i].name, name) == 0)
            return 1;
    }
    return 0;
}

/* Check if any definition has the given name (any label). */
static int has_def_any(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0)
            return 1;
    }
    return 0;
}

/* Check if any call to the given callee exists. */
static int has_call(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, callee) != NULL)
            return 1;
    }
    return 0;
}

/* Check if any import with the given module path exists. */
static int __attribute__((unused)) has_import(CBMFileResult *r, const char *path_substr) {
    for (int i = 0; i < r->imports.count; i++) {
        if (r->imports.items[i].module_path &&
            strstr(r->imports.items[i].module_path, path_substr) != NULL)
            return 1;
    }
    return 0;
}

/* Count definitions with a given label. */
/* Check for a definition with the given qualified name. Distinct from
 * find_def_by_name, which returns the first match by NAME and so cannot tell two
 * same-named definitions in different scopes apart — exactly the case that
 * attrpath qualification exists to separate. */
static int has_def_qn(CBMFileResult *r, const char *qn) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].qualified_name && strcmp(r->defs.items[i].qualified_name, qn) == 0)
            return 1;
    }
    return 0;
}

/* Find a definition by its qualified name relative to the file's module QN
 * (e.g. "Box.init" resolves to "<module_qn>.Box.init"). */
static const CBMDefinition *find_def_in_module(CBMFileResult *r, const char *rel_qn) {
    char qn[512];
    snprintf(qn, sizeof(qn), "%s.%s", r->module_qn, rel_qn);
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].qualified_name && strcmp(r->defs.items[i].qualified_name, qn) == 0)
            return &r->defs.items[i];
    }
    return NULL;
}

/* Find an in-body call by its raw callee text; returns the call or NULL. */
static const CBMCall *find_call_by_callee(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0) {
            return &r->calls.items[i];
        }
    }
    return NULL;
}

static int count_defs_with_label(CBMFileResult *r, const char *label) {
    int count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, label) == 0)
            count++;
    }
    return count;
}

static int count_defs_named(CBMFileResult *r, const char *label, const char *name) {
    int count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, label) == 0 &&
            strcmp(r->defs.items[i].name, name) == 0) {
            count++;
        }
    }
    return count;
}

/* Count calls to `callee` whose enclosing scope is exactly `scope_qn`. A call the
 * scope walk failed to place carries the FILE or module QN here, so a bare count
 * of the callee passes just as happily with every call homed on the file. */
static int count_calls_from(CBMFileResult *r, const char *callee, const char *scope_qn) {
    int count = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && r->calls.items[i].enclosing_func_qn &&
            strcmp(r->calls.items[i].callee_name, callee) == 0 &&
            strcmp(r->calls.items[i].enclosing_func_qn, scope_qn) == 0) {
            count++;
        }
    }
    return count;
}

/* Count usages of `ref` attributed to exactly `scope_qn`, and to any scope. A
 * def head is a BINDING, not a usage, so the pair separates two different
 * mistakes: too few rows means a read was swallowed by the binding, too many
 * means a binding site was counted as a read. */
static int count_usages_from(CBMFileResult *r, const char *ref, const char *scope_qn) {
    int count = 0;
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && r->usages.items[i].enclosing_func_qn &&
            strcmp(r->usages.items[i].ref_name, ref) == 0 &&
            strcmp(r->usages.items[i].enclosing_func_qn, scope_qn) == 0) {
            count++;
        }
    }
    return count;
}

static int count_usages_named(CBMFileResult *r, const char *ref) {
    int count = 0;
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && strcmp(r->usages.items[i].ref_name, ref) == 0) {
            count++;
        }
    }
    return count;
}

static int count_calls_named(CBMFileResult *r, const char *callee) {
    int count = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0) {
            count++;
        }
    }
    return count;
}

/* Convenience: extract, assert no error, return result. Caller frees. */
static CBMFileResult *extract(const char *src, CBMLanguage lang, const char *proj,
                              const char *path) {
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src), lang, proj, path, 0, NULL, NULL);
    return r;
}

/* As extract(), but threads an ObjectScript macro table through. */
static CBMFileResult *extract_with_macros(const char *src, CBMLanguage lang, const char *proj,
                                          const char *path, const CBMMacroTable *mt) {
    CBMFileResult *r =
        cbm_extract_file_ex(src, (int)strlen(src), lang, proj, path, 0, NULL, NULL, mt, NULL);
    return r;
}

/* ═══════════════════════════════════════════════════════════════════
 * Group A: OOP Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- R: box::use imports (#218) + module$fn calls (#219) --- */
TEST(extract_r_box_use_imports_issue218) {
    CBMFileResult *r = extract("box::use(\n"
                               "  shiny[moduleServer, NS],\n"
                               "  app/logic/validation[validate_input],\n"
                               ")\n"
                               "library(dplyr)\n"
                               "source(\"helpers.R\")\n",
                               CBM_LANG_R, "t", "app.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* box::use specs → one IMPORTS edge per module (symbol list stripped). */
    ASSERT(has_import(r, "shiny"));
    ASSERT(has_import(r, "app/logic/validation"));
    /* base-R imports work too. */
    ASSERT(has_import(r, "dplyr"));
    ASSERT(has_import(r, "helpers"));
    cbm_free_result(r);
    PASS();
}

TEST(extract_r_dollar_call_issue219) {
    CBMFileResult *r = extract("validation$validate_input(x)\n", CBM_LANG_R, "t", "app.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* module$fn() now produces a CALLS edge (was silently dropped). */
    ASSERT(has_call(r, "validation.validate_input"));
    cbm_free_result(r);
    PASS();
}

/* --- TS: object-literal arrow methods from a factory (Zustand, #341) --- */
TEST(extract_ts_factory_object_methods_issue341) {
    CBMFileResult *r = extract("export function createItemActions(set, get) {\n"
                               "  return {\n"
                               "    addItem: (type, id) => { return 1; },\n"
                               "    moveItem: (id, target) => { return 2; },\n"
                               "    deleteItem: (id) => { return 3; },\n"
                               "  };\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "item-actions.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The factory itself + each returned arrow method are Function nodes. */
    ASSERT(has_def_any(r, "createItemActions"));
    ASSERT(has_def_any(r, "addItem"));
    ASSERT(has_def_any(r, "moveItem"));
    ASSERT(has_def_any(r, "deleteItem"));
    cbm_free_result(r);
    PASS();
}

/* #2010, split out of #1997: AST traversal stacks were allocated from
 * result->arena, which the parallel pass holds for every file until the whole
 * result cache is freed, so a one-file scratch structure was retained for the
 * length of the index. cbm_extract_channels runs for every file and dispatches
 * TypeScript to extract_channels_js, whose two walks take a 4096-entry TSNode
 * stack each, and the ES import walk takes a 512-entry one:
 * 2 * 4096 * 32 + 512 * 32 = 278528 bytes charged to the arena of a one-line
 * file.
 *
 * The bound is derived, not tuned. Measured on this source, total_alloc was
 * 365984 before the scratch arena and is 87456 after, exactly that difference.
 * #1916 added two pointers to CBMDefinition (240 -> 256 bytes) and the C
 * `variants` list one more (264), so it now measures 88224: 8448 is the defs
 * item array at GROW_ARRAY's starting capacity of 32 times
 * sizeof(CBMDefinition) 264, and the other 79776 is everything else this
 * file's extraction interns; none of it is traversal scratch. So the bound
 * sits above 88224 with room and a factor of four below the 365984 the
 * scratch stacks cost.
 *
 * It is a byte budget, not a proof of lifetime; that is
 * extract_traversal_stacks_come_from_ctx_scratch_issue2010 in test_mem.c. */
TEST(traversal_stack_not_in_result_arena_issue2010) {
    CBMFileResult *r = extract("export const x = 1;\n", CBM_LANG_TYPESCRIPT, "t", "a.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_TRUE(has_def_any(r, "x"));
    /* Read the field rather than cbm_arena_total(): this file sees
     * internal/cbm/arena.h, which declares a subset of the API. test_mem.c
     * includes foundation/arena.h ahead of cbm.h and can call the accessor. */
    ASSERT_LT(r->arena.total_alloc, (size_t)CBM_SZ_128 * CBM_SZ_1K);
    cbm_free_result(r);
    PASS();
}

/* Not a scratch test. The C and C++ preprocessed second pass builds its own
 * extraction context (pp_ctx in cbm_extract_file_ex), and that context carries
 * ctx->scratch so every context in the file is uniform, but nothing reads it
 * there: pp_ctx reaches only cbm_extract_unified and cbm_run_c_lsp, and neither
 * extract_unified.c nor anything under internal/cbm/lsp/ includes
 * extract_node_stack.h, so no traversal stack is built on that path today.
 * This guards the macro-expansion path itself, which had no assertion on a call
 * that exists only after expansion. */
TEST(extract_c_macro_hidden_call_survives_preprocessed_pass_issue2010) {
    CBMFileResult *r = extract("void target(void) {}\n"
                               "#define INVOKE() target()\n"
                               "void caller(void) { INVOKE(); }\n",
                               CBM_LANG_C, "t", "macro_call.c");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(has_call(r, "target"));
    cbm_free_result(r);
    PASS();
}

/* --- C/C++ preprocessor macros become Macro nodes (#375) --- */
TEST(extract_c_macros_issue375) {
    CBMFileResult *r = extract("#define SIMPLE_MACRO 1\n"
                               "#define FN_MACRO(x) (2 * (x))\n"
                               "#define EMPTY_MACRO\n"
                               "int main(void) { return FN_MACRO(SIMPLE_MACRO); }\n",
                               CBM_LANG_C, "p", "macros.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Macro", "SIMPLE_MACRO"));
    ASSERT(has_def(r, "Macro", "FN_MACRO"));
    ASSERT(has_def(r, "Macro", "EMPTY_MACRO"));
    ASSERT(has_def(r, "Function", "main")); /* macros don't displace function defs */
    cbm_free_result(r);
    PASS();
}

TEST(extract_cpp_inc_linkage_and_callback) {
    CBMFileResult *r =
        extract("#define SAMPLE_CALLBACK(type) type\n"
                "extern \"C\" __declspec(dllexport) int sample_export() { return 0; }\n"
                "static SAMPLE_CALLBACK(int) sample_callback() { return sample_export(); }\n",
                CBM_LANG_CPP, "sample", "runtime/sample.inc");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(has_def(r, "Function", "sample_export"));
    ASSERT_TRUE(has_def(r, "Function", "sample_callback"));
    ASSERT_FALSE(has_def_any(r, "extern"));
    cbm_free_result(r);

    /* A statement include has no enclosing function in the file. Keep any
     * syntax coverage diagnostic rather than inventing a callable owner. */
    r = extract("#ifdef ENABLE_SAMPLE\nif (sample_check()) return 1;\n#endif\n", CBM_LANG_CPP,
                "sample", "runtime/guard.inc");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(has_def_any(r, "extern"));
    ASSERT_FALSE(has_def(r, "Function", "if"));
    cbm_free_result(r);
    PASS();
}

TEST(extract_cpp_macros_issue375) {
    CBMFileResult *r = extract("#define MAX(a, b) ((a) > (b) ? (a) : (b))\n"
                               "#define PI 3.14159\n"
                               "namespace n {\n"
                               "int f() { return MAX(1, 2); }\n"
                               "}\n",
                               CBM_LANG_CPP, "p", "macros.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Macro", "MAX"));
    ASSERT(has_def(r, "Macro", "PI"));
    cbm_free_result(r);
    PASS();
}

/* #1071: a function-like macro invocation whose argument is a TYPE token
 * (SYNTH_ALLOC_ARRAY(char, n)) makes tree-sitter's C++ grammar emit an ERROR
 * node — it parses `char` in expression position — which cbm_collect_error_regions
 * records as a `parse_partial` coverage gap, even though the file is a valid,
 * in-file macro use with nothing actually missing from the graph. */
TEST(extract_cpp_functionlike_macro_type_arg_no_false_parse_partial_issue1071) {
    CBMFileResult *r = extract("#include <cstddef>\n"
                               "#include <cstdlib>\n"
                               "\n"
                               "#define SYNTH_ALLOC_ARRAY(Type, Count) \\\n"
                               "  ((Type*)std::malloc(sizeof(Type) * (Count)))\n"
                               "\n"
                               "struct Buffer {\n"
                               "  char* data;\n"
                               "  std::size_t size;\n"
                               "};\n"
                               "\n"
                               "Buffer make_buffer(std::size_t n) {\n"
                               "  Buffer b;\n"
                               "  b.data = SYNTH_ALLOC_ARRAY(char, n);\n"
                               "  b.size = n;\n"
                               "  return b;\n"
                               "}\n",
                               CBM_LANG_CPP, "t", "alloc.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->parse_incomplete); /* benign in-body macro call — not a coverage gap */
    ASSERT(has_def(r, "Function", "make_buffer"));
    ASSERT(has_def(r, "Macro", "SYNTH_ALLOC_ARRAY"));
    cbm_free_result(r);
    PASS();
}

/* #1071 guard: the suppression must be tight. A REAL parse error inside a
 * function (not a macro call) must STILL be flagged, and a top-level macro
 * invocation is covered by extract_cpp_preproc_macro_generated_callable_skipped_issue949. */
TEST(extract_cpp_real_in_body_error_still_flagged_issue1071) {
    /* `int x = ;` is a genuine syntax error inside foo()'s body — no macro
     * involved, so the coverage gap must not be suppressed. */
    CBMFileResult *r = extract("int foo() {\n"
                               "  int x = ;\n"
                               "  return x;\n"
                               "}\n",
                               CBM_LANG_CPP, "t", "broken.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(r->parse_incomplete); /* real gap stays reported */
    cbm_free_result(r);
    PASS();
}

/* #1735: the #1071 check's cost. cbm_subtract_macro_invocation_regions asked
 * "is this region a macro call?" before "is it inside a function?", and the
 * first question walked the source from byte 0 for every region: regions x
 * file bytes on any file with many error regions, whatever its language.
 * Counted (test seam), never timed. */
enum { MACRO_SCAN_SRC_CAP = 8192 };

TEST(macro_check_reads_no_source_for_regions_outside_functions_issue1735) {
    /* 40 functions, each followed by a top-level junk line: 40 regions, none
     * of them inside a function. */
    char src[MACRO_SCAN_SRC_CAP];
    int len = snprintf(src, sizeof(src), "#define ALLOC(T, n) ((T *)malloc(sizeof(T) * (n)))\n");
    for (int i = 0; i < 40; i++) {
        len += snprintf(src + len, sizeof(src) - (size_t)len,
                        "int ok%d(void) {\n    return %d;\n}\n} ] junk ( {\n", i, i);
    }
    ASSERT_LT(len, MACRO_SCAN_SRC_CAP);
    uint64_t before = cbm_test_macro_line_scan_bytes();
    CBMFileResult *r = extract(src, CBM_LANG_C, "t", "junk.c");
    uint64_t scanned = cbm_test_macro_line_scan_bytes() - before;
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(r->parse_incomplete);     /* top-level junk stays reported... */
    ASSERT_EQ(r->error_region_count, 40); /* ...one range per junk line, as before */
    ASSERT_EQ(scanned, 0u);
    cbm_free_result(r);
    PASS();
}

TEST(macro_check_locates_lines_with_one_table_issue1735) {
    /* 60 functions whose bodies hold a real syntax error: every region sits
     * inside a function, so the check has to look at each one's lines. */
    char src[MACRO_SCAN_SRC_CAP];
    int len = snprintf(src, sizeof(src), "#define ALLOC(T, n) ((T *)malloc(sizeof(T) * (n)))\n");
    for (int i = 0; i < 60; i++) {
        len += snprintf(src + len, sizeof(src) - (size_t)len,
                        "int f%d(void) {\n    int x = ;\n    return x;\n}\n", i);
    }
    ASSERT_LT(len, MACRO_SCAN_SRC_CAP);
    uint64_t before = cbm_test_macro_line_scan_bytes();
    CBMFileResult *r = extract(src, CBM_LANG_C, "t", "inbody.c");
    uint64_t scanned = cbm_test_macro_line_scan_bytes() - before;
    ASSERT_NOT_NULL(r);
    /* #1071 unchanged: a real in-body error is not a macro call and stays
     * reported, one range per function. */
    ASSERT_TRUE(r->parse_incomplete);
    ASSERT_EQ(r->error_region_count, 60);
    /* One line table for the file, not one walk per region. */
    ASSERT_LTE(scanned, (uint64_t)len);
    cbm_free_result(r);
    PASS();
}

/* --- GDScript: AST -> graph visitor (Godot, #186) --- */
TEST(extract_gdscript_issue186) {
    CBMFileResult *r = extract("extends Node\n"
                               "class_name Player\n"
                               "\n"
                               "var health = 100\n"
                               "\n"
                               "func _ready():\n"
                               "    take_damage(10)\n"
                               "\n"
                               "func take_damage(amount):\n"
                               "    health -= amount\n"
                               "\n"
                               "class Inner:\n"
                               "    func helper():\n"
                               "        pass\n",
                               CBM_LANG_GDSCRIPT, "game", "player.gd");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "_ready"));
    ASSERT(has_def(r, "Function", "take_damage"));
    ASSERT(has_def(r, "Class", "Inner"));
    ASSERT(has_call(r, "take_damage"));
    cbm_free_result(r);
    PASS();
}

/* --- PowerShell: AST -> graph visitor (#35) --- */
TEST(extract_powershell_issue35) {
    CBMFileResult *r = extract("function Get-Greeting {\n"
                               "    param($Name)\n"
                               "    Write-Output \"Hello $Name\"\n"
                               "}\n"
                               "\n"
                               "function Set-Config {\n"
                               "    Get-Greeting -Name 'World'\n"
                               "}\n",
                               CBM_LANG_POWERSHELL, "ops", "greet.ps1");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    cbm_free_result(r);
    PASS();
}

/* --- Luau: AST -> graph visitor (Roblox, #39) --- */
TEST(extract_luau_issue39) {
    CBMFileResult *r = extract("local function add(a, b)\n"
                               "    return a + b\n"
                               "end\n"
                               "\n"
                               "function multiply(a, b)\n"
                               "    return add(a, a) * b\n"
                               "end\n",
                               CBM_LANG_LUAU, "game", "math.luau");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    cbm_free_result(r);
    PASS();
}

/* --- QML: AST -> graph visitor (Qt, #42) --- */
TEST(extract_qml_issue42) {
    CBMFileResult *r = extract("import QtQuick 2.15\n"
                               "\n"
                               "Rectangle {\n"
                               "    id: root\n"
                               "    width: 100\n"
                               "    property int counter: 0\n"
                               "    signal clicked(int value)\n"
                               "\n"
                               "    function increment() {\n"
                               "        counter += 1\n"
                               "        compute(counter)\n"
                               "    }\n"
                               "\n"
                               "    function compute(n) {\n"
                               "        return n * 2\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_QML, "app", "Main.qml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "increment"));
    ASSERT(has_def(r, "Function", "compute"));
    ASSERT(has_call(r, "compute"));
    cbm_free_result(r);
    PASS();
}

/* --- CFML script dialect: .cfc components (Lucee/ColdFusion, #38) --- */
TEST(extract_cfscript_issue38) {
    CBMFileResult *r = extract("component {\n"
                               "    public function getUser(numeric id) {\n"
                               "        return loadUser(id);\n"
                               "    }\n"
                               "    function loadUser(id) {\n"
                               "        return id * 2;\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_CFSCRIPT, "app", "User.cfc");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    ASSERT(has_def(r, "Function", "getUser"));
    ASSERT(has_def(r, "Function", "loadUser"));
    ASSERT(has_call(r, "loadUser"));
    cbm_free_result(r);
    PASS();
}

/* --- CFML tag dialect: .cfm templates with <cffunction> (#38) --- */
TEST(extract_cfml_tag_issue38) {
    CBMFileResult *r = extract("<cffunction name=\"greet\" returntype=\"string\">\n"
                               "    <cfargument name=\"who\" type=\"string\">\n"
                               "    <cfreturn \"Hello \" & arguments.who>\n"
                               "</cffunction>\n",
                               CBM_LANG_CFML, "app", "index.cfm");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- CFML tag dialect: script functions inside a <cfscript> block of a tag
 * component. The HTML-derived cfml grammar keeps the <cfscript> body as an
 * opaque cf_script_content token, so these functions only surface once the
 * block is re-parsed with the cfscript grammar through the shared
 * included-ranges machinery (parse_one_embedded_block, #1852).
 * Also asserts the block-relative line numbers are remapped back to host-file
 * lines, and that a leading <cfsetting> void tag (which cascades ERROR nodes in
 * the cfml grammar) does not prevent recovery of the functions. --- */
TEST(extract_cfml_embedded_cfscript_defs) {
    /* Source layout (1-based lines): 1 <cfcomponent>, 2 <cfsetting>, 3 <cfscript>,
     * 4 greet(), 7 addTwo(), 10 </cfscript>, 11 <cffunction tagPing>, 14 close. */
    CBMFileResult *r = extract("<cfcomponent>\n"
                               "<cfsetting requesttimeout=\"10\">\n"
                               "<cfscript>\n"
                               "    public string function greet(string who) {\n"
                               "        return \"hi \" & who;\n"
                               "    }\n"
                               "    private numeric function addTwo(numeric a) {\n"
                               "        return a + 2;\n"
                               "    }\n"
                               "</cfscript>\n"
                               "<cffunction name=\"tagPing\" returntype=\"string\">\n"
                               "    <cfreturn \"pong\">\n"
                               "</cffunction>\n"
                               "</cfcomponent>\n",
                               CBM_LANG_CFML, "app", "Service.cfc");
    ASSERT_NOT_NULL(r);
    /* Script functions inside <cfscript> are recovered ... */
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "addTwo"));
    /* ... alongside the tag-dialect <cffunction> in the same component. */
    ASSERT(has_def(r, "Function", "tagPing"));
    /* Line numbers are remapped from block-relative back to host-file lines. */
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (strcmp(d->label, "Function") == 0 && strcmp(d->name, "greet") == 0) {
            ASSERT(d->start_line == 4);
        }
        if (strcmp(d->label, "Function") == 0 && strcmp(d->name, "addTwo") == 0) {
            ASSERT(d->start_line == 7);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* --- Helm / Go template: named templates + include calls (#338) --- */
TEST(extract_helm_templates_issue338) {
    CBMFileResult *r = extract("{{- define \"chart.fullname\" -}}\n"
                               "{{- .Release.Name -}}\n"
                               "{{- end -}}\n"
                               "\n"
                               "{{- define \"chart.labels\" -}}\n"
                               "app: {{ include \"chart.fullname\" . }}\n"
                               "chart: {{ template \"chart.fullname\" . }}\n"
                               "{{- end -}}\n",
                               CBM_LANG_GOTEMPLATE, "chart", "templates/_helpers.tpl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* define -> Function nodes */
    ASSERT(has_def(r, "Function", "chart.fullname"));
    ASSERT(has_def(r, "Function", "chart.labels"));
    /* include / template -> CALLS to the named template (not to "include") */
    ASSERT(has_call(r, "chart.fullname"));
    cbm_free_result(r);
    PASS();
}

/* --- Helm values.yaml: top-level keys only, no leaf flood (#338) --- */
TEST(extract_helm_values_toplevel_issue338) {
    CBMFileResult *r = extract("image:\n"
                               "  repository: nginx\n"
                               "  tag: latest\n"
                               "replicaCount: 3\n"
                               "service:\n"
                               "  port: 80\n",
                               CBM_LANG_YAML, "chart", "values.yaml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "image"));
    ASSERT(has_def(r, "Variable", "replicaCount"));
    ASSERT(has_def(r, "Variable", "service"));
    /* Nested leaf keys must NOT explode into separate nodes. */
    ASSERT(!has_def(r, "Variable", "repository"));
    ASSERT(!has_def(r, "Variable", "tag"));
    ASSERT(!has_def(r, "Variable", "port"));
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

/* --- Java --- */
TEST(java_class) {
    CBMFileResult *r = extract(
        "public class Animal { private String name; public String getName() { return name; } }",
        CBM_LANG_JAVA, "t", "Animal.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    cbm_free_result(r);
    PASS();
}

/* A class field is one Field. Java, C# and Solidity list the field
 * declaration as a variable kind too, and the class-body variable pass minted
 * a second node: a Variable with the module's qualified name (Query.filters
 * became `demo.query.filters`, the name of a package a documentation code
 * span then bound). Languages whose class variables are no Field keep them. */
TEST(class_field_is_one_field_not_also_a_variable) {
    CBMFileResult *r = extract("package demo.query;\npublic class Query {\n"
                               "    private Object filters;\n"
                               "    private static final String PROP = \"v\";\n}\n",
                               CBM_LANG_JAVA, "t", "Query.java");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Field", "filters"), 1);
    ASSERT_EQ(count_defs_named(r, "Variable", "filters"), 0);
    /* an initialized field is named by its declarator's name, not its text
     * (`PROP = "v"` was the Field's name, so only the duplicate was findable) */
    ASSERT_EQ(count_defs_named(r, "Field", "PROP"), 1);
    ASSERT_EQ(count_defs_named(r, "Variable", "PROP"), 0);
    cbm_free_result(r);
    r = extract("namespace Demo {\n  public class Q {\n    private int count;\n  }\n}\n",
                CBM_LANG_CSHARP, "t", "Q.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Field", "count"), 1);
    ASSERT_EQ(count_defs_named(r, "Variable", "count"), 0);
    cbm_free_result(r);
    r = extract("pragma solidity ^0.8.0;\ncontract Q {\n    uint256 public total;\n}\n",
                CBM_LANG_SOLIDITY, "t", "Q.sol");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Field", "total"), 1);
    ASSERT_EQ(count_defs_named(r, "Variable", "total"), 0);
    cbm_free_result(r);
    /* no Field for these: their class variables stay */
    r = extract("class Q {\n    var count: Int = 0\n}\n", CBM_LANG_SWIFT, "t", "Q.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Variable", "count"), 1);
    cbm_free_result(r);
    r = extract("extends Node\nclass Inner:\n    var x = 1\n", CBM_LANG_GDSCRIPT, "t", "q.gd");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Variable", "x"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(java_method) {
    CBMFileResult *r = extract(
        "public class Svc { public void doWork() {} public int compute(int x) { return x; } }",
        CBM_LANG_JAVA, "t", "Svc.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "doWork"));
    ASSERT(has_def(r, "Method", "compute"));
    cbm_free_result(r);
    PASS();
}

TEST(java_interface) {
    CBMFileResult *r =
        extract("public interface Repository { void save(Object o); Object findById(long id); }",
                CBM_LANG_JAVA, "t", "Repo.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Repository"));
    cbm_free_result(r);
    PASS();
}

/* Regression for #1234: Java interface/enum methods were emitted as both a
 * Method node (correct, via extract_class_methods) and a duplicate Function
 * node (incorrect, via walk_defs). Prevention in push_class_body_children
 * (gated to Java) recognizes interface_body and enum_body as class body
 * containers, stopping the fallback path from re-walking method_declaration
 * children as top-level functions. */
TEST(java_interface_no_duplicate_function_issue1234) {
    CBMFileResult *r =
        extract("public interface MarketplaceService {\n"
                "    ReservationDTO createReservation(Authentication auth, RequestDTO req);\n"
                "    void cancelReservation(long id);\n"
                "}\n",
                CBM_LANG_JAVA, "t", "MarketplaceService.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT(has_def(r, "Interface", "MarketplaceService"));
    ASSERT(has_def(r, "Method", "createReservation"));
    ASSERT(has_def(r, "Method", "cancelReservation"));
    ASSERT_EQ(count_defs_with_label(r, "Function"), 0);

    cbm_free_result(r);
    PASS();
}

TEST(java_enum_dedup_preserves_calls_issue1234) {
    CBMFileResult *r =
        extract("package app;\n\nenum Day {\n"
                "    MON, TUE, WED, THU, FRI, SAT, SUN;\n\n"
                "    public boolean isWeekend() { return this == SAT || this == SUN; }\n"
                "    public String label() { return name().toLowerCase(); }\n}\n\n"
                "class DayUtil {\n"
                "    static String describe(Day d) {\n"
                "        return d.label() + (d.isWeekend() ? \"(rest)\" : \"(work)\");\n    }\n}\n",
                CBM_LANG_JAVA, "t", "Day.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT(has_def(r, "Enum", "Day"));
    ASSERT(has_def(r, "Method", "isWeekend"));
    ASSERT(has_def(r, "Method", "label"));
    /* The enum CONSTANTS must survive alongside the methods. Reaching the
     * methods means descending into enum_body_declarations, and the tempting
     * way to do that -- redirecting the shared find_class_body -- also makes
     * the constants unreachable, because they are siblings of that node rather
     * than children. find_class_member_body exists to descend for members only
     * and leave find_class_body (which extract_enum_members uses) alone; these
     * two assertions are what stop that distinction being collapsed again. */
    ASSERT(has_def(r, "Variable", "MON"));
    ASSERT(has_def(r, "Variable", "SUN"));
    ASSERT(has_def(r, "Class", "DayUtil"));
    ASSERT(has_def(r, "Method", "describe"));
    ASSERT_EQ(count_defs_with_label(r, "Function"), 0);

    cbm_free_result(r);
    PASS();
}

/* Regression for #279: a Java class declaring both `extends` and
 * `implements` must produce one INHERITS edge per base — the extends parent
 * AND every implements interface — with bare type names (not the keyword
 * text "extends Bar" / "implements Baz, Qux"). Before the fix:
 *   1) the field loop returned on the first match → only the superclass
 *      was emitted, the interfaces were dropped.
 *   2) the emitted name was the full field text including the keyword. */
TEST(java_class_extends_and_implements) {
    CBMFileResult *r = extract("public class DefaultLinkTool extends DefaultDiagramTool implements "
                               "ILinkTool, Closeable { }",
                               CBM_LANG_JAVA, "t", "DefaultLinkTool.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Find the class def and inspect its base_classes list. */
    CBMDefinition *cls = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Class") == 0 &&
            strcmp(r->defs.items[i].name, "DefaultLinkTool") == 0) {
            cls = &r->defs.items[i];
            break;
        }
    }
    ASSERT_NOT_NULL(cls);
    ASSERT_NOT_NULL(cls->base_classes);

    bool saw_super = false;
    bool saw_iface_a = false;
    bool saw_iface_b = false;
    for (const char **b = cls->base_classes; *b; b++) {
        /* The keyword-text bug would surface as "extends ..." or
         * "implements ..." literally inside one of the entries. */
        ASSERT_NULL(strstr(*b, "extends"));
        ASSERT_NULL(strstr(*b, "implements"));
        if (strcmp(*b, "DefaultDiagramTool") == 0)
            saw_super = true;
        if (strcmp(*b, "ILinkTool") == 0)
            saw_iface_a = true;
        if (strcmp(*b, "Closeable") == 0)
            saw_iface_b = true;
    }
    ASSERT_TRUE(saw_super);
    ASSERT_TRUE(saw_iface_a);
    ASSERT_TRUE(saw_iface_b);

    cbm_free_result(r);
    PASS();
}

/* REPRODUCTION (RED until fixed) — Python `class Animal(Base):` must extract the
 * BARE base name "Base", but extract_base_classes captures the whole
 * `superclasses` argument_list text "(Base)" instead: collect_bases_from_field
 * (internal/cbm/extract_defs.c) matches only type_identifier / generic_type /
 * qualified_name / scoped_type_identifier / user_type, while tree-sitter-python
 * uses a plain `identifier` node for the base — so no child matches and the
 * raw-field fallback grabs the argument_list text "(Base)" (parens included).
 * DOWNSTREAM SYMPTOM: that malformed name never resolves to the Base class node,
 * so EVERY Python subclass yields ZERO INHERITS edges (observed in the P6
 * graph-contract suite). Fix: have collect_bases_from_field accept `identifier`
 * (or strip the argument_list parens). This test stays RED as the regression
 * guard / reproduction until the fix lands — see CLAUDE.md "Bug Fixing —
 * Reproduce-First". */
TEST(python_class_base_extracted_bare) {
    CBMFileResult *r = extract("class Base:\n    pass\n\n\nclass Animal(Base):\n    pass\n",
                               CBM_LANG_PYTHON, "t", "models.py");
    ASSERT_NOT_NULL(r);

    CBMDefinition *cls = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].label && strcmp(r->defs.items[i].label, "Class") == 0 &&
            r->defs.items[i].name && strcmp(r->defs.items[i].name, "Animal") == 0) {
            cls = &r->defs.items[i];
            break;
        }
    }
    ASSERT_NOT_NULL(cls);
    ASSERT_NOT_NULL(cls->base_classes); /* a subclass must record at least one base */

    bool saw_bare_base = false;
    for (const char **b = cls->base_classes; *b; b++) {
        if (strcmp(*b, "Base") == 0) {
            saw_bare_base = true;
        }
    }
    /* CURRENTLY FAILS: base_classes holds "(Base)" (argument_list text), not the
     * bare "Base" needed for INHERITS resolution. */
    ASSERT_TRUE(saw_bare_base);

    cbm_free_result(r);
    PASS();
}

/* --- PHP --- */
TEST(php_class) {
    CBMFileResult *r = extract("<?php\nclass User { public string $name; public function "
                               "getName(): string { return $this->name; } }",
                               CBM_LANG_PHP, "t", "User.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "User"));
    ASSERT(has_def(r, "Method", "getName"));
    cbm_free_result(r);
    PASS();
}

TEST(php_function) {
    CBMFileResult *r =
        extract("<?php\nfunction greet(string $name): string { return 'Hello ' . $name; }",
                CBM_LANG_PHP, "t", "helpers.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* #2000: inline HTML between `?>` and `<?php` is valid PHP, but the php_only
 * grammar has no rule for it, so everything after the first `?>` fell into an
 * ERROR region and never reached the graph. */
static const CBMCall *find_call_named(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0)
            return &r->calls.items[i];
    }
    return NULL;
}

static int php_def_line(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0)
            return (int)r->defs.items[i].start_line;
    }
    return -1;
}

TEST(php_inline_html_tail_reaches_graph_issue2000) {
    CBMFileResult *r = extract("<?php\n"
                               "function gamma() { return 2; }\n"
                               "?>\n"
                               "<div class=\"box\">\n"
                               "  <p>plain markup after the closing tag</p>\n"
                               "</div>\n"
                               "<?php\n"
                               "function delta() { return gamma(); }\n",
                               CBM_LANG_PHP, "t", "inline_html.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "gamma"));
    ASSERT(has_def(r, "Function", "delta"));
    /* Lines are in original-file coordinates. */
    ASSERT_EQ(php_def_line(r, "gamma"), 2);
    ASSERT_EQ(php_def_line(r, "delta"), 8);
    const CBMCall *c = find_call_named(r, "gamma");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(strstr(c->enclosing_func_qn, "delta"));
    ASSERT_FALSE(r->parse_incomplete);
    cbm_free_result(r);
    PASS();
}

/* View-file shapes: echo tags keep their calls, and control structures that
 * are opened in one PHP block and closed in a later one still parse. */
TEST(php_inline_html_template_shapes_issue2000) {
    CBMFileResult *r = extract("<!DOCTYPE html>\n"
                               "<html><head><title><?= page_title($page) ?></title></head>\n"
                               "<body>\n"
                               "<?php if ($user): ?>\n"
                               "  <p>Hello <?=$user->name?></p>\n"
                               "<?php else: ?>\n"
                               "  <a href=\"/login\">log in</a>\n"
                               "<?php endif; ?>\n"
                               "<?php foreach ($items as $item) { ?>\n"
                               "  <li><?php echo render_item($item); ?></li>\n"
                               "<?php } ?>\n"
                               "<?php function footer_links() { return nav_links(); } ?>\n"
                               "</body></html>\n",
                               CBM_LANG_PHP, "t", "view.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "page_title"));
    ASSERT(has_call(r, "render_item"));
    ASSERT(has_def(r, "Function", "footer_links"));
    ASSERT_EQ(php_def_line(r, "footer_links"), 12);
    ASSERT(has_call(r, "nav_links"));
    ASSERT_FALSE(r->parse_incomplete);
    cbm_free_result(r);
    PASS();
}

/* `?>` only leaves PHP mode from code or a one-line comment. Inside strings,
 * heredoc, nowdoc and block comments it is text; `#[` is an attribute, not a
 * comment; `<?xml` in markup is not an open tag. */
TEST(php_inline_html_close_tag_in_literals_issue2000) {
    CBMFileResult *r = extract("<?php\n"
                               "$a = 'single ?> quoted';\n"
                               "$b = \"double ?> quoted \\\" still\";\n"
                               "$c = <<<EOT\n"
                               "  heredoc ?> body\n"
                               "  EOT;\n"
                               "$d = <<<'NOW'\n"
                               "nowdoc ?> body\n"
                               "NOW;\n"
                               "/* block ?> comment */\n"
                               "#[Pure]\n"
                               "function one() { return 1; }\n"
                               "// line comment ends here ?>\n"
                               "<?xml version=\"1.0\"?><note/>\n"
                               "<?php\n"
                               "function two() { return one(); }\n",
                               CBM_LANG_PHP, "t", "literals.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "one"));
    ASSERT(has_def(r, "Function", "two"));
    ASSERT_EQ(php_def_line(r, "two"), 16);
    ASSERT(has_call(r, "one"));
    ASSERT_FALSE(r->parse_incomplete);
    cbm_free_result(r);
    PASS();
}

/* Markup is blanked, never parsed: code-shaped text outside the PHP tags must
 * not produce definitions or calls, wherever it sits. */
TEST(php_inline_html_markup_never_reaches_graph_issue2000) {
    CBMFileResult *r = extract("<p>function before() { return leakBefore(); }</p>\n"
                               "<?php\n"
                               "function real() { return 1; }\n"
                               "?>\n"
                               "<p>function fake() { return leak(); }</p>\n"
                               "<script>function jsFake() { leakScript(); }</script>\n"
                               "<?xml version=\"1.0\"?><x>function xmlFake() { leakXml(); }</x>\n"
                               "<?php\n"
                               "function after() { return real(); }\n"
                               "?>\n"
                               "<p>class Tail { function tailFake() { leakTail(); } }</p>\n",
                               CBM_LANG_PHP, "t", "markup.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "real"));
    ASSERT(has_def(r, "Function", "after"));
    ASSERT(has_call(r, "real"));
    ASSERT_FALSE(has_def_any(r, "before"));
    ASSERT_FALSE(has_def_any(r, "fake"));
    ASSERT_FALSE(has_def_any(r, "jsFake"));
    ASSERT_FALSE(has_def_any(r, "xmlFake"));
    ASSERT_FALSE(has_def_any(r, "Tail"));
    ASSERT_FALSE(has_def_any(r, "tailFake"));
    ASSERT_FALSE(has_call(r, "leak"));
    ASSERT_FALSE(r->parse_incomplete);
    cbm_free_result(r);
    PASS();
}

/* The mask hands back the caller's buffer, uncopied, when nothing needs
 * rewriting, and a same-length rewrite otherwise. The pointer alone cannot
 * tell copy-on-write from an eager copy, so the arena's allocation total is
 * sampled around each call: no bytes for `plain` and `quoted`, a copy for
 * `mixed`. */
TEST(php_inline_html_mask_copies_only_on_write_issue2000) {
    CBMArena arena;
    cbm_arena_init(&arena);
    const char *plain = "<?php\nfunction a() { return 1; }\n";
    const char *quoted = "<?php\n$s = '?>';\n/* ?> */\n$h = <<<EOT\n?>\nEOT;\n";
    const char *mixed = "<?php\nfunction a() {}\n?>\n<b>x</b>\n";

    size_t before = cbm_arena_total(&arena);
    ASSERT(cbm_php_mask_inline_html(&arena, plain, (int)strlen(plain)) == plain);
    ASSERT_EQ(cbm_arena_total(&arena), before);

    before = cbm_arena_total(&arena);
    ASSERT(cbm_php_mask_inline_html(&arena, quoted, (int)strlen(quoted)) == quoted);
    ASSERT_EQ(cbm_arena_total(&arena), before);

    before = cbm_arena_total(&arena);
    const char *masked = cbm_php_mask_inline_html(&arena, mixed, (int)strlen(mixed));
    ASSERT(cbm_arena_total(&arena) > before);
    ASSERT(masked != mixed);
    ASSERT_EQ((int)strlen(masked), (int)strlen(mixed));
    ASSERT_STR_EQ(masked, "<?php\nfunction a() {}\n; \n        \n");
    cbm_arena_destroy(&arena);
    PASS();
}

/* A trailing `?>` (common at the end of older class files) is not a partial
 * parse, and CRLF line endings keep their line numbers. */
TEST(php_inline_html_trailing_close_tag_crlf_issue2000) {
    CBMFileResult *r = extract("<?php\r\n"
                               "class Repo {\r\n"
                               "    public function find($id) { return $id; }\r\n"
                               "}\r\n"
                               "?>\r\n",
                               CBM_LANG_PHP, "t", "Repo.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Repo"));
    ASSERT(has_def(r, "Method", "find"));
    ASSERT_EQ(php_def_line(r, "find"), 3);
    ASSERT_FALSE(r->parse_incomplete);
    cbm_free_result(r);
    PASS();
}

/* --- Ruby --- */
TEST(ruby_class) {
    CBMFileResult *r = extract("class Animal\n  def initialize(name)\n    @name = name\n  end\n  "
                               "def speak\n    puts @name\n  end\nend\n",
                               CBM_LANG_RUBY, "t", "animal.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

TEST(ruby_module) {
    CBMFileResult *r = extract("module Greetable\n  def greet\n    \"Hello\"\n  end\nend\n",
                               CBM_LANG_RUBY, "t", "greetable.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Greetable"));
    cbm_free_result(r);
    PASS();
}

/* A Ruby `Const.new` call is rewritten to name the CONSTANT, not the method:
 * the constructor body lives in `initialize`, so the call should link the class
 * like every other language's `new T()`. The rewrite fired only for bare
 * `constant` receivers, so a scope-resolved receiver kept the whole call text
 * as its callee ("Admin::User.new"), which resolves to nothing and cannot join
 * the Ruby LSP's constructor rows, whose callee is the class QN.
 *
 * Both spellings must land on the bare constant path; a retained ".new" suffix
 * is the bug's signature. */
TEST(ruby_constructor_callee_is_constant_path) {
    CBMFileResult *r = extract("module Admin\n  class User\n  end\nend\n"
                               "class Widget\nend\n"
                               "class Maker\n"
                               "  def build\n"
                               "    Admin::User.new\n"
                               "    Widget.new\n"
                               "  end\n"
                               "end\n",
                               CBM_LANG_RUBY, "t", "maker.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    int scoped = 0, bare = 0, kept_new = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *callee = r->calls.items[i].callee_name;
        if (strcmp(callee, "Admin::User") == 0)
            scoped = 1;
        if (strcmp(callee, "Widget") == 0)
            bare = 1;
        /* Either failure mode: the method name survived on its own, or the
         * whole `Recv.new` expression did. */
        size_t n = strlen(callee);
        if (strcmp(callee, "new") == 0 || (n >= 4 && strcmp(callee + n - 4, ".new") == 0))
            kept_new = 1;
    }
    if (!scoped || !bare || kept_new) {
        printf("  ruby callees (%d):\n", r->calls.count);
        for (int i = 0; i < r->calls.count; i++)
            printf("    '%s'\n", r->calls.items[i].callee_name);
    }
    /* Scope-resolved receiver reduces to the constant path; its bare leaf is
     * what resolution joins on. */
    ASSERT(scoped);
    /* Bare receiver: pre-existing behaviour, guarded against regression. */
    ASSERT(bare);
    ASSERT_FALSE(kept_new);

    cbm_free_result(r);
    PASS();
}

/* --- C# --- */
TEST(csharp_class) {
    CBMFileResult *r = extract("namespace App { public class Service { public void Run() {} public "
                               "int Compute(int x) => x * 2; } }",
                               CBM_LANG_CSHARP, "t", "Service.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Service"));
    ASSERT(has_def(r, "Method", "Run"));
    cbm_free_result(r);
    PASS();
}

TEST(csharp_interface) {
    CBMFileResult *r = extract("public interface IService { void Execute(); string GetStatus(); }",
                               CBM_LANG_CSHARP, "t", "IService.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "IService"));
    cbm_free_result(r);
    PASS();
}

/* Issue #2071: a C# 14 extension block parses as a constructor_declaration
 * named `extension` whose body holds the members, and has_error stays 0, so the
 * members were dropped without any signal. They belong to the enclosing type. */
TEST(csharp_extension_block_members) {
    CBMFileResult *r = extract("namespace App;\n"
                               "public static class NumberExtensions\n"
                               "{\n"
                               "    extension(IEnumerable<int> numbers)\n"
                               "    {\n"
                               "        public int SumPositive() => 0;\n"
                               "        public static int Zero() => 0;\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_CSHARP, "t", "NumberExtensions.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "NumberExtensions"));
    ASSERT(has_def(r, "Method", "SumPositive"));
    ASSERT(has_def(r, "Method", "Zero"));
    ASSERT_FALSE(has_def_any(r, "extension"));
    cbm_free_result(r);
    PASS();
}

/* The same shape is a genuine constructor inside a type actually called
 * `extension`, and must still be emitted (#2071). */
TEST(csharp_constructor_of_type_named_extension) {
    CBMFileResult *r =
        extract("namespace App { public class extension { public extension() { } } }",
                CBM_LANG_CSHARP, "t", "extension.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "extension"));
    cbm_free_result(r);
    PASS();
}

/* Escaping a type identifier does not change its constructor's identity. */
TEST(csharp_constructor_of_escaped_type_named_extension) {
    const char *src = "namespace App { public class @extension { "
                      "public extension() { int ConstructorLocal() => 1; } } }";
    CBMFileResult *r = extract(src, CBM_LANG_CSHARP, "t", "extension.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "extension"));
    ASSERT_FALSE(has_def(r, "Method", "ConstructorLocal"));
    cbm_free_result(r);
    PASS();
}

/* All conditional branches expose extension members, but method-local
 * functions must never be promoted to members of the enclosing type. */
TEST(csharp_extension_block_conditional_members) {
    const char *src = "public static class TextExtensions\n"
                      "{\n"
                      "    extension(string text)\n"
                      "    {\n"
                      "#if FIRST\n"
                      "        public int First() { int Nested() => 1; return Nested(); }\n"
                      "#elif SECOND\n"
                      "        public int Second() => 2;\n"
                      "#else\n"
                      "#if NESTED\n"
                      "        public int Third() => 3;\n"
                      "#else\n"
                      "        public int Fourth() => 4;\n"
                      "#endif\n"
                      "#endif\n"
                      "    }\n"
                      "}\n";
    CBMFileResult *r = extract(src, CBM_LANG_CSHARP, "t", "TextExtensions.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "First"));
    ASSERT(has_def(r, "Method", "Second"));
    ASSERT(has_def(r, "Method", "Third"));
    ASSERT(has_def(r, "Method", "Fourth"));
    ASSERT_FALSE(has_def_any(r, "extension"));
    ASSERT_FALSE(has_def(r, "Method", "Nested"));
    cbm_free_result(r);
    PASS();
}

/* --- Swift --- */
TEST(swift_class) {
    CBMFileResult *r = extract("class Vehicle {\n    var speed: Int = 0\n    func accelerate() { "
                               "speed += 10 }\n    func stop() { speed = 0 }\n}\n",
                               CBM_LANG_SWIFT, "t", "Vehicle.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Vehicle"));
    ASSERT(has_def(r, "Method", "accelerate"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_protocol) {
    /* A protocol requirement is a bodyless func inside a protocol body. Swift
     * codebases are heavily protocol-driven, so the requirement is very often
     * the declaration a reader is actually looking for — before this it was
     * absent from the graph entirely. */
    CBMFileResult *r = extract("protocol StudyRunning {\n    func generate() -> String\n}\n",
                               CBM_LANG_SWIFT, "t", "StudyRunning.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Interface", "StudyRunning"));
    ASSERT(has_def(r, "Method", "generate"));
    cbm_free_result(r);
    PASS();
}

/* --- Kotlin --- */
TEST(kotlin_function) {
    CBMFileResult *r = extract("fun greet(name: String): String = \"Hello $name\"\nfun main() { "
                               "println(greet(\"World\")) }\n",
                               CBM_LANG_KOTLIN, "t", "main.kt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(kotlin_class) {
    CBMFileResult *r =
        extract("class User(val name: String) {\n    fun display(): String = \"User: $name\"\n}\n",
                CBM_LANG_KOTLIN, "t", "User.kt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "User"));
    cbm_free_result(r);
    PASS();
}

/* --- Scala --- */
TEST(scala_function) {
    CBMFileResult *r =
        extract("object Main {\n  def greet(name: String): String = s\"Hello $name\"\n  def "
                "main(args: Array[String]): Unit = println(greet(\"World\"))\n}\n",
                CBM_LANG_SCALA, "t", "Main.scala");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(scala_class) {
    CBMFileResult *r =
        extract("class Animal(val name: String) {\n  def speak(): String = s\"I am $name\"\n}\n",
                CBM_LANG_SCALA, "t", "Animal.scala");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    cbm_free_result(r);
    PASS();
}

/* --- Dart --- */
TEST(dart_class) {
    CBMFileResult *r = extract("class Animal {\n  String name;\n  Animal(this.name);\n  String "
                               "speak() => 'I am $name';\n}\n",
                               CBM_LANG_DART, "t", "animal.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

/* --- Dart extension members (#1457) --- */
TEST(dart_extension_members) {
    CBMFileResult *r =
        extract("class Holder {\n  final int value;\n  const Holder(this.value);\n}\n\n"
                "extension HolderMath on Holder {\n  int doubled() => value + value;\n"
                "  int tripled() => value + value + value;\n"
                "  String describeHolder() => 'holder';\n}\n\n"
                "int topLevelHelper(int x) => x + 1;\n",
                CBM_LANG_DART, "t", "a.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Holder"));
    ASSERT(has_def(r, "Function", "topLevelHelper"));
    ASSERT(has_def(r, "Class", "HolderMath"));
    ASSERT(has_def(r, "Method", "doubled"));
    ASSERT(has_def(r, "Method", "tripled"));
    ASSERT(has_def(r, "Method", "describeHolder"));
    /* Members hang off the extension (DEFINES_METHOD source), not the file. */
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && strcmp(d->name, "doubled") == 0) {
            ASSERT_NOT_NULL(d->parent_class);
            ASSERT_STR_EQ(d->parent_class, "t.a.HolderMath");
        }
    }
    cbm_free_result(r);

    /* Unnamed extension: its members are still indexed. */
    r = extract("extension on String {\n  bool isShout() => this == toUpperCase();\n}\n",
                CBM_LANG_DART, "t", "b.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "isShout"));
    cbm_free_result(r);
    PASS();
}

/* --- Groovy --- */
TEST(groovy_class) {
    CBMFileResult *r =
        extract("class Greeter {\n    String name\n    String greet() { \"Hello, $name\" }\n    "
                "static void main(args) { println new Greeter(name:'World').greet() }\n}\n",
                CBM_LANG_GROOVY, "t", "Greeter.groovy");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Greeter"));
    ASSERT(has_def(r, "Method", "greet"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group B: Systems Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Rust --- */
TEST(rust_function) {
    CBMFileResult *r =
        extract("fn main() { println!(\"Hello\"); }\npub fn add(a: i32, b: i32) -> i32 { a + b }\n",
                CBM_LANG_RUST, "t", "main.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

TEST(rust_struct) {
    CBMFileResult *r = extract("pub struct Point { pub x: f64, pub y: f64 }\nimpl Point { pub fn "
                               "new(x: f64, y: f64) -> Self { Point { x, y } } }\n",
                               CBM_LANG_RUST, "t", "point.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "Point"));
    ASSERT(has_def(r, "Method", "new"));
    cbm_free_result(r);
    PASS();
}

/* --- Go --- */
TEST(go_function) {
    CBMFileResult *r = extract("package main\nfunc Greet(name string) string { return \"Hello, \" "
                               "+ name }\nfunc main() { Greet(\"World\") }\n",
                               CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(go_struct) {
    CBMFileResult *r = extract("package main\ntype Server struct { Host string; Port int }\nfunc "
                               "(s *Server) Start() error { return nil }\n",
                               CBM_LANG_GO, "t", "server.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "Server"));
    ASSERT(has_def(r, "Method", "Start"));
    cbm_free_result(r);
    PASS();
}

TEST(go_interface) {
    CBMFileResult *r =
        extract("package main\ntype Handler interface { ServeHTTP() error; Close() }\n",
                CBM_LANG_GO, "t", "handler.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Handler"));
    cbm_free_result(r);
    PASS();
}

/* --- Zig --- */
TEST(zig_function) {
    CBMFileResult *r =
        extract("const std = @import(\"std\");\npub fn add(a: i32, b: i32) i32 { return a + b; }\n",
                CBM_LANG_ZIG, "t", "main.zig");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- C --- */
TEST(c_function) {
    CBMFileResult *r =
        extract("int add(int a, int b) { return a + b; }\nvoid greet() { printf(\"Hello\"); }\n",
                CBM_LANG_C, "t", "math.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(c_struct) {
    CBMFileResult *r =
        extract("struct Point { int x; int y; };\nvoid init_point(struct Point *p) { p->x = 0; }\n",
                CBM_LANG_C, "t", "point.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "init_point"));
    cbm_free_result(r);
    PASS();
}

/* `typedef struct { … } Name;` is the dominant C spelling of a type: the
 * aggregate itself is anonymous and the typedef's declarator names it. Without
 * that name the struct had no Class node and none of its members a Field node
 * (37 of the 38 structs in internal/cbm/cbm.h), so a member access could only
 * bind some OTHER struct's same-named field. */
TEST(extract_c_anonymous_typedef_aggregate_is_named_by_its_typedef) {
    CBMFileResult *r = extract("typedef struct {\n"
                               "    int count;\n"
                               "    const char *label;\n"
                               "} Tally;\n"
                               "\n"
                               "typedef union {\n"
                               "    int as_int;\n"
                               "    float as_float;\n"
                               "} Slot;\n"
                               "\n"
                               "typedef enum { SHADE_RED, SHADE_GREEN } Shade;\n"
                               "\n"
                               "typedef struct Named {\n"
                               "    int id;\n"
                               "} Named;\n"
                               "\n"
                               "typedef struct {\n"
                               "    int raw;\n"
                               "} *TallyRef;\n",
                               CBM_LANG_C, "t", "tally.h");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* RED before the fix: none of the three anonymous aggregates has a def. */
    ASSERT_TRUE(has_def(r, "Class", "Tally"));
    ASSERT_TRUE(has_def_qn(r, "t.tally.Tally.count"));
    ASSERT_TRUE(has_def_qn(r, "t.tally.Tally.label"));
    ASSERT_TRUE(has_def(r, "Class", "Slot"));
    ASSERT_TRUE(has_def_qn(r, "t.tally.Slot.as_int"));
    ASSERT_TRUE(has_def_qn(r, "t.tally.Slot.as_float"));
    ASSERT_TRUE(has_def_any(r, "Shade"));
    /* A struct that names itself keeps exactly one def, under its own name. */
    ASSERT_EQ(count_defs_named(r, "Class", "Named"), 1);
    ASSERT_TRUE(has_def_qn(r, "t.tally.Named.id"));
    /* A pointer typedef names a pointer type, not the aggregate: no Class. */
    ASSERT_FALSE(has_def(r, "Class", "TallyRef"));
    ASSERT_FALSE(has_def(r, "Field", "raw"));
    cbm_free_result(r);
    PASS();
}

/* The anonymous aggregate of a typedef is ONE definition. extract_c_typedef names
 * it from the type_definition; a second naming from the anonymous specifier gave
 * Tally two Class defs under one QN, every member twice, and a variants list. */
TEST(extract_c_anonymous_typedef_aggregate_is_one_def) {
    CBMFileResult *r = extract("typedef struct {\n"
                               "    int count;\n"
                               "} Tally;\n"
                               "typedef enum { SHADE_RED, SHADE_GREEN } Shade;\n",
                               CBM_LANG_C, "t", "tally.h");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Class", "Tally"), 1);
    ASSERT_EQ(count_defs_named(r, "Field", "count"), 1);
    ASSERT_EQ(count_defs_named(r, "Enum", "Shade"), 1);
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && strcmp(d->name, "Tally") == 0) {
            ASSERT_NULL(d->variants);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* A pointer-to-function member (`void (*open)(int);`, the shape of every
 * kernel ops table) is a field of its struct. It shares the
 * field_declaration + function_declarator shape with a C++ member FUNCTION
 * declaration, which the field extractor rightly skips; the two differ in
 * where the name sits: `(*open)` is a parenthesized pointer declarator. */
TEST(extract_c_function_pointer_member_is_a_field) {
    CBMFileResult *r = extract("struct Ops {\n"
                               "    int flags;\n"
                               "    void (*open)(int fd);\n"
                               "    int (*cmp)(const void *, const void *);\n"
                               "    char *(*name_of)(int id);\n"
                               "    void (*handlers[4])(void);\n"
                               "};\n",
                               CBM_LANG_C, "t", "ops.h");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_TRUE(has_def_qn(r, "t.ops.Ops.flags"));
    /* RED before the fix: none of the four pointer-to-function members. */
    ASSERT_TRUE(has_def_qn(r, "t.ops.Ops.open"));
    ASSERT_TRUE(has_def_qn(r, "t.ops.Ops.cmp"));
    ASSERT_TRUE(has_def_qn(r, "t.ops.Ops.name_of"));
    ASSERT_TRUE(has_def_qn(r, "t.ops.Ops.handlers"));
    ASSERT_EQ(count_defs_with_label(r, "Field"), 5);
    /* Each carries a type text, which the cross-file registry needs to list
     * it among its struct's fields. */
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && strcmp(d->label, "Field") == 0) {
            ASSERT_NOT_NULL(d->return_type);
            ASSERT_TRUE(d->return_type[0] != '\0');
        }
    }
    cbm_free_result(r);

    /* A C++ member function DECLARATION stays out of the fields; a
     * pointer-to-function member beside it is one. */
    r = extract("class Widget {\n"
                "public:\n"
                "    void resize(int w);\n"
                "    int (*hook)(int);\n"
                "    int width;\n"
                "};\n",
                CBM_LANG_CPP, "t", "widget.hpp");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(has_def(r, "Field", "hook"));
    ASSERT_TRUE(has_def(r, "Field", "width"));
    ASSERT_FALSE(has_def(r, "Field", "resize"));
    cbm_free_result(r);
    PASS();
}

/* return_type of the first definition named `name`; NULL when there is no such
 * definition or it carries no return type. */
static const char *def_return_type(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0) {
            return r->defs.items[i].return_type;
        }
    }
    return NULL;
}

/* A member's name is the identifier at the bottom of its declarator, and its
 * type is everything around that identifier, in the canonical spelling of the
 * function return types below. Taking the first declarator's first child as
 * the name published members called `*argv` and `seen[8]`, which no member
 * access can ever match; taking only the `type` node typed `struct Node *next`
 * as a struct, so `list->next[i]` had no element type; and of
 * `struct Node *next, *prev;` only `next` existed. */
TEST(extract_c_member_declarators_name_and_type) {
    CBMFileResult *r = extract("struct Shapes {\n"
                               "    char **argv;\n"
                               "    int seen[8];\n"
                               "    struct Node *next, *prev;\n"
                               "    int a, b;\n"
                               "    const char *label;\n"
                               "    unsigned flags : 3;\n"
                               "    char *const fixed;\n"
                               "    char *names[4];\n"
                               "    int plain;\n"
                               "};\n",
                               CBM_LANG_C, "t", "shapes.h");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* RED before the fix: `*argv`, `seen[8]`, `*next`, `*label`, `*names[4]`
     * as names, and no `prev` / `b` at all. */
    ASSERT_EQ(count_defs_with_label(r, "Field"), 11);
    ASSERT_STR_EQ(def_return_type(r, "argv"), "char **");
    ASSERT_STR_EQ(def_return_type(r, "seen"), "int [8]");
    ASSERT_STR_EQ(def_return_type(r, "next"), "struct Node *");
    ASSERT_STR_EQ(def_return_type(r, "prev"), "struct Node *");
    ASSERT_STR_EQ(def_return_type(r, "a"), "int");
    ASSERT_STR_EQ(def_return_type(r, "b"), "int");
    ASSERT_STR_EQ(def_return_type(r, "label"), "const char *");
    ASSERT_STR_EQ(def_return_type(r, "flags"), "unsigned");
    ASSERT_STR_EQ(def_return_type(r, "fixed"), "char *const");
    ASSERT_STR_EQ(def_return_type(r, "names"), "char *[4]");
    ASSERT_STR_EQ(def_return_type(r, "plain"), "int");
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && strcmp(d->label, "Field") == 0) {
            ASSERT_NULL(strpbrk(d->name, "*[]() "));
        }
    }
    cbm_free_result(r);

    /* Pointer-to-function members spell their type the way C does. */
    r = extract("struct Ops {\n"
                "    void (*open)(int fd);\n"
                "    char *(*name_of)(int id);\n"
                "    void (*handlers[4])(void);\n"
                "    int (*cmp)(const void *,\n"
                "               const void *);\n"
                "};\n",
                CBM_LANG_C, "t", "ops.h");
    ASSERT_NOT_NULL(r);
    ASSERT_STR_EQ(def_return_type(r, "open"), "void (*)(int fd)");
    ASSERT_STR_EQ(def_return_type(r, "name_of"), "char *(*)(int id)");
    ASSERT_STR_EQ(def_return_type(r, "handlers"), "void (*[4])(void)");
    ASSERT_STR_EQ(def_return_type(r, "cmp"), "int (*)(const void *, const void *)");
    cbm_free_result(r);

    /* C++: a reference member, and member functions stay out. */
    r = extract("class Widget {\n"
                "public:\n"
                "    Widget *parent, *child;\n"
                "    const Text &title;\n"
                "    int *ids() const;\n"
                "    void (resize)(int w);\n"
                "};\n",
                CBM_LANG_CPP, "t", "widget.hpp");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_with_label(r, "Field"), 3);
    ASSERT_STR_EQ(def_return_type(r, "parent"), "Widget *");
    ASSERT_STR_EQ(def_return_type(r, "child"), "Widget *");
    ASSERT_STR_EQ(def_return_type(r, "title"), "const Text &");
    cbm_free_result(r);

    /* A member whose type is a macro invocation (jemalloc's
     * `ql_head(tcache_slow_t) tcache_ql;`): the member is `tcache_ql`, never
     * the macro's argument. Both grammars: a header is parsed as C++. */
    static const CBMLanguage macro_langs[] = {CBM_LANG_C, CBM_LANG_CPP};
    for (size_t li = 0; li < sizeof(macro_langs) / sizeof(macro_langs[0]); li++) {
        r = extract("struct arena_s {\n"
                    "    ql_head(tcache_slow_t) tcache_ql;\n"
                    "    malloc_mutex_t mtx;\n"
                    "};\n",
                    macro_langs[li], "t", "arena.h");
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(has_def(r, "Field", "tcache_slow_t"));
        ASSERT_FALSE(has_def(r, "Field", "(tcache_slow_t)"));
        ASSERT_TRUE(has_def(r, "Field", "tcache_ql"));
        ASSERT_STR_EQ(def_return_type(r, "tcache_ql"), "ql_head(tcache_slow_t)");
        ASSERT_TRUE(has_def(r, "Field", "mtx"));
        cbm_free_result(r);
    }
    PASS();
}

/* PR #1245: the C grammar splits a declared return type across the `type` node,
 * sibling type_qualifier nodes and the pointer_declarator chain wrapping the
 * function declarator. Taking only the `type` node published `const char *` as
 * "char". Canonical spelling: qualifiers, base type, one space, then the
 * declarator markers unspaced (`const char *`, `char **`). */
TEST(c_function_return_type_preserves_pointer_and_qualifier) {
    CBMFileResult *r = extract("static const char *text_end(const char *text) { return text; }\n"
                               "char **table(void) { return 0; }\n"
                               "char const *east_const(void) { return 0; }\n"
                               "const struct Point *find_point(void) { return 0; }\n"
                               "volatile unsigned long *reg(void) { return 0; }\n"
                               "char *const *frozen(void) { return 0; }\n",
                               CBM_LANG_C, "t", "returns.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_STR_EQ(def_return_type(r, "text_end"), "const char *");
    ASSERT_STR_EQ(def_return_type(r, "table"), "char **");
    ASSERT_STR_EQ(def_return_type(r, "east_const"), "const char *");
    ASSERT_STR_EQ(def_return_type(r, "find_point"), "const struct Point *");
    ASSERT_STR_EQ(def_return_type(r, "reg"), "volatile unsigned long *");
    ASSERT_STR_EQ(def_return_type(r, "frozen"), "char *const *");
    cbm_free_result(r);
    PASS();
}

/* Guard for the fix above: a return type with no qualifier and no declarator
 * marker is already correct and must come out byte-identical. */
TEST(c_function_return_type_plain_unchanged) {
    CBMFileResult *r = extract("int scalar(void) { return 0; }\n"
                               "void nothing(void) {}\n"
                               "unsigned long wide(void) { return 0; }\n"
                               "struct Point make_point(void) { struct Point p; return p; }\n"
                               "static inline size_t count(void) { return 0; }\n"
                               "_Noreturn void die(void) { for (;;) {} }\n",
                               CBM_LANG_C, "t", "plain.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_STR_EQ(def_return_type(r, "scalar"), "int");
    ASSERT_STR_EQ(def_return_type(r, "nothing"), "void");
    ASSERT_STR_EQ(def_return_type(r, "wide"), "unsigned long");
    ASSERT_STR_EQ(def_return_type(r, "make_point"), "struct Point");
    ASSERT_STR_EQ(def_return_type(r, "count"), "size_t");
    /* _Noreturn parses as a type_qualifier but is not part of the type. */
    ASSERT_STR_EQ(def_return_type(r, "die"), "void");
    cbm_free_result(r);
    PASS();
}

/* --- C++ --- */
TEST(cpp_class) {
    CBMFileResult *r = extract(
        "class Widget {\npublic:\n    void draw() {}\n    int width() const { return 0; }\n};\n",
        CBM_LANG_CPP, "t", "widget.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Widget"));
    ASSERT(has_def(r, "Method", "draw"));
    cbm_free_result(r);
    PASS();
}

/* PR #1245, C++ side: in-class methods go through a separate extraction path
 * from free functions, and C++ adds reference markers (`&`, `&&`) whose
 * reference_declarator carries no `declarator` field. */
TEST(cpp_method_return_type_preserves_pointer_and_qualifier) {
    CBMFileResult *r = extract("class Text {\n"
                               "public:\n"
                               "    const char *end() { return nullptr; }\n"
                               "    char **table() { return nullptr; }\n"
                               "    Text &self() { return *this; }\n"
                               "    const Text &cself() const { return *this; }\n"
                               "    Text *&slot() { return next_; }\n"
                               "    Text *next_;\n"
                               "    int width() const { return 0; }\n"
                               "    constexpr int square(int x) const { return x * x; }\n"
                               "};\n"
                               "const Text &shared() { static Text t; return t; }\n"
                               "Text &&moved(Text &t) { return static_cast<Text &&>(t); }\n"
                               "const char *Text::c_str() const { return nullptr; }\n",
                               CBM_LANG_CPP, "t", "text.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_STR_EQ(def_return_type(r, "end"), "const char *");
    ASSERT_STR_EQ(def_return_type(r, "table"), "char **");
    ASSERT_STR_EQ(def_return_type(r, "self"), "Text &");
    ASSERT_STR_EQ(def_return_type(r, "cself"), "const Text &");
    ASSERT_STR_EQ(def_return_type(r, "slot"), "Text *&");
    ASSERT_STR_EQ(def_return_type(r, "width"), "int");
    /* constexpr parses as a type_qualifier but is not part of the type. */
    ASSERT_STR_EQ(def_return_type(r, "square"), "int");
    ASSERT_STR_EQ(def_return_type(r, "shared"), "const Text &");
    ASSERT_STR_EQ(def_return_type(r, "moved"), "Text &&");
    ASSERT_STR_EQ(def_return_type(r, "c_str"), "const char *");
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group C: Scripting / Dynamic Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Python --- */
/* #1277: annotated Python instance fields reach result->field_types (the
 * cross-file LSP's only source for them); nothing unannotated is guessed and
 * no graph def is minted for a field. */
static const char *py_field_type_of(const CBMFileResult *r, const char *cls_suffix,
                                    const char *field) {
    for (int i = 0; i < r->field_types.count; i++) {
        const CBMFieldType *ft = &r->field_types.items[i];
        size_t cl = strlen(ft->class_qn);
        size_t sl = strlen(cls_suffix);
        if (cl >= sl && strcmp(ft->class_qn + cl - sl, cls_suffix) == 0 &&
            strcmp(ft->field_name, field) == 0) {
            return ft->type_text;
        }
    }
    return NULL;
}

TEST(python_annotated_instance_fields_exported_issue1277) {
    const char *src = "class Trainer(Base):\n"
                      "    engine: Contract\n"
                      "    limit: int = 3\n"
                      "    plain = 5\n\n"
                      "    def __init__(self, strategies: Contract, n, opt: 'Other' = None):\n"
                      "        self.strategies = strategies\n"
                      "        self.typed: Contract = strategies\n"
                      "        self.count = n\n"
                      "        self.made = make()\n"
                      "        self.opt = opt\n"
                      "        if n:\n"
                      "            self.nested: Nested = n\n"
                      "        def inner(other: Inner):\n"
                      "            self.hidden = other\n\n"
                      "    def later(self, x: Later):\n"
                      "        self.late = x\n";
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "trainer.py");
    ASSERT_NOT_NULL(r);
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "engine"), "Contract");
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "limit"), "int");
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "strategies"), "Contract");
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "typed"), "Contract");
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "opt"), "'Other'");
    ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "nested"), "Nested");
    /* Controls: no declared type, a nested function's binding, a non-__init__ method. */
    ASSERT_NULL(py_field_type_of(r, ".Trainer", "plain"));
    ASSERT_NULL(py_field_type_of(r, ".Trainer", "count"));
    ASSERT_NULL(py_field_type_of(r, ".Trainer", "made"));
    ASSERT_NULL(py_field_type_of(r, ".Trainer", "hidden"));
    ASSERT_NULL(py_field_type_of(r, ".Trainer", "late"));
    ASSERT_EQ(r->field_types.count, 6);
    for (int i = 0; i < r->defs.count; i++) {
        ASSERT_FALSE(r->defs.items[i].label && strcmp(r->defs.items[i].label, "Field") == 0);
    }
    cbm_free_result(r);
    PASS();
}

/* #1277: the import an annotated field's type comes from usually sits under
 * `if TYPE_CHECKING:`. It is recorded, flagged annotation-only; a runtime
 * import is not flagged; an else branch (a runtime alternative) and an
 * ordinary `if` stay unrecorded as before. */
static const CBMImport *py_find_import(const CBMFileResult *r, const char *local) {
    for (int i = 0; i < r->imports.count; i++) {
        if (r->imports.items[i].local_name && strcmp(r->imports.items[i].local_name, local) == 0)
            return &r->imports.items[i];
    }
    return NULL;
}

TEST(python_type_checking_imports_flagged_issue1277) {
    const char *src = "from typing import TYPE_CHECKING\n"
                      "import typing\n"
                      "if TYPE_CHECKING:\n"
                      "    from trainer import Trainer\n"
                      "    import contracts\n"
                      "else:\n"
                      "    from fallback import Runtime\n"
                      "if typing.TYPE_CHECKING:\n"
                      "    from engine import Engine as Eng\n"
                      "if FLAG:\n"
                      "    from other import Conditional\n";
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "loop.py");
    ASSERT_NOT_NULL(r);
    const CBMImport *tc = py_find_import(r, "TYPE_CHECKING");
    const CBMImport *trainer = py_find_import(r, "Trainer");
    const CBMImport *contracts = py_find_import(r, "contracts");
    const CBMImport *eng = py_find_import(r, "Eng");
    ASSERT_NOT_NULL(tc);
    ASSERT_FALSE(tc->type_checking_only);
    ASSERT_NOT_NULL(trainer);
    ASSERT_TRUE(trainer->type_checking_only);
    ASSERT_NOT_NULL(contracts);
    ASSERT_TRUE(contracts->type_checking_only);
    ASSERT_NOT_NULL(eng);
    ASSERT_TRUE(eng->type_checking_only);
    ASSERT_NULL(py_find_import(r, "Runtime"));
    ASSERT_NULL(py_find_import(r, "Conditional"));
    cbm_free_result(r);
    PASS();
}

/* A name the alternative of an `if TYPE_CHECKING:` binds again (the airflow
 * compat shape, usually inside try/except ImportError) is bound at runtime, so
 * its TYPE_CHECKING import is not annotation-only: it stays unrecorded, as the
 * runtime import itself does. A star import in an alternative may bind any
 * name, so it covers every name of the block. */
TEST(python_type_checking_rebound_in_else_unrecorded_issue1277) {
    const char *src = "from typing import TYPE_CHECKING\n"
                      "if TYPE_CHECKING:\n"
                      "    from airflow.sdk.execution_time.secrets_masker import mask_secret\n"
                      "    from airflow.sdk.types import OnlyTyped\n"
                      "else:\n"
                      "    try:\n"
                      "        from airflow.sdk.log import mask_secret\n"
                      "    except ImportError:\n"
                      "        mask_secret = None\n"
                      "if TYPE_CHECKING:\n"
                      "    from compat.types import Starred\n"
                      "elif SOMETHING:\n"
                      "    from compat import *\n";
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "hook.py");
    ASSERT_NOT_NULL(r);
    const CBMImport *typed = py_find_import(r, "OnlyTyped");
    ASSERT_NOT_NULL(typed);
    ASSERT_TRUE(typed->type_checking_only);        /* only the type checker binds it */
    ASSERT_NULL(py_find_import(r, "mask_secret")); /* the else branch binds it at runtime */
    ASSERT_NULL(py_find_import(r, "Starred"));     /* the elif star import may bind it */
    ASSERT_NULL(py_find_import(r, "compat"));      /* alternatives stay unrecorded */
    ASSERT_NOT_NULL(py_find_import(r, "TYPE_CHECKING"));
    cbm_free_result(r);
    PASS();
}

TEST(python_function) {
    CBMFileResult *r = extract(
        "def greet(name):\n    return f\"Hello {name}\"\n\ndef main():\n    greet(\"World\")\n",
        CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(python_class) {
    CBMFileResult *r =
        extract("class Dog:\n    def __init__(self, name):\n        self.name = name\n    def "
                "speak(self):\n        return f\"Woof from {self.name}\"\n",
                CBM_LANG_PYTHON, "t", "dog.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Dog"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

/* --- JavaScript --- */
TEST(js_function) {
    CBMFileResult *r =
        extract("function greet(name) { return `Hello ${name}`; }\nconst add = (a, b) => a + b;\n",
                CBM_LANG_JAVASCRIPT, "t", "util.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(js_class) {
    CBMFileResult *r =
        extract("class Counter {\n  constructor() { this.count = 0; }\n  increment() { "
                "this.count++; }\n  get value() { return this.count; }\n}\n",
                CBM_LANG_JAVASCRIPT, "t", "counter.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Counter"));
    ASSERT(has_def(r, "Method", "increment"));
    cbm_free_result(r);
    PASS();
}

/* --- TypeScript --- */
TEST(ts_function) {
    CBMFileResult *r = extract("export function greet(name: string): string { return `Hello "
                               "${name}`; }\nfunction helper(): void {}\n",
                               CBM_LANG_TYPESCRIPT, "t", "util.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(ts_class) {
    CBMFileResult *r =
        extract("class Service {\n  private name: string;\n  constructor(name: string) { this.name "
                "= name; }\n  getName(): string { return this.name; }\n}\n",
                CBM_LANG_TYPESCRIPT, "t", "service.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Service"));
    cbm_free_result(r);
    PASS();
}

TEST(body_tokens_type_identifier) {
    CBMFileResult *r = extract("function serialize(obj: MyModel): SerializedResult {\n"
                               "  const result: SerializedResult = new SerializedResult();\n"
                               "  return result;\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "serial.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "serialize") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].body_tokens);
            ASSERT(strstr(r->defs.items[i].body_tokens, "SerializedResult") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

/* --- Lua --- */
TEST(lua_function) {
    CBMFileResult *r = extract(
        "function greet(name)\n  return \"Hello \" .. name\nend\nlocal function helper() end\n",
        CBM_LANG_LUA, "t", "main.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Bash --- */
TEST(bash_function) {
    CBMFileResult *r =
        extract("greet() {\n  echo \"Hello $1\"\n}\nmain() {\n  greet \"World\"\n}\n",
                CBM_LANG_BASH, "t", "script.sh");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Perl --- */
TEST(perl_function) {
    CBMFileResult *r = extract("sub greet {\n    my ($name) = @_;\n    return \"Hello "
                               "$name\";\n}\nsub main { greet(\"World\"); }\n",
                               CBM_LANG_PERL, "t", "main.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- R --- */
TEST(r_function) {
    CBMFileResult *r = extract("add <- function(x, y) x + y\nmultiply <- function(x, y) x * y\n",
                               CBM_LANG_R, "t", "math.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group D: Functional Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Elixir --- */
TEST(elixir_function) {
    CBMFileResult *r = extract("defmodule Greeter do\n  def greet(name), do: \"Hello #{name}\"\n  "
                               "defp helper, do: nil\nend\n",
                               CBM_LANG_ELIXIR, "t", "greeter.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* ── Elixir def-head guard helpers (internal/cbm/helpers.c) ─────────
 *
 * `def name(args) when guard` parses its WHOLE head as one `when`
 * binary_operator whose left operand is the `name(args)` call, and Elixir
 * admits more than one guard on a clause, which tree-sitter-elixir nests
 * right-associatively. Four walks read that same first argument and each asks a
 * different question of it: the defs and call-scope walks want the head UNDER
 * every guard, the usages walk wants it so that a parameter READ by the guard
 * stays outside the binding, and the calls walk wants to know whether the node
 * it is visiting IS that head or one of the guard operators above it.
 *
 * That last question is why cbm_elixir_def_head_is exists beside the unwrap,
 * and it is exercised here on the AST rather than through cbm_extract_file
 * because the two routes it has to answer for are indistinguishable from
 * outside: `def f(x) when g` reaches the calls walk as the inner `f(x)` call,
 * which the unwrap reaches, while `def f when g` has no inner call at all and
 * reaches it as the `when` operator itself, which the unwrap does not. A test
 * that only drives one walk sees whichever of the two that walk happens to hit.
 *
 * This file's helpers change no extraction behaviour on their own; the walks
 * that consume them are separate changes. */

enum { ELIXIR_HEAD_PROBE_MAX = 16, ELIXIR_HEAD_STACK_MAX = 256 };

static bool head_probe_text_is(const char *source, TSNode node, const char *want) {
    if (ts_node_is_null(node)) {
        return false;
    }
    uint32_t start = ts_node_start_byte(node);
    uint32_t end = ts_node_end_byte(node);
    size_t len = strlen(want);
    return end >= start && (size_t)(end - start) == len && memcmp(source + start, want, len) == 0;
}

/* The first argument of every `def`/`defp` call under `root`, in source order.
 * That argument is what all four walks read, so it is what the helpers take. */
typedef struct {
    TSNode signature[ELIXIR_HEAD_PROBE_MAX];
    int count;
} elixir_head_probe_t;

static void collect_elixir_def_signatures(TSNode root, const char *source,
                                          elixir_head_probe_t *out) {
    TSNode stack[ELIXIR_HEAD_STACK_MAX];
    int top = 0;
    stack[top++] = root;
    while (top > 0) {
        TSNode cur = stack[--top];
        uint32_t cc = ts_node_child_count(cur);
        if (cc > 1 && strcmp(ts_node_type(cur), "call") == 0 &&
            (head_probe_text_is(source, ts_node_child(cur, 0), "def") ||
             head_probe_text_is(source, ts_node_child(cur, 0), "defp")) &&
            out->count < ELIXIR_HEAD_PROBE_MAX) {
            TSNode args = ts_node_child(cur, 1);
            if (!ts_node_is_null(args) && ts_node_child_count(args) > 0) {
                out->signature[out->count++] = ts_node_child(args, 0);
            }
        }
        for (int i = (int)cc - 1; i >= 0 && top < ELIXIR_HEAD_STACK_MAX; i--) {
            stack[top++] = ts_node_child(cur, (uint32_t)i);
        }
    }
}

TEST(elixir_def_head_is_covers_the_head_and_every_guard_above_it) {
    const char *source = "defmodule Heads do\n"
                         "  def plain(x), do: x\n"
                         "  def guarded(x) when is_binary(x), do: x\n"
                         "  def bare when true, do: :ok\n"
                         "  def twice(x) when is_atom(x) when is_binary(x), do: x\n"
                         "  def a + b, do: {a, b}\n"
                         "end\n";
    const TSLanguage *language = cbm_ts_language(CBM_LANG_ELIXIR);
    ASSERT_NOT_NULL(language);
    TSParser *parser = ts_parser_new();
    ASSERT_NOT_NULL(parser);
    ASSERT_TRUE(ts_parser_set_language(parser, language));
    TSTree *tree = ts_parser_parse_string(parser, NULL, source, (uint32_t)strlen(source));
    ASSERT_NOT_NULL(tree);

    elixir_head_probe_t probe;
    probe.count = 0;
    collect_elixir_def_signatures(ts_tree_root_node(tree), source, &probe);
    ASSERT_EQ(5, probe.count);

    /* Unguarded: nothing to peel, and the head is the whole first argument.
     * The name node inside it is NOT the head -- the calls walk compares the
     * node it is visiting, and the `plain` identifier is one of those. */
    TSNode plain = probe.signature[0];
    ASSERT_FALSE(cbm_elixir_is_when_guard(plain));
    ASSERT_TRUE(ts_node_eq(cbm_elixir_def_head_unwrap_guard(plain), plain));
    ASSERT_TRUE(cbm_elixir_def_head_is(plain, plain));
    ASSERT_FALSE(cbm_elixir_def_head_is(plain, ts_node_child(plain, 0)));

    /* One guard: the first argument is the operator, the head is its left
     * operand, and BOTH answer true -- the operator is the node the paren-less
     * route hands the calls walk, the inner call is the node the peel route
     * hands it. The guard expression answers false, or the walk would suppress
     * a real call written inside a guard. */
    TSNode guarded = probe.signature[1];
    ASSERT_TRUE(cbm_elixir_is_when_guard(guarded));
    TSNode guarded_head = cbm_elixir_def_head_unwrap_guard(guarded);
    ASSERT_FALSE(ts_node_eq(guarded_head, guarded));
    ASSERT_STR_EQ("call", ts_node_type(guarded_head));
    ASSERT_TRUE(head_probe_text_is(source, guarded_head, "guarded(x)"));
    ASSERT_TRUE(cbm_elixir_def_head_is(guarded, guarded));
    ASSERT_TRUE(cbm_elixir_def_head_is(guarded, guarded_head));
    TSNode guard_expr = ts_node_child_by_field_name(guarded, TS_FIELD("right"));
    ASSERT_FALSE(ts_node_is_null(guard_expr));
    ASSERT_TRUE(head_probe_text_is(source, guard_expr, "is_binary(x)"));
    ASSERT_FALSE(cbm_elixir_def_head_is(guarded, guard_expr));

    /* Paren-less: the head under the guard is a bare identifier, so there is no
     * inner call for the peel route to produce. This is the shape that makes
     * cbm_elixir_def_head_is necessary: the only node the calls walk ever sees
     * for this clause is the operator. */
    TSNode bare = probe.signature[2];
    ASSERT_TRUE(cbm_elixir_is_when_guard(bare));
    TSNode bare_head = cbm_elixir_def_head_unwrap_guard(bare);
    ASSERT_STR_EQ("identifier", ts_node_type(bare_head));
    ASSERT_TRUE(head_probe_text_is(source, bare_head, "bare"));
    ASSERT_TRUE(cbm_elixir_def_head_is(bare, bare));
    ASSERT_TRUE(cbm_elixir_def_head_is(bare, bare_head));

    /* Two guards on one clause. tree-sitter-elixir nests them
     * RIGHT-associatively -- `when(twice(x), when(is_atom(x), is_binary(x)))`,
     * which is what this asserts -- so the head is still the outer operator's
     * left operand and the peel reaches it in one step. The repeated peel is
     * therefore a fixed point rather than a chain walk on this grammar; the
     * nodes that must answer true are the operator and the head. */
    TSNode twice = probe.signature[3];
    ASSERT_TRUE(cbm_elixir_is_when_guard(twice));
    TSNode second_guard = ts_node_child_by_field_name(twice, TS_FIELD("right"));
    ASSERT_TRUE(cbm_elixir_is_when_guard(second_guard));
    TSNode twice_head = cbm_elixir_def_head_unwrap_guard(twice);
    ASSERT_TRUE(head_probe_text_is(source, twice_head, "twice(x)"));
    ASSERT_TRUE(cbm_elixir_def_head_is(twice, twice));
    ASSERT_TRUE(cbm_elixir_def_head_is(twice, twice_head));
    /* The second guard is a `when` operator too, and it is NOT on the head
     * chain: a walk that treated any `when` above the head as a declaration
     * would suppress the calls written inside it. */
    ASSERT_FALSE(cbm_elixir_def_head_is(twice, second_guard));

    /* An operator definition's head is a binary_operator too, and unwrapping it
     * would name the function after its own left parameter. Only the `when`
     * token admits the peel, so `def a + b` is returned unchanged and its left
     * operand is not a head. */
    TSNode op_def = probe.signature[4];
    ASSERT_STR_EQ("binary_operator", ts_node_type(op_def));
    ASSERT_FALSE(cbm_elixir_is_when_guard(op_def));
    ASSERT_TRUE(ts_node_eq(cbm_elixir_def_head_unwrap_guard(op_def), op_def));
    ASSERT_TRUE(cbm_elixir_def_head_is(op_def, op_def));
    TSNode op_lhs = ts_node_child_by_field_name(op_def, TS_FIELD("left"));
    ASSERT_TRUE(head_probe_text_is(source, op_lhs, "a"));
    ASSERT_FALSE(cbm_elixir_def_head_is(op_def, op_lhs));

    ts_tree_delete(tree);
    ts_parser_delete(parser);
    PASS();
}

/* `def name(args) when guard` parses its whole head as a `when`
 * binary_operator, so the name sits on the operator's left operand rather than
 * directly under the call. The def extractor accepted only `call` and
 * `identifier` there, so every guarded clause was dropped -- and a function
 * whose clauses ALL carry guards never reached the graph at all, silently.
 * Guards are ordinary Elixir: on one real 2.9k-function codebase this hid 216
 * of 270 all-guarded functions, and every call edge touching them. */
TEST(extract_elixir_guarded_def_head) {
    CBMFileResult *r = extract("defmodule Guarded do\n"
                               "  def plain(x), do: x\n"
                               "  def guarded(x) when is_binary(x), do: x\n"
                               "  def guarded(x) when is_list(x), do: x\n"
                               "  def multi(x, y) when is_binary(x) and is_integer(y), do: {x, y}\n"
                               "  defp priv_guarded(x) when is_atom(x), do: x\n"
                               "  def bare when true, do: :ok\n"
                               "  def a + b, do: {a, b}\n"
                               "  def c - d when is_integer(c), do: {c, d}\n"
                               "  def multi_guard(x) when is_atom(x) when is_binary(x), do: x\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "guarded.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "plain"));
    ASSERT(has_def(r, "Function", "guarded"));
    ASSERT(has_def(r, "Function", "multi"));
    ASSERT(has_def(r, "Function", "priv_guarded"));
    ASSERT(has_def(r, "Function", "bare"));

    /* Elixir admits more than one guard on a clause. tree-sitter-elixir nests
     * those `when` operators right-associatively, so the declared head stays
     * the outermost operator's left operand -- one node either way, and the
     * peel must not stop short of it or return the guard. */
    ASSERT(has_def(r, "Function", "multi_guard"));
    ASSERT_EQ(count_defs_named(r, "Function", "multi_guard"), 1);

    /* An operator definition is a binary_operator head too, but it is not a
     * guard: unwrapping it names the function after its own LEFT PARAMETER.
     * `def a + b` must not mint a function called `a`, nor `def c - d when ...`
     * one called `c` -- the guard's left operand is itself the `c - d`
     * operator, which names no function either. Neither operator form is
     * extracted at all, which is what this grammar did before guards were
     * handled; only the `when` token admits the unwrap. */
    ASSERT_EQ(count_defs_named(r, "Function", "a"), 0);
    ASSERT_EQ(count_defs_named(r, "Function", "c"), 0);
    cbm_free_result(r);
    PASS();
}

/* A guard hides the head from the scope walk and from the calls walk.
 * compute_elixir_func_qn accepts only a `call` or an `identifier` as a def's
 * first argument, so a guarded clause resolved no QN and opened NO function
 * scope: every call in its body was attributed to the FILE node, the function
 * reported no outgoing edges, and its callees gained an in-edge from the file
 * instead of from their caller. A paren-less guarded clause (`def f when g`) is
 * worse still: it has no inner call node at all, so the guard operator itself
 * falls through to extract_callee_name's first-identifier last resort and mints
 * a phantom CALLS edge naming the function being defined. */
TEST(extract_elixir_guarded_def_head_scope) {
    CBMFileResult *r = extract("defmodule Guards do\n"
                               "  def target(x), do: x\n"
                               "  def other(x), do: x\n"
                               "  def unguarded_caller(a), do: target(a)\n"
                               "  def guarded_caller(a) when is_binary(a) do\n"
                               "    target(a)\n"
                               "    other(a)\n"
                               "  end\n"
                               "  def bare_guarded when true, do: target(:ok)\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "guard_scope.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* A paren-less guarded head is a definition, never a call to itself. */
    ASSERT_EQ(count_calls_named(r, "bare_guarded"), 0);

    /* Both calls in the guarded body source to the guarded function, and the
     * paren-less clause's body call to that clause. */
    ASSERT_EQ(count_calls_from(r, "target", "t.guard_scope.guarded_caller"), 1);
    ASSERT_EQ(count_calls_from(r, "other", "t.guard_scope.guarded_caller"), 1);
    ASSERT_EQ(count_calls_from(r, "target", "t.guard_scope.bare_guarded"), 1);

    /* Control on the path the fix does not touch: an unguarded clause still
     * sources its body call to itself. This is NOT a leak detector -- the walk
     * expires scopes by tree depth (pop_expired_scopes), so a sibling clause
     * always unwinds the previous one before pushing its own and "pushed but
     * never popped" is not a state this walk can reach. */
    ASSERT_EQ(count_calls_from(r, "target", "t.guard_scope.unguarded_caller"), 1);

    /* Nothing falls back to the file node. */
    ASSERT_EQ(count_calls_from(r, "target", "t.guard_scope"), 0);
    ASSERT_EQ(count_calls_from(r, "other", "t.guard_scope"), 0);

    cbm_free_result(r);
    PASS();
}

/* The half the calls and scope assertions above cannot see: the usages walk
 * asks whether an identifier sits inside the def's SIGNATURE, and treats
 * everything that does as part of the binding rather than as a reference. A
 * guard makes that signature the whole `when` operator, which spans the guard
 * expression too -- so `a` read by `is_binary(a)` was classified as its own
 * binding and emitted no USAGE row at all. A guard is an expression, not a
 * pattern: the parameters are bound by `guarded(a, b)` and every mention of one
 * to its right is a read, exactly as the same mention in the body already is.
 * Unwrapping the signature to the head restores those rows without admitting
 * the binding sites themselves, which is why each name is asserted both within
 * its scope and in total. */
TEST(extract_elixir_guarded_def_head_guard_usages) {
    CBMFileResult *r = extract("defmodule GuardUsage do\n"
                               "  def plain(x), do: x\n"
                               "  def guarded(a, b) when is_binary(a) and byte_size(a) > 3 do\n"
                               "    b\n"
                               "  end\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "guard_usage.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Both guard reads of the parameter are usages of the guarded clause. */
    ASSERT_EQ(count_usages_from(r, "a", "t.guard_usage.guarded"), 2);
    /* ...and nothing else claims `a`: the `a` in `guarded(a, b)` binds it. */
    ASSERT_EQ(count_usages_named(r, "a"), 2);

    /* The body read is unchanged, and the head's `b` is still a binding --
     * an unwrap that took the guard instead of the head would add both head
     * parameters here. */
    ASSERT_EQ(count_usages_from(r, "b", "t.guard_usage.guarded"), 1);
    ASSERT_EQ(count_usages_named(r, "b"), 1);

    /* Control: an unguarded clause was never affected either way. */
    ASSERT_EQ(count_usages_from(r, "x", "t.guard_usage.plain"), 1);
    ASSERT_EQ(count_usages_named(r, "x"), 1);

    cbm_free_result(r);
    PASS();
}

/* Every clause of an Elixir function is its own `def` call, and an Elixir QN
 * carries neither module nor arity, so all clauses compute one qualified name
 * and collide on a single graph node. cbm_gbuf_upsert_node ranks a same-QN
 * collision by LARGEST start_line, so the survivor was the last clause in the
 * file and get_code_snippet returned that clause as the whole function: a
 * two-clause `admin?` read back as `def admin?(%__MODULE__{}), do: false` --
 * the graph asserting a predicate that always returns false. The node has to
 * span its own clauses, and ONLY its own: the fold is bounded to the
 * immediately preceding definition and to the enclosing module body, so a def
 * of another name ends the group and two same-named functions in two modules
 * stay two nodes. */
TEST(extract_elixir_clauses_fold_only_when_adjacent_in_one_module) {
    CBMFileResult *r = extract("defmodule Roles do\n"                       /* 1 */
                               "  def admin?(%{role: :admin}), do: true\n"  /* 2 */
                               "  def admin?(%{}), do: false\n"             /* 3 */
                               "\n"                                         /* 4 */
                               "  def promote(user), do: user\n"            /* 5 */
                               "\n"                                         /* 6 */
                               "  def admin?(_other), do: false\n"          /* 7 */
                               "end\n"                                      /* 8 */
                               "\n"                                         /* 9 */
                               "defmodule Guests do\n"                      /* 10 */
                               "  def admin?(:root), do: true\n"            /* 11 */
                               "  def admin?(_any), do: false\n"            /* 12 */
                               "end\n",                                     /* 13 */
                               CBM_LANG_ELIXIR, "t", "roles.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* The two adjacent Roles clauses fold; the clause past `promote` is its own
     * group; the Guests pair is a DIFFERENT function and stays its own node. */
    ASSERT_EQ(3, count_defs_named(r, "Function", "admin?"));
    ASSERT_EQ(1, count_defs_named(r, "Function", "promote"));

    const CBMDefinition *admin[3] = {NULL, NULL, NULL};
    const CBMDefinition *promote = NULL;
    int seen = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") != 0) {
            continue;
        }
        if (strcmp(r->defs.items[i].name, "admin?") == 0 && seen < 3) {
            admin[seen++] = &r->defs.items[i];
        } else if (strcmp(r->defs.items[i].name, "promote") == 0) {
            promote = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(admin[0]);
    ASSERT_NOT_NULL(admin[1]);
    ASSERT_NOT_NULL(admin[2]);
    ASSERT_NOT_NULL(promote);

    ASSERT_EQ(2, (int)admin[0]->start_line);
    ASSERT_EQ(3, (int)admin[0]->end_line);
    /* separated from lines 2-3 by `promote`, so it keeps its own span */
    ASSERT_EQ(7, (int)admin[1]->start_line);
    ASSERT_EQ(7, (int)admin[1]->end_line);
    /* Guests.admin? never reaches back over the module boundary */
    ASSERT_EQ(11, (int)admin[2]->start_line);
    ASSERT_EQ(12, (int)admin[2]->end_line);
    ASSERT_EQ(5, (int)promote->start_line);
    ASSERT_EQ(5, (int)promote->end_line);
    cbm_free_result(r);
    PASS();
}

/* A nested module is the one place where the "def of another name ends the
 * group" rule is not enough: an Elixir QN carries no module, so `Outer.run` and
 * `Outer.Inner.run` compute the SAME qualified name, and when Inner sits
 * directly above Outer's own clause the two are adjacent in the extracted defs.
 * The fold is bounded to the module body as well, so they stay two nodes. */
TEST(extract_elixir_nested_module_clauses_do_not_fold) {
    CBMFileResult *r = extract("defmodule Outer do\n"          /* 1 */
                               "  defmodule Inner do\n"        /* 2 */
                               "    def run(a), do: a\n"       /* 3 */
                               "  end\n"                       /* 4 */
                               "\n"                            /* 5 */
                               "  def run(b), do: b + 1\n"     /* 6 */
                               "end\n",                        /* 7 */
                               CBM_LANG_ELIXIR, "t", "nested.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(2, count_defs_named(r, "Function", "run"));

    const CBMDefinition *runs[2] = {NULL, NULL};
    int seen = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0 &&
            strcmp(r->defs.items[i].name, "run") == 0 && seen < 2) {
            runs[seen++] = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(runs[0]);
    ASSERT_NOT_NULL(runs[1]);
    ASSERT_EQ(3, (int)runs[0]->start_line);
    ASSERT_EQ(3, (int)runs[0]->end_line);
    ASSERT_EQ(6, (int)runs[1]->start_line);
    ASSERT_EQ(6, (int)runs[1]->end_line);
    cbm_free_result(r);
    PASS();
}

/* Folding clauses has to decide is_exported for the merged node. A `def` clause
 * and a `defp` clause of the same name AND arity are clauses of one function --
 * a private guard clause or a nil short-circuit written above the public head
 * is ordinary Elixir -- so is_exported is the OR over the folded clauses: the
 * name is callable from outside if any clause exports it, and a wholly private
 * function stays unexported. */
TEST(extract_elixir_folded_clause_is_exported_is_the_or) {
    CBMFileResult *r = extract("defmodule Acc do\n"                                /* 1 */
                               "  def build(l), do: build(l)\n"                    /* 2 */
                               "  defp build([]), do: []\n"                        /* 3 */
                               "\n"                                                /* 4 */
                               "  defp trim(nil), do: nil\n"                       /* 5 */
                               "  defp trim(s), do: s\n"                           /* 6 */
                               "end\n",                                            /* 7 */
                               CBM_LANG_ELIXIR, "t", "acc.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(1, count_defs_named(r, "Function", "build"));
    ASSERT_EQ(1, count_defs_named(r, "Function", "trim"));

    const CBMDefinition *build = NULL;
    const CBMDefinition *trim = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") != 0) {
            continue;
        }
        if (strcmp(r->defs.items[i].name, "build") == 0) {
            build = &r->defs.items[i];
        } else if (strcmp(r->defs.items[i].name, "trim") == 0) {
            trim = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(build);
    ASSERT_NOT_NULL(trim);
    ASSERT_EQ(2, (int)build->start_line);
    ASSERT_EQ(3, (int)build->end_line);
    ASSERT_TRUE(build->is_exported);
    ASSERT_EQ(5, (int)trim->start_line);
    ASSERT_EQ(6, (int)trim->end_line);
    ASSERT_FALSE(trim->is_exported);
    cbm_free_result(r);

    /* The other direction, and the only one the `prev->is_exported ||` disjunct
     * decides. Above, the exporting clause is the FIRST one, so a plain
     * `prev->is_exported = is_exported` assignment would also have to lose it
     * on the later defp -- but a last-clause-wins assignment happens to be
     * right whenever the def comes last. Here the defp comes first and the def
     * second, so the surviving flag can only be true if the fold ORs rather
     * than assigns. */
    CBMFileResult *o = extract("defmodule Ord do\n"           /* 1 */
                               "  defp z(1), do: 1\n"         /* 2 */
                               "  def z(2), do: 2\n"          /* 3 */
                               "end\n",                       /* 4 */
                               CBM_LANG_ELIXIR, "t", "ord.ex");
    ASSERT_NOT_NULL(o);
    ASSERT_FALSE(o->has_error);
    ASSERT_EQ(1, count_defs_named(o, "Function", "z"));
    const CBMDefinition *z = NULL;
    for (int i = 0; i < o->defs.count; i++) {
        if (strcmp(o->defs.items[i].label, "Function") == 0 &&
            strcmp(o->defs.items[i].name, "z") == 0) {
            z = &o->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(z);
    ASSERT_EQ(2, (int)z->start_line);
    ASSERT_EQ(3, (int)z->end_line);
    ASSERT_TRUE(z->is_exported);
    cbm_free_result(o);
    PASS();
}

/* First definition with this name, for the Elixir clause-fold tests below.
 * find_def() is declared much further down this file. */
static const CBMDefinition *elixir_first_def(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0) {
            return &r->defs.items[i];
        }
    }
    return NULL;
}

/* A guarded clause head is a DECLARATION of the name, never a call to it, and
 * the call extractor has to agree with the def extractor about which node the
 * head is. It did not: it suppressed a head only when the head node IS the
 * def's first named argument, but `def f(x) when g` parses its whole head as a
 * `when` binary_operator, so the inner `f(x)` was not that argument and was
 * recorded as a call to `f`. Under the folded span that phantom lands inside
 * the function's own node, and self-recursion is decided by line containment,
 * so an ordinary two-clause guarded function reported itself recursive.
 * Recursion is a load-bearing signal: `recursive` is a queryable node property
 * and seeds the cycle detection in pass_complexity. */
TEST(extract_elixir_guarded_clause_head_is_not_a_self_call) {
    CBMFileResult *r = extract("defmodule Guarded do\n"                     /* 1 */
                               "  def f(x) when is_integer(x), do: x\n"     /* 2 */
                               "  def f(_x), do: 0\n"                       /* 3 */
                               "\n"                                         /* 4 */
                               "  def solo(x) when is_binary(x), do: x\n"   /* 5 */
                               "end\n",                                     /* 6 */
                               CBM_LANG_ELIXIR, "t", "guard_call.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* No call to either name exists anywhere in this file. */
    ASSERT_EQ(0, count_calls_named(r, "f"));
    ASSERT_EQ(0, count_calls_named(r, "solo"));
    /* The guard predicate IS a real call and stays one. */
    ASSERT_EQ(1, count_calls_named(r, "is_integer"));
    ASSERT_EQ(1, count_calls_named(r, "is_binary"));

    ASSERT_EQ(1, count_defs_named(r, "Function", "f"));
    const CBMDefinition *f = elixir_first_def(r, "f");
    ASSERT_NOT_NULL(f);
    ASSERT_EQ(2, (int)f->start_line);
    ASSERT_EQ(3, (int)f->end_line);
    ASSERT_FALSE(f->is_recursive);

    /* A single guarded clause was wrong even before the span widened: the
     * phantom landed on its own one-line node. */
    const CBMDefinition *solo = elixir_first_def(r, "solo");
    ASSERT_NOT_NULL(solo);
    ASSERT_FALSE(solo->is_recursive);
    cbm_free_result(r);
    PASS();
}

/* Every reference of any kind this file records for `name`, across all four
 * extractors the unified walk runs over one subtree: a call site, a value
 * usage, a read/write occurrence, a type reference. Suppressing a node in ONE
 * of them does not remove a phantom reference, it moves it -- handle_calls
 * declining a node leaves state->callee_expr unset, and handle_usages then
 * reaches the bare identifier and mints a USAGE instead. USAGE and CALLS are
 * separate rows in the edge table, so the relabelled phantom also escapes the
 * UNIQUE(source,target,type) dedup that had been collapsing it onto a real
 * call, and pass_importance counts an inbound reference that did not exist
 * before. An assertion naming only r->calls cannot see any of that. */
static int elixir_any_ref_count(CBMFileResult *r, const char *name) {
    int count = count_calls_named(r, name);
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && strcmp(r->usages.items[i].ref_name, name) == 0) {
            count++;
        }
    }
    for (int i = 0; i < r->rw.count; i++) {
        if (r->rw.items[i].var_name && strcmp(r->rw.items[i].var_name, name) == 0) {
            count++;
        }
    }
    for (int i = 0; i < r->type_refs.count; i++) {
        if (r->type_refs.items[i].type_name && strcmp(r->type_refs.items[i].type_name, name) == 0) {
            count++;
        }
    }
    return count;
}

/* The head suppression has to REMOVE the phantom, not relabel it. What makes
 * that hold for a def head is not the calls walk alone: is_elixir_def_binding in
 * extract_usages.c already treats everything inside a def's first argument as
 * a binding occurrence rather than a reference, so the identifier handle_calls
 * declines is declined by handle_usages too. That agreement is the invariant
 * under test, and it is why the counts below are over every extractor rather
 * than over r->calls.
 *
 * `spec_subject` pins the boundary between the two mechanisms. A typespec
 * subject is the same shape as a def head, and suppressing it in the calls walk
 * would only relabel its phantom as a USAGE, because nothing treats it as a
 * binding. It is removed instead by skipping the whole `@spec` subtree before
 * any extractor sees it (is_elixir_typespec_attribute, extract_unified.c), so
 * the assertion is both that no reference of any kind survives AND that what
 * does survive is never a relabelling: the equality holds at 0 == 0 here, and
 * would hold at 1 == 1 on a build with the subtree skip removed but the calls
 * suppression left in place. */
TEST(extract_elixir_declaration_head_mints_no_reference_of_any_kind) {
    CBMFileResult *r = extract("defmodule Heads do\n"                              /* 1 */
                               "  def guarded(x) when is_integer(x), do: x\n"      /* 2 */
                               "  def guarded(_x), do: 0\n"                        /* 3 */
                               "\n"                                                /* 4 */
                               "  defp bare(x), do: x\n"                           /* 5 */
                               "\n"                                                /* 6 */
                               "  @spec spec_subject(integer) :: integer\n"        /* 7 */
                               "  def spec_subject(n), do: n\n"                    /* 8 */
                               "end\n",                                            /* 9 */
                               CBM_LANG_ELIXIR, "t", "heads.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Nothing in this file references `guarded` or `bare`. Not as a call, not
     * as a value, not as a read/write, not as a type. */
    ASSERT_EQ(0, elixir_any_ref_count(r, "guarded"));
    ASSERT_EQ(0, elixir_any_ref_count(r, "bare"));
    /* The guard predicate is a real call and survives as one. */
    ASSERT_EQ(1, count_calls_named(r, "is_integer"));
    ASSERT_EQ(1, elixir_any_ref_count(r, "is_integer"));
    /* Neither the @spec line nor the def head it precedes leaves a reference,
     * and nothing has been relabelled into a usage, a read/write or a type
     * reference. */
    ASSERT_EQ(0, count_calls_named(r, "spec_subject"));
    ASSERT_EQ(count_calls_named(r, "spec_subject"),
              elixir_any_ref_count(r, "spec_subject"));

    ASSERT_EQ(1, count_defs_named(r, "Function", "guarded"));
    const CBMDefinition *guarded = elixir_first_def(r, "guarded");
    ASSERT_NOT_NULL(guarded);
    ASSERT_EQ(2, (int)guarded->start_line);
    ASSERT_EQ(3, (int)guarded->end_line);
    ASSERT_FALSE(guarded->is_recursive);
    cbm_free_result(r);
    PASS();
}

/* The other direction: suppressing declaration heads must not blind the
 * detector to real recursion, and folding must not lose a self-call written in
 * a clause that is no longer the surviving one. `walk` recurses from its
 * guarded second clause; exactly one call to `walk` is recorded (the body one,
 * not the two heads) and the folded node is recursive. */
TEST(extract_elixir_real_recursion_survives_head_suppression) {
    CBMFileResult *r = extract("defmodule Rec do\n"                                        /* 1 */
                               "  def walk([]), do: []\n"                                  /* 2 */
                               "  def walk([h | t]) when is_integer(h), do: [h | walk(t)]\n" /* 3 */
                               "end\n",                                                    /* 4 */
                               CBM_LANG_ELIXIR, "t", "rec.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(1, count_calls_named(r, "walk"));
    ASSERT_EQ(1, count_defs_named(r, "Function", "walk"));
    const CBMDefinition *walk = elixir_first_def(r, "walk");
    ASSERT_NOT_NULL(walk);
    ASSERT_EQ(2, (int)walk->start_line);
    ASSERT_EQ(3, (int)walk->end_line);
    ASSERT_TRUE(walk->is_recursive);
    cbm_free_result(r);
    PASS();
}

/* An Elixir module attribute parses as `unary_operator(@, call(<attr>, args))`,
 * so a typespec line reaches the unified walk as ordinary code and every symbol
 * it names collects a phantom inbound edge from the enclosing Module -- a CALLS
 * onto the specified function, and for `@type` a USAGE plus a WRITES asserting
 * a mutation that does not exist. On a codebase whose convention is @spec on
 * every public function, fan_in then never reaches 0 and "which exported
 * functions nothing calls" is unanswerable.
 *
 * All six heads in the skip list are exercised, so deleting any one entry from
 * typespec_heads[] breaks this test.
 *
 * Two of the groups below pin a decision rather than a repair, and both are
 * argued in is_elixir_typespec_attribute's comment:
 *
 *   type_refs[] -- a typespec's type references are not indexed at all. A type
 *   declaration mints no node, so such a reference resolves onto nothing or
 *   onto a same-named FUNCTION, which is the pollution rather than a record of
 *   it. Restoring any of them must break this test.
 *
 *   behaviour_contract_names[] -- accepted cost. A @callback / @macrocallback
 *   name is a function name, so before this change it resolved cross-file onto
 *   the functions implementing the behaviour. Nothing replaces that edge.
 *
 * The attribute NAME phantom outside the typespec family is deliberately still
 * there: `@timeout` keeps its one reference, and its VALUE is ordinary
 * compile-time code that still runs. `guarded` is pinned at 0 rather than 1
 * because the guarded def head no longer mints a phantom either -- the calls
 * walk now recognises a `when`-wrapped head as a declaration. */
TEST(extract_elixir_typespec_attribute_is_not_code) {
    /* Names a typespec declares, plus the six attribute heads themselves.
     * Every one carries a reference on the pristine build. */
    static const char *const declared[] = {"with_spec", "entry",  "secret",  "handle",
                                           "spec",      "type",   "typep",   "opaque",
                                           "callback",  "macrocallback", NULL};
    /* Accepted cost: these used to resolve onto the behaviour's implementors. */
    static const char *const behaviour_contract_names[] = {"handle_it", "expand_it", NULL};
    /* Pinned decision: type references are not indexed -- remote, bare-local
     * and builtin alike. */
    static const char *const type_refs[] = {"MyApp.User.t", "String.t", "MyApp.Vault.key",
                                            "Macro.t",      "t",        "key",
                                            "term",         "integer",  "reference",
                                            "atom",         NULL};
    CBMFileResult *r = extract("defmodule Specced do\n"
                               "  @timeout Application.compile_env(:app, :timeout)\n"
                               "  @type entry :: String.t()\n"
                               "  @typep secret :: MyApp.Vault.key()\n"
                               "  @opaque handle :: reference()\n"
                               "  @callback handle_it(term) :: :ok\n"
                               "  @macrocallback expand_it(term) :: Macro.t()\n"
                               "  @spec with_spec(MyApp.User.t()) :: integer\n"
                               "  def with_spec(n), do: n\n"
                               "  def without_spec(n), do: n\n"
                               "  @spec guarded(atom) :: :ok\n"
                               "  def guarded(x) when is_atom(x), do: :ok\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "specced.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The definitions themselves are a separate pass and are unaffected. */
    ASSERT(has_def(r, "Function", "with_spec"));
    ASSERT(has_def(r, "Function", "without_spec"));
    ASSERT(has_def(r, "Function", "guarded"));
    /* Control on the instrument, not a pin: `without_spec` carries no typespec
     * and is never called, so it reads 0 on the pristine build too. It is here
     * to show elixir_any_ref_count does not score a definition as a reference,
     * which is what would make every 0 below vacuous. It cannot fail first and
     * cannot catch a regression. */
    ASSERT_EQ(0, elixir_any_ref_count(r, "without_spec"));
    for (const char *const *name = declared; *name; name++) {
        ASSERT_EQ(0, elixir_any_ref_count(r, *name));
    }
    for (const char *const *name = behaviour_contract_names; *name; name++) {
        ASSERT_EQ(0, elixir_any_ref_count(r, *name));
    }
    for (const char *const *name = type_refs; *name; name++) {
        ASSERT_EQ(0, elixir_any_ref_count(r, *name));
    }
    /* A non-typespec attribute is untouched: its value really is compile-time
     * code, and its name still mints the one phantom this fix does not close. */
    ASSERT_EQ(1, count_calls_named(r, "Application.compile_env"));
    ASSERT_EQ(1, elixir_any_ref_count(r, "timeout"));
    /* Both phantoms onto `guarded` are gone: the @spec one to the subtree skip,
     * the def-head one to the calls walk recognising a guarded head. */
    ASSERT_EQ(0, elixir_any_ref_count(r, "guarded"));
    cbm_free_result(r);
    PASS();
}

/* tree-sitter-elixir gives a call's arguments node no field name, so the
 * generic `arguments` field lookup returns null and first_string_arg was never
 * populated for any Elixir call — Phoenix route paths, service URLs and config
 * keys all key off it. */
TEST(elixir_call_string_argument) {
    CBMFileResult *r = extract("defmodule Sample do\n"
                               "  def run do\n"
                               "    get(\"/wallets\", WalletController)\n"
                               "  end\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "sample.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int seen = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "get") != 0) {
            continue;
        }
        seen = 1;
        ASSERT_NOT_NULL(r->calls.items[i].first_string_arg);
        ASSERT_STR_EQ("/wallets", r->calls.items[i].first_string_arg);
    }
    ASSERT_EQ(1, seen);
    cbm_free_result(r);
    PASS();
}

/* True when a channel with this name/transport/direction was extracted. */
static int has_channel(CBMFileResult *r, const char *name, const char *transport,
                       CBMChannelDirection dir) {
    for (int i = 0; i < r->channels.count; i++) {
        const CBMChannel *c = &r->channels.items[i];
        if (c->channel_name && strcmp(c->channel_name, name) == 0 && c->transport &&
            strcmp(c->transport, transport) == 0 && c->direction == dir)
            return 1;
    }
    return 0;
}

/* Phoenix pub/sub and channel listeners. Both branches were unreachable: the
 * emit side looked up an "arguments" FIELD that tree-sitter-elixir does not
 * define, and the listener side dispatched on a "def" NODE TYPE that does not
 * exist (Elixir defs are `call` nodes), so a Phoenix app produced no channels
 * at all. */
TEST(elixir_channels_pubsub_and_handle_in) {
    CBMFileResult *r =
        extract("defmodule Acme.Notifier do\n"
                "  def announce(p) do\n"
                "    Phoenix.PubSub.broadcast(Acme.PubSub, \"user:created\", p)\n"
                "  end\n"
                "  def watch, do: Phoenix.PubSub.subscribe(Acme.PubSub, \"user:updated\")\n"
                "end\n"
                "defmodule AcmeWeb.RoomChannel do\n"
                "  def handle_in(\"new_msg\", payload, socket) do\n"
                "    push(socket, \"pong\", %{})\n"
                "    {:noreply, socket}\n"
                "  end\n"
                "  def handle_in(\"ping\", _p, socket) when is_map(socket) do\n"
                "    {:noreply, socket}\n"
                "  end\n"
                "end\n",
                CBM_LANG_ELIXIR, "t", "chan.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_channel(r, "user:created", "phoenix_pubsub", CBM_CHANNEL_EMIT));
    ASSERT(has_channel(r, "user:updated", "phoenix_pubsub", CBM_CHANNEL_LISTEN));
    /* handle_in clauses are listeners — including the guarded one. */
    ASSERT(has_channel(r, "new_msg", "phoenix_channel", CBM_CHANNEL_LISTEN));
    ASSERT(has_channel(r, "ping", "phoenix_channel", CBM_CHANNEL_LISTEN));
    /* A bare push/broadcast inside the channel module is an emit. */
    ASSERT(has_channel(r, "pong", "phoenix_channel", CBM_CHANNEL_EMIT));
    cbm_free_result(r);
    PASS();
}

/* Elixir control flow is `call` nodes and `stab_clause` arms, not branch node
 * TYPES, so the generic complexity walk scored every Elixir function 0 and the
 * fingerprint was never computed at all — no similarity or duplicate detection. */
TEST(elixir_complexity_and_fingerprint) {
    CBMFileResult *r = extract("defmodule Cx do\n"
                               "  def classify(x) do\n"
                               "    case x do\n"
                               "      0 -> :zero\n"
                               "      n when n > 0 -> :pos\n"
                               "      _ -> :neg\n"
                               "    end\n"
                               "  end\n"
                               "  def plain(a), do: a\n"
                               "  def summarize(orders, currency) do\n"
                               "    totals = Enum.map(orders, fn order -> order.amount * order.rate end)\n"
                               "    count = length(totals)\n"
                               "    sum = Enum.reduce(totals, 0, fn value, acc -> acc + value end)\n"
                               "    average = if count > 0, do: sum / count, else: 0\n"
                               "    label = String.upcase(currency) <> \" total\"\n"
                               "    %{label: label, sum: sum, count: count, average: average}\n"
                               "  end\n"
                               "  def tally(items, unit) do\n"
                               "    values = Enum.map(items, fn item -> item.price * item.qty end)\n"
                               "    n = length(values)\n"
                               "    total = Enum.reduce(values, 0, fn v, a -> a + v end)\n"
                               "    mean = if n > 0, do: total / n, else: 0\n"
                               "    tag = String.upcase(unit) <> \" total\"\n"
                               "    %{tag: tag, total: total, n: n, mean: mean}\n"
                               "  end\n"
                               "end\n",
                               CBM_LANG_ELIXIR, "t", "cx.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    CBMDefinition *cls = NULL;
    CBMDefinition *plain = NULL;
    CBMDefinition *summarize = NULL;
    CBMDefinition *tally = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "classify") == 0)
            cls = &r->defs.items[i];
        if (strcmp(r->defs.items[i].name, "plain") == 0)
            plain = &r->defs.items[i];
        if (strcmp(r->defs.items[i].name, "summarize") == 0)
            summarize = &r->defs.items[i];
        if (strcmp(r->defs.items[i].name, "tally") == 0)
            tally = &r->defs.items[i];
    }
    /* A body past the MinHash size gate gets a fingerprint (Elixir used to emit
     * none at all); a one-expression body stays below the gate and gets none. */
    ASSERT_NOT_NULL(summarize);
    ASSERT(summarize->fingerprint_k > 0);
    ASSERT_NOT_NULL(summarize->fingerprint);
    /* Duplicate detection is what the fingerprint exists for: the same body
     * shape under other function and variable names gets the same fingerprint. */
    ASSERT_NOT_NULL(tally);
    ASSERT_EQ(summarize->fingerprint_k, tally->fingerprint_k);
    ASSERT_NOT_NULL(tally->fingerprint);
    ASSERT(memcmp(summarize->fingerprint, tally->fingerprint,
                  (size_t)summarize->fingerprint_k * sizeof(summarize->fingerprint[0])) == 0);
    ASSERT_NOT_NULL(cls);
    /* The `case` itself + its 3 arms + the second arm's own `when` guard. */
    ASSERT_EQ(5, cls->complexity);
    ASSERT(cls->cognitive > 0);
    ASSERT(cls->lines > 0);
    /* A straight-line body has no decisions but still gets a line count — a
     * language must not become nonzero everywhere just by being measured. */
    ASSERT_NOT_NULL(plain);
    ASSERT_EQ(0, plain->complexity);
    ASSERT(plain->lines > 0);
    ASSERT_EQ(0, plain->fingerprint_k);
    cbm_free_result(r);
    PASS();
}

/* The clauses of a multi-clause function fold into one Function node, so that
 * node's metrics must cover every clause, not just the first: branch, cognitive
 * and loop counts add up, loop_depth and max_access_depth take the deepest
 * clause, every clause past the first is one more dispatch decision, and
 * `lines` is the folded span. `single` repeats the second clause on its own as
 * the per-clause reference: it is not folded, so it carries no dispatch charge. */
TEST(elixir_folded_clause_metrics_cover_every_clause) {
    CBMFileResult *r = extract("defmodule Route do\n"                             /* 1 */
                               "  def pick(0), do: Map.new()\n"                   /* 2 */
                               "  def pick(n) when n > 0 do\n"                    /* 3 */
                               "    for x <- [n], do: Map.new([{x, x}])\n"        /* 4 */
                               "  end\n"                                          /* 5 */
                               "  def pick(rows) do\n"                            /* 6 */
                               "    for row <- rows, do: (for x <- row, do: x)\n" /* 7 */
                               "  end\n"                                          /* 8 */
                               "  def single(n) when n > 0 do\n"                  /* 9 */
                               "    for x <- [n], do: Map.new([{x, x}])\n"        /* 10 */
                               "  end\n"                                          /* 11 */
                               "end\n",                                           /* 12 */
                               CBM_LANG_ELIXIR, "t", "route.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(1, count_defs_named(r, "Function", "pick"));
    const CBMDefinition *one = elixir_first_def(r, "single");
    ASSERT_NOT_NULL(one);
    /* `when` + `for`, each at nesting 0; one comprehension; Map.new is one dot */
    ASSERT_EQ(2, one->complexity);
    ASSERT_EQ(2, one->cognitive);
    ASSERT_EQ(1, one->loop_count);
    ASSERT_EQ(1, one->loop_depth);
    ASSERT_EQ(1, one->max_access_depth);
    ASSERT_EQ(3, one->lines);

    const CBMDefinition *pick = elixir_first_def(r, "pick");
    ASSERT_NOT_NULL(pick);
    ASSERT_EQ(2, (int)pick->start_line);
    ASSERT_EQ(8, (int)pick->end_line);
    /* clauses 0 + 2 + 2, plus 2 for the two clauses past the first */
    ASSERT_EQ(6, pick->complexity);
    /* 0 + 2 + (1 + 2): the inner comprehension sits one level deep */
    ASSERT_EQ(5, pick->cognitive);
    ASSERT_EQ(3, pick->loop_count);
    /* the deepest clause, not the sum of the clauses (that would be 3) */
    ASSERT_EQ(2, pick->loop_depth);
    /* two clauses with one dot each: the deepest is 1, the sum would be 2 */
    ASSERT_EQ(1, pick->max_access_depth);
    ASSERT_EQ(7, pick->lines);
    cbm_free_result(r);
    PASS();
}

/* The Elixir complexity walk keeps its pending nodes on the growable stack
 * cbm_compute_complexity uses. A fixed 4096-frame stack dropped the FIRST
 * children of any wider body (they are pushed last-to-first), so the largest
 * functions silently under-reported. This body is wider than that old cap. */
enum { ELIXIR_WIDE_STMTS = 5000 };

TEST(elixir_complexity_wide_body_exceeds_old_stack_cap) {
    static const char head[] = "defmodule Wide do\n  def wide(x) do\n";
    static const char if_stmt[] = "    if x, do: :a\n";
    static const char for_stmt[] = "    for y <- x, do: y\n";
    static const char tail[] = "  end\nend\n";
    size_t cap = sizeof(head) + (size_t)ELIXIR_WIDE_STMTS * sizeof(for_stmt) + sizeof(tail);
    char *src = malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t pos = (size_t)snprintf(src, cap, "%s", head);
    for (int i = 0; i < ELIXIR_WIDE_STMTS; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos, "%s", (i % 2 == 0) ? if_stmt : for_stmt);
    }
    snprintf(src + pos, cap - pos, "%s", tail);
    CBMFileResult *r = extract(src, CBM_LANG_ELIXIR, "t", "wide.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = elixir_first_def(r, "wide");
    ASSERT_NOT_NULL(d);
    /* every `if` and every `for` is one branching call at nesting depth 0 */
    ASSERT_EQ(ELIXIR_WIDE_STMTS, d->complexity);
    ASSERT_EQ(ELIXIR_WIDE_STMTS, d->cognitive);
    ASSERT_EQ(ELIXIR_WIDE_STMTS / 2, d->loop_count);
    ASSERT_EQ(1, d->loop_depth);
    cbm_free_result(r);
    free(src);
    PASS();
}

/* --- Haskell --- */
TEST(haskell_function) {
    CBMFileResult *r = extract("add :: Int -> Int -> Int\nadd x y = x + y\n\nmultiply :: Int -> "
                               "Int -> Int\nmultiply x y = x * y\n",
                               CBM_LANG_HASKELL, "t", "Math.hs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* #2440: an infix-form definition (`a <+> b = ...`, ``x `plus` y = ...``) has
 * no `name` field; its first named child is an `infix` node whose first child
 * is the LEFT OPERAND, so the def was named `a` / `x`. It must be named after
 * the operator, consistent with the prefix form `(<+>) a b = ...`. */
TEST(haskell_infix_definition_name) {
    CBMFileResult *r = extract("module M where\n"
                               "\n"
                               "(<+>) :: Int -> Int -> Int\n"
                               "a <+> b = a + b\n"
                               "\n"
                               "plus :: Int -> Int -> Int\n"
                               "x `plus` y = x + y\n"
                               "\n"
                               "f :: Int\n"
                               "f = 1 <+> 2\n",
                               CBM_LANG_HASKELL, "t", "M.hs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "f"));
    ASSERT(has_def(r, "Function", "plus"));
    ASSERT(has_def(r, "Function", "(<+>)"));
    ASSERT_FALSE(has_def(r, "Function", "a"));
    ASSERT_FALSE(has_def(r, "Function", "x"));
    cbm_free_result(r);
    PASS();
}

/* --- OCaml --- */
TEST(ocaml_function) {
    CBMFileResult *r =
        extract("let add x y = x + y\nlet multiply x y = x * y\n", CBM_LANG_OCAML, "t", "math.ml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Erlang --- */
TEST(erlang_function) {
    CBMFileResult *r = extract(
        "-module(math).\n-export([add/2]).\nadd(X, Y) -> X + Y.\nmultiply(X, Y) -> X * Y.\n",
        CBM_LANG_ERLANG, "t", "math.erl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group E: Markup / Config / Helper Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- YAML --- */
TEST(yaml_variables) {
    CBMFileResult *r =
        extract("name: myapp\nversion: 1.0\ndatabase:\n  host: localhost\n  port: 5432\n",
                CBM_LANG_YAML, "t", "config.yml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* YAML should extract top-level keys as variables */
    ASSERT_GT(r->defs.count, 0);
    cbm_free_result(r);
    PASS();
}

/* --- HCL --- */
TEST(hcl_blocks) {
    CBMFileResult *r = extract("resource \"aws_instance\" \"web\" {\n  ami = \"abc-123\"\n  "
                               "instance_type = \"t2.micro\"\n}\n"
                               "variable \"region\" {\n  default = \"us-east-1\"\n}\n",
                               CBM_LANG_HCL, "t", "main.tf");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->defs.count, 0);
    /* Block labels are folded into the name so blocks are distinguishable (#337). */
    ASSERT(has_def(r, "Class", "resource.aws_instance.web"));
    ASSERT(has_def(r, "Class", "variable.region"));
    cbm_free_result(r);
    PASS();
}

/* --- SQL --- */
TEST(sql_create_table) {
    CBMFileResult *r = extract("CREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT "
                               "NULL\n);\nCREATE VIEW active_users AS SELECT * FROM users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Dockerfile --- */
TEST(dockerfile_stages) {
    CBMFileResult *r = extract(
        "FROM node:18 AS builder\nRUN npm install\nFROM node:18-slim\nCOPY --from=builder /app .\n",
        CBM_LANG_DOCKERFILE, "t", "Dockerfile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group F: Scientific / Math Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- MATLAB --- */
TEST(matlab_function) {
    CBMFileResult *r =
        extract("function y = square(x)\n  y = x.^2;\nend\n", CBM_LANG_MATLAB, "t", "square.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "square"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean 4 --- */
TEST(lean_function) {
    CBMFileResult *r =
        extract("def add (x y : Nat) : Nat := x + y\n", CBM_LANG_LEAN, "t", "Math.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- FORM --- */
TEST(form_procedure) {
    CBMFileResult *r = extract("#procedure doSomething\n  id x = y;\n#endprocedure\n",
                               CBM_LANG_FORM, "t", "test.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "doSomething"));
    cbm_free_result(r);
    PASS();
}

/* --- Oracle PL/SQL --- */
TEST(plsql_package_and_call) {
    const char *src = "CREATE OR REPLACE PACKAGE BODY emp_pkg AS\n"
                      "  FUNCTION hire(p_name VARCHAR2) RETURN NUMBER IS\n"
                      "    v_sal NUMBER;\n"
                      "  BEGIN\n"
                      "    v_sal := util_pkg.calc_salary(p_name);\n"
                      "    IF v_sal > 0 THEN\n"
                      "      RETURN v_sal;\n"
                      "    END IF;\n"
                      "    RAISE no_data_found;\n"
                      "  END;\n"
                      "END emp_pkg;\n"
                      "/\n";
    CBMFileResult *r = extract(src, CBM_LANG_PLSQL, "t", "emp_pkg.pkb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "emp_pkg"));
    ASSERT(has_def_any(r, "hire"));
    ASSERT(has_call(r, "util_pkg.calc_salary"));
    cbm_free_result(r);
    PASS();
}

TEST(plsql_standalone_function) {
    /* create_function wraps a body (which ends with END) plus an outer END. */
    const char *src = "CREATE OR REPLACE FUNCTION get_bonus RETURN NUMBER IS\n"
                      "BEGIN\n"
                      "  RETURN 1;\n"
                      "END;\n"
                      "END get_bonus;\n"
                      "/\n";
    CBMFileResult *r = extract(src, CBM_LANG_PLSQL, "t", "get_bonus.fnc");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "get_bonus"));
    cbm_free_result(r);
    PASS();
}

TEST(plsql_create_type_as_object_limitation) {
    /* Known grammar limitation: CREATE TYPE ... AS OBJECT yields ERROR nodes
     * (AndreasMaierDe/tree-sitter-plsql @ 28aebef209be). Documented in
     * tests/fixtures/plsql/create_type_as_object_limitation.tps — do not expect
     * a Class def until the upstream grammar improves. */
    const char *src = "CREATE OR REPLACE TYPE address_t AS OBJECT (\n"
                      "  street VARCHAR2(100),\n"
                      "  city   VARCHAR2(50)\n"
                      ");\n"
                      "/\n";
    CBMFileResult *r = extract(src, CBM_LANG_PLSQL, "t", "address.tps");
    ASSERT_NOT_NULL(r);
    /* Pin the limitation positively: the tree contains ERROR/MISSING nodes.
     * When a grammar upgrade clears this, this assertion goes RED — then
     * expect the Class def here instead of the absence below. */
    ASSERT(r->parse_incomplete);
    /* Must not crash; Class extraction is best-effort and currently absent. */
    ASSERT(!has_def(r, "Class", "address_t"));
    cbm_free_result(r);
    PASS();
}

/* --- Chialisp ---
 *
 * Three defects in the only public Chialisp grammar
 * (Quexington/tree-sitter-chialisp) motivated writing our own, and each is
 * pinned below as a parse-level assertion rather than a note: comments that
 * required CRLF to terminate, `(include foo.clib)` rejected because of the dot
 * in the filename, and `(defconstant NAME <expr>)` accepting only a primitive.
 * All three desynchronised the rest of the file, so a regression here shows up
 * as `has_error` plus missing defs, not as one lost node. */
TEST(chialisp_puzzle_defs_and_labels) {
    const char *src = "; a Chialisp puzzle\n"
                      "(mod (ARG)\n"
                      "  (include condition_codes.clib)\n"
                      "  (defconstant TWO 2)\n"
                      "  (defconstant HASH (sha256 1))\n"
                      "  (defun-inline square (x) (* x x))\n"
                      "  (defun apply_twice (v) (square (square v)))\n"
                      "  (defmacro assert items (f items))\n"
                      "  (apply_twice ARG)\n"
                      ")\n";
    CBMFileResult *r = extract(src, CBM_LANG_CHIALISP, "t", "puzzles/my_puzzle.clsp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* `mod` has no name of its own — the puzzle is named by its file. */
    ASSERT(has_def(r, "Module", "my_puzzle"));
    /* Defs are NESTED inside `(mod ...)`; a walk that stops at the module
     * loses every one of them. */
    ASSERT(has_def(r, "Function", "square"));
    ASSERT(has_def(r, "Function", "apply_twice"));
    ASSERT(has_def(r, "Macro", "assert"));
    /* `defconstant` binds an arbitrary EXPRESSION, not just a primitive. */
    ASSERT(has_def(r, "Constant", "TWO"));
    ASSERT(has_def(r, "Constant", "HASH"));
    /* A dotted include filename resolves as one symbol. */
    ASSERT(has_import(r, "condition_codes.clib"));
    /* Real calls survive; CLVM primitives and def heads do not become calls. */
    ASSERT(has_call(r, "square"));
    ASSERT(has_call(r, "apply_twice"));
    ASSERT(!has_call(r, "sha256"));
    ASSERT(!has_call(r, "defun"));
    ASSERT(!has_call(r, "mod"));
    ASSERT(!has_call(r, "include"));
    /* A parameter list is a `list` too — but it binds, it does not invoke. */
    ASSERT(!has_call(r, "x"));
    ASSERT(!has_call(r, "v"));
    ASSERT(!has_call(r, "items"));
    cbm_free_result(r);
    PASS();
}

TEST(chialisp_comment_line_endings) {
    /* LF, CRLF, and a comment closed by EOF with no trailing newline. The
     * public grammar's comment rule was `/;.*\r\n/`, so an LF file lost every
     * form after the first comment. */
    const char *lf = "(mod (A)\n; note\n(defun f (x) x)\n)\n";
    const char *crlf = "(mod (A)\r\n; note\r\n(defun f (x) x)\r\n)\r\n";
    const char *eof = "(mod (A)\n(defun f (x) x)\n)\n; trailing comment, no newline";
    const char *srcs[] = {lf, crlf, eof};
    for (int i = 0; i < 3; i++) {
        CBMFileResult *r = extract(srcs[i], CBM_LANG_CHIALISP, "t", "c.clsp");
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        ASSERT_FALSE(r->parse_incomplete);
        ASSERT(has_def(r, "Function", "f"));
        cbm_free_result(r);
    }
    PASS();
}

TEST(chialisp_library_defs_and_quoted_data) {
    /* A .clib wraps its definitions in one enclosing list, and its macros embed
     * puzzle-shaped literals under `(q ...)`. Those literals are DATA: a def
     * head or call symbol inside one must mint nothing. */
    const char *src = "(\n"
                      "  (defconstant TWO 2)\n"
                      "  (defmacro emit () (q . (defun ghost (x) (real_helper x))))\n"
                      "  (defun real_helper (x) (+ x TWO))\n"
                      ")\n";
    CBMFileResult *r = extract(src, CBM_LANG_CHIALISP, "t", "curry.clib");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Constant", "TWO"));
    ASSERT(has_def(r, "Macro", "emit"));
    ASSERT(has_def(r, "Function", "real_helper"));
    ASSERT(!has_def_any(r, "ghost"));
    ASSERT(!has_call(r, "real_helper"));
    cbm_free_result(r);
    PASS();
}

TEST(chialisp_export_names_do_not_duplicate_defs) {
    /* `(export foo)` names a function already defined in the same file. As a
     * def head it would mint a SECOND node for `foo`; as a call head it would
     * mint a phantom call. It is neither. */
    const char *src = "(\n"
                      "  (defun foo (x) x)\n"
                      "  (export foo)\n"
                      ")\n";
    CBMFileResult *r = extract(src, CBM_LANG_CHIALISP, "t", "e.clsp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int foo_defs = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, "foo") == 0) {
            foo_defs++;
        }
    }
    ASSERT_EQ(foo_defs, 1);
    ASSERT(!has_call(r, "export"));
    ASSERT(!has_call(r, "foo"));
    cbm_free_result(r);
    PASS();
}

TEST(chialisp_comment_before_def_head_keeps_the_name) {
    /* Comments are NAMED nodes and so occupy named-child indices. A comment
     * between the head and the name shifts them by one; defs and call-scope
     * must skip comments the same way or they stop describing the same tree. */
    const char *src = "(mod ()\n"
                      "  (defun ; why this exists\n"
                      "     documented (x) (* x 2))\n"
                      "  (defun caller () (documented 21))\n"
                      ")\n";
    CBMFileResult *r = extract(src, CBM_LANG_CHIALISP, "t", "d.clsp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "documented"));
    ASSERT(has_def(r, "Function", "caller"));
    ASSERT(has_call(r, "documented"));
    cbm_free_result(r);
    PASS();
}

TEST(chialisp_dialect_sigil_is_not_a_file_import) {
    /* `(include *standard-cl-26*)` selects a dialect; recording it as an import
     * invents a dependency on a file that does not exist. The compiler filters
     * `*...*` names and so must we. */
    const char *src = "(mod ()\n"
                      "  (include *standard-cl-26*)\n"
                      "  (include curry.clib)\n"
                      ")\n";
    CBMFileResult *r = extract(src, CBM_LANG_CHIALISP, "t", "s.clsp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_import(r, "curry.clib"));
    ASSERT(!has_import(r, "standard-cl-26"));
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram --- */
TEST(wolfram_function) {
    CBMFileResult *r =
        extract("square[x_] := x^2\nadd[x_, y_] := x + y\n", CBM_LANG_WOLFRAM, "t", "math.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "square"));
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma --- */
TEST(magma_function) {
    CBMFileResult *r = extract("function Factorial(n)\n  if n le 1 then\n    return 1;\n  end "
                               "if;\n  return n * Factorial(n - 1);\nend function;\n",
                               CBM_LANG_MAGMA, "t", "test.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Factorial"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group G: v0.5 Expansion Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- F# --- */
TEST(fsharp_function) {
    /* Go test only asserts >=1 def — F# name extraction is incomplete */
    CBMFileResult *r = extract("module Greeter\nlet greet name = sprintf \"Hello %s\" name\n",
                               CBM_LANG_FSHARP, "t", "Greeter.fs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Julia --- */
TEST(julia_function) {
    CBMFileResult *r = extract("function add(x, y)\n    x + y\nend\nadd2(x, y) = x + y\n",
                               CBM_LANG_JULIA, "t", "math.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Elm --- */
TEST(elm_function) {
    CBMFileResult *r =
        extract("add x y = x + y\nmultiply x y = x * y\n", CBM_LANG_ELM, "t", "Math.elm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Nix --- */
TEST(nix_function) {
    CBMFileResult *r =
        extract("{ pkgs ? import <nixpkgs> {} }:\nlet\n  hello = pkgs.writeShellScriptBin "
                "\"hello\" ''echo hello'';\nin { inherit hello; }\n",
                CBM_LANG_NIX, "t", "default.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* A Nix file's root expression is normally itself a function (`{ pkgs, lib, ... }:`)
 * — the near-universal library/module header. Definitions must survive that header.
 * Each shape below is asserted separately so a regression names the shape it broke.
 * `nix_function` above deliberately stays as-is: its binding is an application, not
 * a function, so it pins the "parses, no def" case and cannot cover this. */
TEST(nix_defs_in_let_rooted_file) {
    CBMFileResult *r = extract("let\n  alpha = x: x + 1;\n  beta = { a, b }: a + b;\nin\n"
                               "{ inherit alpha beta; }\n",
                               CBM_LANG_NIX, "t", "bare.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "alpha"));
    ASSERT(has_def(r, "Function", "beta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_in_attrset_rooted_file) {
    CBMFileResult *r = extract("{\n  epsilon = x: x + 1;\n  zeta = { a, b }: a + b;\n}\n",
                               CBM_LANG_NIX, "t", "attrset.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "epsilon"));
    ASSERT(has_def(r, "Function", "zeta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_in_nested_let) {
    CBMFileResult *r = extract("let\n  outer =\n    let theta = x: x + 1;\n    in theta;\n"
                               "in\n{ inherit outer; }\n",
                               CBM_LANG_NIX, "t", "nested.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "theta"));
    cbm_free_result(r);
    PASS();
}

/* The regression this suite previously could not see: the root `{ prelude }:` matches
 * nix_func_types, resolves no name of its own, and — before the fix — terminated the
 * walk, so nothing below the header was ever visited. */
TEST(nix_defs_survive_function_header_let) {
    CBMFileResult *r = extract("{ prelude }:\nlet\n  gamma = x: x + 1;\n"
                               "  delta = { a, b }: a + b;\nin\n{ inherit gamma delta; }\n",
                               CBM_LANG_NIX, "t", "wrapped.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "gamma"));
    ASSERT(has_def(r, "Function", "delta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_survive_function_header_attrset) {
    CBMFileResult *r = extract("{ prelude }:\n{\n  eta = x: x + 1;\n}\n", CBM_LANG_NIX, "t",
                               "wrapped_attrset.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "eta"));
    cbm_free_result(r);
    PASS();
}

/* A curried header — `final: prev: { … }` is the standard nixpkgs overlay signature, and
 * the most common multi-arm header in the ecosystem. Two nested function_expressions sit
 * between the file root and the body. */
TEST(nix_defs_survive_curried_header) {
    CBMFileResult *r =
        extract("final: prev: {\n  kappa = x: x + 1;\n}\n", CBM_LANG_NIX, "t", "overlay.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "kappa"));
    cbm_free_result(r);
    PASS();
}

/* A Nix binding's name is a PATH, and the extractor previously took only its first
 * segment. Convention here matches C++ namespaces — `ns::serialize` is name
 * `serialize`, QN `proj.file.ns.serialize` — so a Nix binding is name = leaf
 * segment, QN = enclosing scope + leaf. */
TEST(nix_attrset_scope_disambiguates_leaf_names) {
    CBMFileResult *r =
        extract("{\n  setA = { dup = x: x + 1; };\n  setB = { dup = y: y + 2; };\n}\n",
                CBM_LANG_NIX, "t", "collide.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Both survive. Unqualified, these shared one QN, so the second definition —
     * and every CALLS edge sourced from it — was silently discarded at write. */
    ASSERT(count_defs_with_label(r, "Function") == 2);
    ASSERT(has_def_qn(r, "t.collide.setA.dup"));
    ASSERT(has_def_qn(r, "t.collide.setB.dup"));
    cbm_free_result(r);
    PASS();
}

/* `a.b.fn = …` is sugar for `a = { b = { fn = …; }; }`. Both spellings must yield
 * the same name and the same QN; the leading segments are scope, not name. */
TEST(nix_dotted_attrpath_qualifies_like_nested) {
    CBMFileResult *r = extract("{\n  wrap.deep.fn = z: z + 1;\n}\n", CBM_LANG_NIX, "t", "d.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fn"));
    ASSERT(has_def_qn(r, "t.d.wrap.deep.fn"));

    CBMFileResult *n =
        extract("{\n  wrap = { deep = { fn = z: z + 1; }; };\n}\n", CBM_LANG_NIX, "t", "d.nix");
    ASSERT_NOT_NULL(n);
    ASSERT_FALSE(n->has_error);
    /* The equality that makes this a correctness fix rather than a preference. */
    ASSERT(has_def_qn(n, "t.d.wrap.deep.fn"));
    cbm_free_result(n);
    cbm_free_result(r);
    PASS();
}

/* A quoted segment is an ordinary name that merely needs quoting in source. The
 * delimiters are not part of it, and leaving them in means every consumer keying
 * on the name has to know to re-quote. */
TEST(nix_quoted_attr_name_strips_quotes) {
    CBMFileResult *r = extract("{\n  \"kebab-case\" = a: a;\n  svc.\"my.name\" = b: b;\n}\n",
                               CBM_LANG_NIX, "t", "q.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "kebab-case"));
    ASSERT_FALSE(has_def_any(r, "\"kebab-case\""));
    ASSERT(has_def_qn(r, "t.q.kebab-case"));
    /* A quoted segment may itself contain dots; they are part of the name, not
     * path separators, but the QN is a dotted string either way. */
    ASSERT(has_def(r, "Function", "my.name"));
    cbm_free_result(r);
    PASS();
}

/* `"${x}" = …` has no statically knowable name. Minting it produces a def named
 * `"${x}"` that nothing can look up or resolve a call against, so mint nothing —
 * the same call the Makefile dot-prefix guard makes. */
TEST(nix_interpolated_attr_mints_no_def) {
    CBMFileResult *r =
        extract("{\n  \"${dynamic}\" = a: a;\n  fixed = b: b;\n}\n", CBM_LANG_NIX, "t", "i.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fixed"));
    ASSERT(count_defs_with_label(r, "Function") == 1);
    cbm_free_result(r);
    PASS();
}

/* Nix Variables. `nix_var_types` has always declared `binding`, but no Nix name
 * resolver existed, so the count was unconditionally zero.
 *
 * Scope follows the rule every other language uses: extract_variables mints FILE
 * scope and never locals — a C++ declaration inside a function body is not a
 * Variable. For Nix, file scope is the `let` bindings and the returned attrset;
 * anything in a deeper attrset is not. Without that bound a NixOS module's
 * settings tree would mint a node per `enable = true`. */
TEST(nix_module_level_bindings_mint_variables) {
    CBMFileResult *r = extract("{ pkgs, lib, ... }:\n"
                               "let\n"
                               "  privateConst = 42;\n"
                               "in\n"
                               "{\n"
                               "  exported = \"value\";\n"
                               "  services.nginx.enable = true;\n"
                               "}\n",
                               CBM_LANG_NIX, "t", "mod.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* A let binding is file scope in the same sense a C++ file-static is. */
    ASSERT(has_def(r, "Variable", "privateConst"));
    ASSERT(has_def(r, "Variable", "exported"));
    /* The QN carries the attrpath, exactly as it does for functions. */
    ASSERT(has_def(r, "Variable", "enable"));
    ASSERT(has_def_qn(r, "t.mod.services.nginx.enable"));
    cbm_free_result(r);
    PASS();
}

/* The flood guard. Each absence assertion is paired with a positive one on the
 * same predicate in the same result, so none can pass by extracting nothing. */
TEST(nix_nested_bindings_are_not_module_level) {
    CBMFileResult *r = extract("{ pkgs }:\n"
                               "{\n"
                               "  topLevel = 1;\n"
                               "  deep = {\n"
                               "    nested = {\n"
                               "      shouldNotAppear = 2;\n"
                               "    };\n"
                               "  };\n"
                               "}\n",
                               CBM_LANG_NIX, "t", "deep.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "topLevel")); /* positive control */
    ASSERT_FALSE(has_def_any(r, "shouldNotAppear"));
    /* `deep` is an attrset — a scope, not a value — so not a Variable either. */
    ASSERT_FALSE(has_def(r, "Variable", "deep"));
    ASSERT_FALSE(has_def(r, "Variable", "nested"));
    cbm_free_result(r);
    PASS();
}

/* A lambda-valued binding is already minted as a Function by the def walk. Minting
 * it again here would double-count every helper in the ecosystem. */
TEST(nix_lambda_binding_is_function_not_variable) {
    CBMFileResult *r =
        extract("{\n  fn = x: x + 1;\n  val = 7;\n}\n", CBM_LANG_NIX, "t", "mix.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fn"));
    ASSERT_FALSE(has_def(r, "Variable", "fn"));
    ASSERT(has_def(r, "Variable", "val")); /* positive control */
    ASSERT_FALSE(has_def(r, "Function", "val"));
    cbm_free_result(r);
    PASS();
}

/* Descending past the header must not mint a second def from a curried lambda's inner
 * arm: `iota = a: b: ...` is one named function, not two. The inner `b:` has a
 * function_expression parent, resolves no name, and must stay out. */
TEST(nix_curried_lambda_mints_one_def) {
    CBMFileResult *r = extract("{ prelude }:\nlet\n  iota = a: b: a + b;\nin\n{ inherit iota; }\n",
                               CBM_LANG_NIX, "t", "curried.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "iota"));
    ASSERT(count_defs_with_label(r, "Function") == 1);
    cbm_free_result(r);
    PASS();
}

/* --- Fortran --- */
TEST(fortran_function) {
    /* Fortran subroutine name extraction is incomplete — just verify no crash */
    CBMFileResult *r = extract("subroutine greet(name)\n  character(*), intent(in) :: name\n  "
                               "print *, 'Hello ', name\nend subroutine\n",
                               CBM_LANG_FORTRAN, "t", "greet.f90");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group A2: Missing OOP / Systems variants
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Swift struct --- */
TEST(swift_struct) {
    CBMFileResult *r = extract("struct Point {\n    var x: Double\n    var y: Double\n    func "
                               "distance() -> Double { return (x*x + y*y).squareRoot() }\n}\n",
                               CBM_LANG_SWIFT, "t", "Point.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "distance"));
    cbm_free_result(r);
    PASS();
}

/* --- Swift calls (port of PR #47 Go tests) --- */
TEST(swift_simple_call) {
    CBMFileResult *r = extract("func main() { greet() }\nfunc greet() { print(\"hello\") }\n",
                               CBM_LANG_SWIFT, "t", "main.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_method_call) {
    CBMFileResult *r =
        extract("class Foo {\n    func bar() { baz.run() }\n}\n", CBM_LANG_SWIFT, "t", "Foo.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "baz.run"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_constructor_call) {
    CBMFileResult *r =
        extract("func create() { let x = MyClass() }\n", CBM_LANG_SWIFT, "t", "create.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyClass"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_chained_call) {
    CBMFileResult *r = extract("func setup() { AlarmScheduler.shared.startKeepAlive() }\n",
                               CBM_LANG_SWIFT, "t", "setup.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(r->calls.count > 0);
    cbm_free_result(r);
    PASS();
}

/* A Swift force-unwrap is the one thing that reaches the scanner's suppressor
 * path -- the rule that stops `try!` emitting its `!` as a token of its own.
 * That path shifted an int by up to TOKEN_COUNT bits, which runs past the
 * width of the type once the index reaches 31.
 *
 * This test cannot go red here. The normal test build prints the UBSan
 * message and carries on, which is why the bug survived. The Windows
 * CLANGARM64 leg runs UBSan in trap mode, where the same shift is an
 * illegal-instruction crash, so parsing this file at all is the check. */
TEST(swift_force_unwrap_scanner_shift) {
    CBMFileResult *r =
        extract("func load() { let u = cached! }\n", CBM_LANG_SWIFT, "t", "Load.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* #2379: a struct's plain `init` is a callable, not a name-less hole -- a call
 * inside it must source from the initializer, not fall back to the file's
 * Module scope. */
TEST(swift_init_struct_issue2379) {
    CBMFileResult *r = extract("func helper() -> Int { 1 }\n"
                               "struct Box {\n"
                               "    let value: Int\n"
                               "    init() {\n"
                               "        value = helper()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Box.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Box.init");
    ASSERT_NOT_NULL(init_def);
    ASSERT_STR_EQ(init_def->label, "Method");
    ASSERT_STR_EQ(init_def->name, "init");

    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: a class's designated init takes parameters -- coverage that a
 * parameterized init is extracted the same way as a bare one. */
TEST(swift_init_class_designated_issue2379) {
    CBMFileResult *r = extract("func helper() -> Int { 1 }\n"
                               "final class Holder {\n"
                               "    let value: Int\n"
                               "    init(seed: Int) {\n"
                               "        value = helper() + seed\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Holder.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");
    ASSERT_NOT_NULL(init_def);
    ASSERT_STR_EQ(init_def->label, "Method");

    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: a convenience init delegates via `self.init(...)`. Its call to
 * `other()` (an argument of the delegating call) must source from the
 * initializer, not from the file. */
TEST(swift_init_convenience_delegates_issue2379) {
    CBMFileResult *r = extract("func other() -> Int { 2 }\n"
                               "final class Holder {\n"
                               "    let value: Int\n"
                               "    init(seed: Int) {\n"
                               "        value = seed\n"
                               "    }\n"
                               "    convenience init() {\n"
                               "        self.init(seed: other())\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Holder.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");
    ASSERT_NOT_NULL(init_def);

    /* self.init(...) delegates to another overload of Holder.init, which
     * shares this node (#2061): it forms no call, because the only edge it
     * could produce is a self-loop. Its argument call stays. */
    ASSERT_FALSE(has_call(r, "self.init"));
    ASSERT_FALSE(has_call(r, "Holder.init"));

    const CBMCall *call = find_call_by_callee(r, "other");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: two initializers in the same type calling the SAME callee must both
 * attribute to the type's init, not to the file's Module scope. Both share
 * the QN `Holder.init` -- codebase-memory-mcp already collapses overloaded
 * Swift methods onto one node (DeusData/codebase-memory-mcp#2061), and an
 * init is no exception; distinguishing overloads by signature is that
 * issue's concern, not this one's. */
TEST(swift_init_overloads_share_one_node_issue2379) {
    CBMFileResult *r = extract("func shared() -> Int { 3 }\n"
                               "final class Holder {\n"
                               "    let value: Int\n"
                               "    init(seed: Int) {\n"
                               "        value = shared()\n"
                               "    }\n"
                               "    convenience init() {\n"
                               "        self.init(seed: shared())\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Holder.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");
    ASSERT_NOT_NULL(init_def);

    int from_init = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (!c->callee_name || strcmp(c->callee_name, "shared") != 0 || !c->enclosing_func_qn) {
            continue;
        }
        ASSERT_STR_EQ(c->enclosing_func_qn, init_def->qualified_name);
        ASSERT_STR_NEQ(c->enclosing_func_qn, r->module_qn);
        from_init++;
    }
    ASSERT_EQ(from_init, 2);

    cbm_free_result(r);
    PASS();
}

/* #2379: a failable `init?` in an enum is still a callable initializer. */
TEST(swift_init_failable_enum_issue2379) {
    CBMFileResult *r = extract("func helper() -> Int { 1 }\n"
                               "enum Mode {\n"
                               "    case on\n"
                               "    init?(flag: Bool) {\n"
                               "        if helper() > 0 { self = .on } else { return nil }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Mode.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Mode.init");
    ASSERT_NOT_NULL(init_def);

    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: `extension X { }` is modeled by the vendored grammar as a
 * class_declaration named X, so an init declared in an extension goes through
 * the same class-method path as one declared in the primary type. */
TEST(swift_init_extension_issue2379) {
    CBMFileResult *r = extract("func other() -> Int { 2 }\n"
                               "extension Box {\n"
                               "    init(raw: Int) {\n"
                               "        value = other()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Box+Raw.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Box.init");
    ASSERT_NOT_NULL(init_def);

    const CBMCall *call = find_call_by_callee(r, "other");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: regression guard -- an ordinary method in the same type keeps its own
 * attribution unchanged (this already worked pre-fix; the initializer fix
 * must not disturb it). */
TEST(swift_method_still_attributed_issue2379) {
    CBMFileResult *r = extract("func other() -> Int { 2 }\n"
                               "struct Box {\n"
                               "    init() {}\n"
                               "    func read() -> Int {\n"
                               "        other()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Box.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *read_def = find_def_in_module(r, "Box.read");
    ASSERT_NOT_NULL(read_def);

    const CBMCall *call = find_call_by_callee(r, "other");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, read_def->qualified_name);

    cbm_free_result(r);
    PASS();
}

/* #2379: a `deinit` has the same gap as `init` -- no source-level name, so a
 * call inside its body attributed to the file's Module scope instead of the
 * type. */
TEST(swift_deinit_issue2379) {
    CBMFileResult *r = extract("func helper() -> Int { 1 }\n"
                               "final class Deinitable {\n"
                               "    deinit {\n"
                               "        _ = helper()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Deinitable.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *deinit_def = find_def_in_module(r, "Deinitable.deinit");
    ASSERT_NOT_NULL(deinit_def);
    ASSERT_STR_EQ(deinit_def->name, "deinit");

    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, deinit_def->qualified_name);
    ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);

    cbm_free_result(r);
    PASS();
}

/* #2379: `super.init(...)` names no type. Left as written, the registry binds it
 * by short name to whichever project `init` is nearest (on Alamofire: a nested
 * `Options.init`, a sibling decoder's). It is emitted as the superclass's
 * initializer instead -- the first inheritance entry, generic arguments
 * dropped -- and stays attributed to the calling initializer. */
TEST(swift_super_init_names_superclass_issue2379) {
    CBMFileResult *r = extract("final class Sub: Base<Int>, Sendable {\n"
                               "    override init() {\n"
                               "        super.init()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Sub.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *init_def = find_def_in_module(r, "Sub.init");
    ASSERT_NOT_NULL(init_def);
    ASSERT_FALSE(has_call(r, "super.init"));
    const CBMCall *call = find_call_by_callee(r, "Base.init");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);

    cbm_free_result(r);
    PASS();
}

/* #2379: without a superclass to name -- no inheritance clause, or a first entry
 * that does not read as a type -- `super.init` forms no call at all. A
 * lower-case root would pass the registry's receiver-chain check and bind by
 * short name again. */
TEST(swift_super_init_without_superclass_no_call_issue2379) {
    CBMFileResult *r = extract("class Root {\n"
                               "    init() {\n"
                               "        super.init()\n"
                               "    }\n"
                               "}\n"
                               "class Odd: base {\n"
                               "    init() {\n"
                               "        super.init()\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Root.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_NOT_NULL(find_def_in_module(r, "Root.init"));
    ASSERT_NOT_NULL(find_def_in_module(r, "Odd.init"));
    for (int i = 0; i < r->calls.count; i++) {
        const char *callee = r->calls.items[i].callee_name;
        ASSERT(!callee || !strstr(callee, "init"));
    }

    cbm_free_result(r);
    PASS();
}

/* #2379: an initializer call `T.init(...)` is flagged so the resolvers'
 * weak-member guard keeps a short-name guess from placing it (nearly every
 * type has an `init`); every other Swift call stays unflagged and resolves
 * exactly as before. */
TEST(swift_initializer_calls_flagged_issue2379) {
    CBMFileResult *r = extract("func run(obj: Worker) {\n"
                               "    _ = UIAlertAction.init(title: nil)\n"
                               "    helper()\n"
                               "    obj.start()\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Run.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *init_call = find_call_by_callee(r, "UIAlertAction.init");
    const CBMCall *bare = find_call_by_callee(r, "helper");
    const CBMCall *member = find_call_by_callee(r, "obj.start");
    ASSERT_NOT_NULL(init_call);
    ASSERT_NOT_NULL(bare);
    ASSERT_NOT_NULL(member);
    ASSERT_TRUE(init_call->is_method);
    ASSERT_FALSE(bare->is_method);
    ASSERT_FALSE(member->is_method);

    cbm_free_result(r);
    PASS();
}

/* #2379: `init` is a Swift keyword. A reference to one (`.init(...)`,
 * `Box.init`) names the initializer of a type the bare name does not carry,
 * so it is not recorded as a usage -- by name it could only be guessed among
 * every type's initializer (on Alamofire, 26 references landed on one nested
 * `Output.init`). The type in `Box.init` is still a usage. */
TEST(swift_init_reference_is_not_a_usage_issue2379) {
    CBMFileResult *r = extract("struct Box {\n"
                               "    init(raw: Int) {}\n"
                               "}\n"
                               "func make() -> Box {\n"
                               "    .init(raw: 1)\n"
                               "}\n"
                               "func maker() -> (Int) -> Box {\n"
                               "    Box.init\n"
                               "}\n",
                               CBM_LANG_SWIFT, "t", "Make.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int init_usages = 0;
    int box_usages = 0;
    for (int i = 0; i < r->usages.count; i++) {
        const char *ref = r->usages.items[i].ref_name;
        init_usages += ref && strcmp(ref, "init") == 0;
        box_usages += ref && strcmp(ref, "Box") == 0;
    }
    ASSERT_EQ(init_usages, 0);
    ASSERT_GT(box_usages, 0);

    cbm_free_result(r);
    PASS();
}

/* --- Objective-C --- */
TEST(objc_interface) {
    CBMFileResult *r =
        extract("@interface Animal : NSObject\n- (NSString *)name;\n- (void)speak;\n@end\n",
                CBM_LANG_OBJC, "t", "Animal.h");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

TEST(objc_implementation) {
    CBMFileResult *r = extract("@implementation Animal\n- (NSString *)name { return @\"Animal\"; "
                               "}\n- (void)speak { NSLog(@\"...\"); }\n@end\n",
                               CBM_LANG_OBJC, "t", "Animal.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Dart top-level function --- */
TEST(dart_top_level_function) {
    CBMFileResult *r = extract(
        "void main() {\n  print('Hello');\n}\nString greet(String name) => 'Hello $name';\n",
        CBM_LANG_DART, "t", "main.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Rust enum --- */
TEST(rust_enum) {
    CBMFileResult *r =
        extract("pub enum Direction { North, South, East, West }\n", CBM_LANG_RUST, "t", "dir.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Zig struct --- */
TEST(zig_struct) {
    CBMFileResult *r = extract("const Point = struct { x: f32, y: f32, pub fn dist(self: Point) "
                               "f32 { return self.x + self.y; } };\n",
                               CBM_LANG_ZIG, "t", "point.zig");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- C++ function (standalone) --- */
TEST(cpp_function) {
    CBMFileResult *r = extract("#include <string>\nstd::string greet(const std::string& name) { "
                               "return \"Hello \" + name; }\nint main() { return 0; }\n",
                               CBM_LANG_CPP, "t", "main.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* #1266: GoogleTest TEST() macros with the same name collapse into a single
 * node when multiple tests share a file. Each must mint a distinct Function
 * node whose name encodes the suite and case arguments. */
TEST(cpp_gtest_same_name_collision_issue1266) {
    CBMFileResult *r = extract("namespace demo { int assembleWidget(int s) { return s * 2; } }\n"
                               "TEST(WidgetSuite, DoublesSmallSize) { demo::assembleWidget(1); }\n"
                               "TEST(WidgetSuite, DoublesZero) { demo::assembleWidget(0); }\n"
                               "TEST(WidgetSuite, DoublesLargeSize) {\n"
                               "  demo::assembleWidget(1000);\n"
                               "}\n",
                               CBM_LANG_CPP, "t", "direct_test.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesSmallSize"));
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesZero"));
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesLargeSize"));
    ASSERT(!has_def(r, "Function", "TEST"));
    cbm_free_result(r);
    PASS();
}

/* #1266: TEST_F fixture macro also produces unique names. */
TEST(cpp_gtest_f_unique_name_issue1266) {
    CBMFileResult *r = extract("TEST_F(MyFixture, FirstTest) { doStuff(); }\n"
                               "TEST_F(MyFixture, SecondTest) { doOtherStuff(); }\n",
                               CBM_LANG_CPP, "t", "fixture_test.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "TEST_F_MyFixture_FirstTest"));
    ASSERT(has_def(r, "Function", "TEST_F_MyFixture_SecondTest"));
    ASSERT(!has_def(r, "Function", "TEST_F"));
    cbm_free_result(r);
    PASS();
}

/* --- C++ out-of-line method definitions (#428) ---
 * A .cpp defining methods of a class declared elsewhere (not in this TU).
 * Pre-fix these were recorded as free Functions (label "Function", no
 * parent_class); they must be Methods linked to their enclosing class via
 * parent_class. (The helper also descends nested scopes `ns::Class::method` to
 * the immediate class, but tree-sitter-cpp parses a synthetic doubly-qualified
 * out-of-line def in isolation as an ERROR node, so that path is exercised by
 * real codebases rather than this isolated unit fixture.) */
TEST(cpp_out_of_line_method_issue428) {
    CBMFileResult *r = extract("void Foo::bar() {}\n"
                               "int Foo::baz() { return 0; }\n",
                               CBM_LANG_CPP, "t", "foo.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Method", "bar"));
    ASSERT(has_def(r, "Method", "baz"));
    ASSERT(!has_def(r, "Function", "bar")); /* not a free function */
    /* parent_class links to the enclosing class QN */
    int checked = 0;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (strcmp(d->name, "bar") == 0 && strcmp(d->label, "Method") == 0) {
            ASSERT_NOT_NULL(d->parent_class);
            ASSERT(strstr(d->parent_class, "Foo") != NULL);
            checked = 1;
        }
    }
    ASSERT(checked);
    cbm_free_result(r);
    PASS();
}

/* --- COBOL paragraph --- */
TEST(cobol_paragraph) {
    CBMFileResult *r =
        extract("IDENTIFICATION DIVISION.\nPROGRAM-ID. HELLO.\nPROCEDURE DIVISION.\n    "
                "DISPLAY-GREETING.\n        DISPLAY 'HELLO WORLD'.\n        STOP RUN.\n",
                CBM_LANG_COBOL, "t", "hello.cbl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Verilog module --- */
TEST(verilog_module) {
    CBMFileResult *r =
        extract("module adder(input a, input b, output sum);\n  assign sum = a + b;\nendmodule\n",
                CBM_LANG_VERILOG, "t", "adder.v");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- CUDA kernel --- */
TEST(cuda_kernel) {
    CBMFileResult *r = extract("__global__ void vectorAdd(float *a, float *b, float *c, int n) {\n "
                               "   int i = blockIdx.x * blockDim.x + threadIdx.x;\n    if (i < n) "
                               "c[i] = a[i] + b[i];\n}\nint main() { return 0; }\n",
                               CBM_LANG_CUDA, "t", "vector.cu");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Python decorator --- */
TEST(python_decorator) {
    CBMFileResult *r = extract("class Router:\n    @staticmethod\n    def route(path: str):\n      "
                               "  def decorator(func): return func\n        return decorator\n",
                               CBM_LANG_PYTHON, "t", "router.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Router"));
    cbm_free_result(r);
    PASS();
}

/* --- TypeScript interface --- */
TEST(ts_interface) {
    CBMFileResult *r = extract("export interface Repository<T> { findById(id: number): T; "
                               "save(entity: T): void; delete(id: number): void; }\n",
                               CBM_LANG_TYPESCRIPT, "t", "repo.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- TSX component --- */
TEST(tsx_component) {
    CBMFileResult *r = extract(
        "import React from 'react';\ninterface Props { name: string; }\nexport function Greeting({ "
        "name }: Props) {\n    return <div>Hello {name}</div>;\n}\nexport default Greeting;\n",
        CBM_LANG_TSX, "t", "Greeting.tsx");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greeting"));
    cbm_free_result(r);
    PASS();
}

/* --- Lua table method --- */
TEST(lua_table_method) {
    CBMFileResult *r =
        extract("local M = {}\nfunction M.create(name)\n    return { name = name }\nend\nfunction "
                "M.greet(self)\n    return 'Hi ' .. self.name\nend\nreturn M\n",
                CBM_LANG_LUA, "t", "module.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Should extract at least one Function from Lua table method */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Emacs Lisp defun --- */
TEST(emacs_lisp_defun) {
    CBMFileResult *r = extract("(defun greet (name)\n  (message \"Hello %s\" name))\n(defun main "
                               "()\n  (greet \"World\"))\n",
                               CBM_LANG_EMACSLISP, "t", "init.el");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

/* --- Emacs Lisp defvar --- */
TEST(emacs_lisp_defvar) {
    CBMFileResult *r = extract("(defvar my-count 0 \"A counter.\")\n(defcustom my-name \"World\" "
                               "\"The name.\"\n  :type 'string)\n",
                               CBM_LANG_EMACSLISP, "t", "vars.el");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Haskell data type --- */
TEST(haskell_data_type) {
    CBMFileResult *r =
        extract("data Shape = Circle Double | Rectangle Double Double\narea :: Shape -> "
                "Double\narea (Circle r) = pi * r * r\narea (Rectangle w h) = w * h\n",
                CBM_LANG_HASKELL, "t", "Shape.hs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Clojure function (known limitation: defn produces list_lit) --- */
TEST(clojure_function) {
    CBMFileResult *r = extract("(ns greeter.core)\n(defn greet [name]\n  (str \"Hello \" "
                               "name))\n(defn -main [& args]\n  (println (greet \"World\")))\n",
                               CBM_LANG_CLOJURE, "t", "core.clj");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Clojure uses list_lit for all forms — no function defs extracted (known limitation) */
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group E2: Missing Config / Markup Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- HTML elements --- */
TEST(html_elements) {
    CBMFileResult *r = extract(
        "<!DOCTYPE "
        "html><html><head><title>Test</title></head><body><h1>Hello</h1><p>World</p></body></html>",
        CBM_LANG_HTML, "t", "index.html");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- SQL function (CREATE FUNCTION) --- */
TEST(sql_function) {
    CBMFileResult *r = extract("CREATE FUNCTION get_user_count() RETURNS INTEGER AS $$ SELECT "
                               "COUNT(*) FROM users; $$ LANGUAGE SQL;\n",
                               CBM_LANG_SQL, "t", "funcs.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

TEST(sql_ddl_node_labels) {
    CBMFileResult *r = extract("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);\n"
                               "CREATE VIEW active_users AS SELECT * FROM users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Table", "users"));
    ASSERT(has_def(r, "View", "active_users"));
    cbm_free_result(r);
    PASS();
}

TEST(sql_view_lineage_usages) {
    /* A view's FROM/JOIN relations are emitted as usages (ref_name = table),
     * which pass_usages later resolves into view -> table USAGE lineage edges. */
    CBMFileResult *r = extract("CREATE TABLE users (id INTEGER);\n"
                               "CREATE VIEW active_users AS SELECT * FROM users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int found_users = 0;
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && strcmp(r->usages.items[i].ref_name, "users") == 0) {
            found_users = 1;
        }
    }
    ASSERT(found_users);
    cbm_free_result(r);
    PASS();
}

TEST(sql_schema_qualified_name) {
    /* schema-qualified DDL (schema.table) is named by the table, not the schema,
     * and FROM schema.table resolves to that table for lineage. */
    CBMFileResult *r = extract("CREATE TABLE app.users (id INTEGER);\n"
                               "CREATE VIEW app.active AS SELECT * FROM app.users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Table", "users"));
    ASSERT(has_def(r, "View", "active"));
    int found_users = 0;
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && strcmp(r->usages.items[i].ref_name, "users") == 0) {
            found_users = 1;
        }
    }
    ASSERT(found_users);
    cbm_free_result(r);
    PASS();
}

/* --- dbt Jinja lineage --- */

/* Helper: does the file's usage list carry `name`? */
static int has_usage(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->usages.count; i++) {
        if (r->usages.items[i].ref_name && strcmp(r->usages.items[i].ref_name, name) == 0) {
            return 1;
        }
    }
    return 0;
}

TEST(dbt_model_and_ref_lineage) {
    /* A dbt model: the file stem is the model identity, and each ref() is a
     * dependency on another model. The SQL grammar cannot read `{{ ref(..) }}`
     * at all, so without the dbt pass this file yields no lineage whatsoever. */
    CBMFileResult *r = extract("SELECT o.id, c.name\n"
                               "FROM {{ ref('stg_orders') }} o\n"
                               "JOIN {{ ref('stg_customers') }} c ON c.id = o.customer_id\n",
                               CBM_LANG_SQL, "t", "models/marts/orders_enriched.sql");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Model", "orders_enriched"));
    ASSERT(has_usage(r, "stg_orders"));
    ASSERT(has_usage(r, "stg_customers"));
    cbm_free_result(r);
    PASS();
}

TEST(dbt_source_and_two_arg_ref) {
    /* Both dbt builtins name the relation in their LAST string argument:
     * source('group','table') -> table, and the two-argument
     * ref('package','model') form -> model. */
    CBMFileResult *r =
        extract("SELECT * FROM {{ source('raw', 'customers') }}\n"
                "UNION ALL SELECT * FROM {{ ref('analytics', 'legacy_customers') }}\n",
                CBM_LANG_SQL, "t", "models/stg_customers.sql");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Model", "stg_customers"));
    ASSERT(has_usage(r, "customers"));
    ASSERT(has_usage(r, "legacy_customers"));
    /* the group/package argument is not the relation */
    ASSERT_FALSE(has_usage(r, "raw"));
    ASSERT_FALSE(has_usage(r, "analytics"));
    cbm_free_result(r);
    PASS();
}

TEST(dbt_ignores_non_dbt_jinja) {
    /* Templated SQL is not dbt SQL. An Airflow-style parameter substitution has
     * Jinja but no dbt builtin, so the dbt pass must contribute NOTHING — no
     * Model node named after the file, and no usage minted from the template
     * variables. This is the gate that keeps every non-dbt repository free of
     * fabricated data-lineage vocabulary.
     *
     * The ordinary SQL identifier path is unaffected and still sees the literal
     * `FROM events`; the second extraction below is the control proving that
     * usage is pre-existing SQL behaviour rather than anything dbt added. */
    CBMFileResult *r = extract("SELECT * FROM events WHERE day = '{{ ds }}'\n"
                               "  AND region = '{{ params.region_code }}'\n",
                               CBM_LANG_SQL, "t", "queries/daily_events.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(has_def(r, "Model", "daily_events"));

    /* Control: the same statement with the templates replaced by plain string
     * literals. Both parse as SQL identically, so an equal usage count is the
     * precise statement of "the dbt pass contributed nothing here" — stronger
     * than naming individual identifiers, and immune to how SQL happens to
     * tokenize the template text. */
    CBMFileResult *plain = extract("SELECT * FROM events WHERE day = '2026-01-01'\n"
                                   "  AND region = 'eu-west'\n",
                                   CBM_LANG_SQL, "t", "queries/daily_events.sql");
    ASSERT_NOT_NULL(plain);
    ASSERT_FALSE(has_def(plain, "Model", "daily_events"));
    ASSERT_EQ(r->usages.count, plain->usages.count);
    ASSERT_EQ(r->defs.count, plain->defs.count);
    cbm_free_result(plain);
    cbm_free_result(r);
    PASS();
}

TEST(dbt_plain_sql_untouched) {
    /* Plain DDL keeps producing exactly the Table/View relations it did before
     * the dbt pass existed — no Model node, and the FROM lineage is unchanged. */
    CBMFileResult *r = extract("CREATE TABLE users (id INTEGER);\n"
                               "CREATE VIEW active_users AS SELECT * FROM users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Table", "users"));
    ASSERT(has_def(r, "View", "active_users"));
    ASSERT_FALSE(has_def(r, "Model", "schema"));
    cbm_free_result(r);
    PASS();
}

/* --- Meson project --- */
TEST(meson_project) {
    CBMFileResult *r = extract(
        "project('myapp', 'c', version: '1.0.0')\nexecutable('myapp', 'main.c', install: true)\n",
        CBM_LANG_MESON, "t", "meson.build");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- CSS rules --- */
TEST(css_rules) {
    CBMFileResult *r = extract(
        ".container { display: flex; width: 100%; }\n.button { background: #007bff; color: white; "
        "border: none; }\n@media (max-width: 768px) { .container { flex-direction: column; } }\n",
        CBM_LANG_CSS, "t", "styles.css");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- SCSS rules --- */
TEST(scss_rules) {
    CBMFileResult *r = extract("$primary: #007bff;\n.container {\n  width: 100%;\n  .button {\n    "
                               "background: $primary;\n    &:hover { opacity: 0.8; }\n  }\n}\n",
                               CBM_LANG_SCSS, "t", "styles.scss");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- TOML basic --- */
TEST(toml_basic) {
    CBMFileResult *r = extract("[server]\nhost = \"localhost\"\nport = 8080\n\n[database]\nurl = "
                               "\"postgres://localhost/db\"\nmax_connections = 10\n",
                               CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "server"));
    ASSERT(has_def(r, "Class", "database"));
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

/* --- CMake function --- */
TEST(cmake_function) {
    CBMFileResult *r = extract(
        "cmake_minimum_required(VERSION 3.16)\nproject(MyApp VERSION 1.0)\nadd_executable(myapp "
        "main.cpp)\ntarget_compile_features(myapp PRIVATE cxx_std_17)\n",
        CBM_LANG_CMAKE, "t", "CMakeLists.txt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- JSON object --- */
TEST(json_object) {
    CBMFileResult *r = extract("{\"name\": \"myapp\", \"version\": \"1.0.0\", \"scripts\": "
                               "{\"build\": \"go build\", \"test\": \"go test ./...\"}}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "name"));
    ASSERT(has_def(r, "Variable", "version"));
    cbm_free_result(r);
    PASS();
}

/* --- Protobuf message --- */
TEST(protobuf_message) {
    CBMFileResult *r = extract(
        "syntax = \"proto3\";\npackage user;\nmessage User { int64 id = 1; string name = 2; string "
        "email = 3; }\nservice UserService { rpc GetUser(User) returns (User); }\n",
        CBM_LANG_PROTOBUF, "t", "user.proto");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- GraphQL type --- */
TEST(graphql_type) {
    CBMFileResult *r = extract("type User {\n  id: ID!\n  name: String!\n  email: String!\n}\ntype "
                               "Query {\n  user(id: ID!): User\n  users: [User!]!\n}\n",
                               CBM_LANG_GRAPHQL, "t", "schema.graphql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Svelte component --- */
TEST(svelte_component) {
    CBMFileResult *r = extract("<script>\n  let name = 'World';\n  function greet() {\n    return "
                               "`Hello ${name}`;\n  }\n</script>\n<h1>{greet()}</h1>\n",
                               CBM_LANG_SVELTE, "t", "App.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Vue component --- */
TEST(vue_component) {
    CBMFileResult *r =
        extract("<template><div>{{ message }}</div></template>\n<script>\nexport default {\n  "
                "name: 'App',\n  data() { return { message: 'Hello World' }; },\n  methods: { "
                "greet() { return this.message; } }\n};\n</script>\n",
                CBM_LANG_VUE, "t", "App.vue");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- GLSL shader --- */
TEST(glsl_shader) {
    CBMFileResult *r = extract(
        "#version 330 core\nvoid main() {\n    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n}\nvec3 "
        "transform(vec3 pos, mat4 mvp) {\n    return (mvp * vec4(pos, 1.0)).xyz;\n}\n",
        CBM_LANG_GLSL, "t", "vertex.glsl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- VimScript function --- */
TEST(vimscript_function) {
    CBMFileResult *r = extract("function! SayHello()\n  echo 'Hello'\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "t", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* VimScript extraction may or may not produce named functions */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "SayHello"));
    }
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group H: Scientific / Math — extended tests
 * ═══════════════════════════════════════════════════════════════════ */

/* --- MATLAB parse (simple expression) --- */
TEST(matlab_parse) {
    CBMFileResult *r = extract("x = 1;\ny = x + 2;\n", CBM_LANG_MATLAB, "t", "simple.matlab");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- MATLAB call --- */
TEST(matlab_call) {
    CBMFileResult *r = extract("function y = foo(x)\n  y = inv(x);\n  disp hello\nend\n",
                               CBM_LANG_MATLAB, "t", "foo.matlab");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "inv"));
    ASSERT(has_call(r, "disp"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean parse (theorem) --- */
TEST(lean_parse) {
    CBMFileResult *r = extract("theorem add_comm (a b : Nat) : a + b = b + a := by omega\n",
                               CBM_LANG_LEAN, "t", "Comm.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Lean call (recursive fib) --- */
TEST(lean_call) {
    CBMFileResult *r = extract("def fib : Nat \xe2\x86\x92 Nat\n  | 0 => 1\n  | 1 => 1\n  | n + 2 "
                               "=> fib (n + 1) + fib n\n",
                               CBM_LANG_LEAN, "t", "Fib.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "fib"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean type annotation not call --- */
TEST(lean_type_annotation_not_call) {
    CBMFileResult *r = extract(
        "def listLen (xs : List Nat) : Nat := 0\ndef greet : IO Unit := IO.println \"hi\"\n",
        CBM_LANG_LEAN, "t", "Types.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* "List" in binder type position should NOT be extracted as a call */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(strcmp(r->calls.items[i].callee_name, "List") == 0);
    }
    /* IO.println in the body should be present */
    int found_println = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, "println") != NULL) {
            found_println = 1;
        }
    }
    ASSERT_TRUE(found_println);
    cbm_free_result(r);
    PASS();
}

/* --- FORM parse (simple expression) --- */
TEST(form_parse) {
    CBMFileResult *r = extract("Symbols x, y;\nLocal F = x + y;\nPrint;\n.end\n", CBM_LANG_FORM,
                               "t", "example.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- FORM call (#call) --- */
TEST(form_call) {
    CBMFileResult *r = extract("#procedure myproc(x)\n  id `x' = 0;\n#endprocedure\n#procedure "
                               "caller()\n  #call myproc(1)\n#endprocedure\n",
                               CBM_LANG_FORM, "t", "calc.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "myproc"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma procedure --- */
TEST(magma_procedure) {
    CBMFileResult *r = extract("procedure PrintHello()\n  print \"Hello\";\nend procedure;\n",
                               CBM_LANG_MAGMA, "t", "hello.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "PrintHello"));
    }
    cbm_free_result(r);
    PASS();
}

/* --- Magma parse (simple) --- */
TEST(magma_parse) {
    CBMFileResult *r = extract("x := 42;\ny := x + 1;\n", CBM_LANG_MAGMA, "t", "simple.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Magma import (load) --- */
TEST(magma_import) {
    CBMFileResult *r = extract("load \"utils.mag\";\nload \"lib/helpers.mag\";\n", CBM_LANG_MAGMA,
                               "t", "main.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    cbm_free_result(r);
    PASS();
}

/* --- Magma call --- */
TEST(magma_call) {
    CBMFileResult *r = extract("function Foo(x)\n  y := Bar(x);\n  return y;\nend function;\n",
                               CBM_LANG_MAGMA, "t", "calls.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "Bar"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma disambiguation (.m file as Magma) --- */
TEST(magma_disambiguation) {
    CBMFileResult *r = extract("function Factorial(n)\n  if n le 1 then\n    return 1;\n  end "
                               "if;\n  return n * Factorial(n - 1);\nend function;\n",
                               CBM_LANG_MAGMA, "t", "test.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 1);
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "Factorial"));
    }
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram function (both := and =) --- */
TEST(wolfram_function_extended) {
    CBMFileResult *r = extract("f[x_] := x^2\ng[x_] = x + 1\n", CBM_LANG_WOLFRAM, "t", "funcs.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 2);
    ASSERT(has_def(r, "Function", "f"));
    ASSERT(has_def(r, "Function", "g"));
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram call --- */
TEST(wolfram_call) {
    CBMFileResult *r = extract("f[x_] := g[x] + h[x]\n", CBM_LANG_WOLFRAM, "t", "calls.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "g"));
    ASSERT(has_call(r, "h"));
    /* "f" should NOT appear as a call (it's the definition LHS) */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(strcmp(r->calls.items[i].callee_name, "f") == 0);
    }
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram caller attribution --- */
TEST(wolfram_caller_attribution) {
    CBMFileResult *r = extract("f[x_] := g[x] + h[x]\n", CBM_LANG_WOLFRAM, "t", "caller.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    /* Calls inside f[] should have f as enclosing function, not the module path */
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "g") == 0 ||
            strcmp(r->calls.items[i].callee_name, "h") == 0) {
            /* enclosing_func_qn must NOT be empty or the file path */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.caller") == 0);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* Issue #438: a C function_definition has no `name` field — the name lives in the
 * declarator chain. Calls inside a C function must be attributed to the enclosing
 * function, not the module. Pre-fix, enclosing_func_qn fell back to the module QN. */
TEST(c_caller_attribution) {
    CBMFileResult *r = extract("int helper(int x) { return x; }\n"
                               "int caller(void) { return helper(1); }\n",
                               CBM_LANG_C, "t", "main.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int saw_helper = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            saw_helper = 1;
            /* enclosing_func_qn must be the function, NOT empty and NOT the module QN. */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.main") == 0);
        }
    }
    ASSERT(saw_helper);
    cbm_free_result(r);
    PASS();
}

/* adc8304 (the dedup refactor bundled into #463) re-pointed the C/C++ enclosing-
 * function resolver at the canonical declarator walker: qualified names (Foo::bar)
 * now resolve via resolve_qualified_name(), and `type_identifier` was dropped from
 * the terminal-name set. These guard that out-of-line C++ method / ctor / dtor
 * definitions still attribute their inner calls to the enclosing function, not the
 * module — i.e. that the dedup did not reintroduce the #438 regression on the
 * qualified-declarator path. Module QN for "m.cpp" under prefix "t" is "t.m". */
TEST(cpp_out_of_line_method_caller_attribution) {
    CBMFileResult *r = extract("struct Foo { void bar(); };\n"
                               "int helper(int x) { return x; }\n"
                               "void Foo::bar() { helper(1); }\n",
                               CBM_LANG_CPP, "t", "m.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int saw_helper = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            saw_helper = 1;
            /* enclosing must be the out-of-line method, NOT empty and NOT the module. */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.m") == 0);
        }
    }
    ASSERT(saw_helper);
    cbm_free_result(r);
    PASS();
}

/* Out-of-line constructor (Foo::Foo) and destructor (Foo::~Foo) exercise the
 * identifier and destructor_name branches of resolve_qualified_name(). A call
 * inside either must attribute to that special member, not the module. */
TEST(cpp_out_of_line_ctor_dtor_caller_attribution) {
    CBMFileResult *r = extract("struct Foo { Foo(); ~Foo(); };\n"
                               "int helper(int x) { return x; }\n"
                               "Foo::Foo() { helper(1); }\n"
                               "Foo::~Foo() { helper(2); }\n",
                               CBM_LANG_CPP, "t", "m.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int helper_calls = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            helper_calls++;
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.m") == 0);
        }
    }
    ASSERT(helper_calls >= 1);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram parse (simple assignment) --- */
TEST(wolfram_parse) {
    CBMFileResult *r = extract("x = 42;\ny = x + 1;\n", CBM_LANG_WOLFRAM, "t", "simple.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram import --- */
TEST(wolfram_import) {
    CBMFileResult *r =
        extract("<< \"utils.wl\"\nNeeds[\"Package`\"]\n", CBM_LANG_WOLFRAM, "t", "main.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram nested def --- */
TEST(wolfram_nested_def) {
    CBMFileResult *r = extract("main[x_] := Module[{localF}, localF[t_] := t + 1; localF[x]]\n",
                               CBM_LANG_WOLFRAM, "t", "nested.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "localF"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group I: cbm_test.go ports
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_docstring) {
    CBMFileResult *r = extract(
        "def compute(x, y):\n    \"\"\"Compute the sum of x and y.\"\"\"\n    return x + y\n",
        CBM_LANG_PYTHON, "test", "test.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "compute"));
    /* Check docstring is present */
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "compute") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT_TRUE(strlen(r->defs.items[i].docstring) > 0);
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(go_function_extraction) {
    CBMFileResult *r =
        extract("package main\n\n// Greet returns a greeting.\nfunc Greet(name string) string "
                "{\n\treturn \"Hello, \" + name\n}\n\nfunc main() {\n\tGreet(\"world\")\n}\n",
                CBM_LANG_GO, "test", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greet"));
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_call(r, "Greet"));
    cbm_free_result(r);
    PASS();
}

TEST(js_arrow_function) {
    CBMFileResult *r = extract("const greet = (name) => {\n  return \"Hello \" + "
                               "name;\n};\n\nconst result = greet(\"world\");\n",
                               CBM_LANG_JAVASCRIPT, "test", "app.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group J: language_failures_test.go ports
 * ═══════════════════════════════════════════════════════════════════ */

/* CommonLisp — defun extraction (known limitation: grammar produces list_lit) */
TEST(commonlisp_defun) {
    CBMFileResult *r =
        extract("(defun hello () \"world\")\n", CBM_LANG_COMMONLISP, "test", "hello.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Known limitation: CommonLisp grammar produces list_lit, not defun nodes.
     * Function extraction returns 0 — this test documents the limitation. */
    cbm_free_result(r);
    PASS();
}

TEST(commonlisp_multiple_functions) {
    CBMFileResult *r = extract("(defun add (a b) (+ a b))\n(defun mul (a b) (* a b))\n",
                               CBM_LANG_COMMONLISP, "test", "math.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

TEST(commonlisp_defmacro) {
    CBMFileResult *r =
        extract("(defmacro when2 (condition &body body)\n  `(if ,condition (progn ,@body)))\n",
                CBM_LANG_COMMONLISP, "test", "macros.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* 2026-09-16 probe: config extractors handed multi-line node text over as a
 * name (8,301 elasticsearch YAML Fields, 91 kernel Makefile/.conf nodes with a
 * line break inside), and JS/TS baselines named functions `{}` and variables
 * `1`. The definition push is the one place every extractor goes through. */
TEST(defs_push_cuts_multiline_names_and_rejects_js_literal_names) {
    CBMArena a;
    cbm_arena_init(&a);
    CBMDefArray defs = {0};

    CBMDefinition make = {0};
    make.name = "endif\n\n$(obj)/pm_data-offsets.h";
    make.qualified_name = "proj.arch.arm.mach-at91.Makefile.endif\n\n$(obj)/pm_data-offsets.h";
    make.label = "Function";
    make.file_path = "arch/arm/mach-at91/Makefile";
    cbm_defs_push(&defs, &a, make);
    ASSERT_EQ(defs.count, 1);
    ASSERT_STR_EQ(defs.items[0].name, "endif");
    ASSERT_STR_EQ(defs.items[0].qualified_name, "proj.arch.arm.mach-at91.Makefile.endif");

    CBMDefinition yaml = {0};
    yaml.name = "Test get datafeed stats given missing datafeed_id   \r\n  - do:";
    yaml.qualified_name =
        "proj.spec.Test get datafeed stats given missing datafeed_id   \r\n  - do:";
    yaml.label = "Field";
    yaml.file_path = "rest-api-spec/test/ml/get_datafeed_stats.yml";
    cbm_defs_push(&defs, &a, yaml);
    ASSERT_EQ(defs.count, 2);
    ASSERT_STR_EQ(defs.items[1].name, "Test get datafeed stats given missing datafeed_id");

    /* JS/TS: a literal token is not a name. */
    CBMDefinition brace = {0};
    brace.name = "{}";
    brace.qualified_name = "proj.tests.baselines.x.{}";
    brace.label = "Function";
    brace.file_path = "tests/baselines/reference/x.js";
    cbm_defs_push(&defs, &a, brace);
    CBMDefinition one = {0};
    one.name = "1";
    one.qualified_name = "proj.tests.cases.y.1";
    one.label = "Variable";
    one.file_path = "tests/cases/y.ts";
    cbm_defs_push(&defs, &a, one);
    ASSERT_EQ(defs.count, 2);

    /* Real JS names, including private members and `$`-prefixed ones, stay. */
    CBMDefinition priv = {0};
    priv.name = "#secret";
    priv.qualified_name = "proj.src.a.Klass.#secret";
    priv.label = "Method";
    priv.file_path = "src/a.ts";
    cbm_defs_push(&defs, &a, priv);
    CBMDefinition dollar = {0};
    dollar.name = "$scope";
    dollar.qualified_name = "proj.src.b.$scope";
    dollar.label = "Variable";
    dollar.file_path = "src/b.js";
    cbm_defs_push(&defs, &a, dollar);
    ASSERT_EQ(defs.count, 4);

    /* Member keys JS spells without an identifier start are names too:
     * computed, string-literal and escaped (1,782 real definitions in the
     * TypeScript corpus wore these spellings). */
    const char *member_keys[] = {"[Symbol.iterator]", "\"my-key\"", "'x'", "\\u0410"};
    for (int i = 0; i < 4; i++) {
        CBMDefinition member = {0};
        member.name = member_keys[i];
        member.qualified_name = member_keys[i];
        member.label = "Method";
        member.file_path = "src/c.ts";
        cbm_defs_push(&defs, &a, member);
    }
    ASSERT_EQ(defs.count, 8);

    /* Tokens that are not names in any spelling: patterns, numeric literals,
     * parenthesised types, rest elements. */
    const char *tokens[] = {"{ b11 } = { b11: \"string\" }", "0x0",  "3.2e1",
                            "(x: number) => string",         "...a", "?"};
    for (int i = 0; i < 6; i++) {
        CBMDefinition token = {0};
        token.name = tokens[i];
        token.qualified_name = tokens[i];
        token.label = "Variable";
        token.file_path = "tests/cases/z.js";
        cbm_defs_push(&defs, &a, token);
    }
    ASSERT_EQ(defs.count, 8);

    /* Other languages may legitimately name operators: untouched. */
    CBMDefinition op = {0};
    op.name = "<$>";
    op.qualified_name = "proj.Data.Functor.<$>";
    op.label = "Function";
    op.file_path = "src/Data/Functor.hs";
    cbm_defs_push(&defs, &a, op);
    ASSERT_EQ(defs.count, 9);

    cbm_arena_destroy(&a);
    PASS();
}

TEST(makefile_rule_as_function) {
    CBMFileResult *r = extract("all:\n\t@echo hello\n", CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "all"));
    cbm_free_result(r);
    PASS();
}

TEST(makefile_multiple_targets) {
    CBMFileResult *r = extract("all: main.o\n\tgcc -o all main.o\n\nbuild:\n\tgo build ./...\n",
                               CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "all"));
    ASSERT(has_def(r, "Function", "build"));
    cbm_free_result(r);
    PASS();
}

TEST(makefile_variable_extraction) {
    CBMFileResult *r =
        extract("CC := gcc\nCFLAGS := -Wall\n", CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Variable extraction may or may not work depending on Makefile grammar support */
    cbm_free_result(r);
    PASS();
}

TEST(vimscript_function_extraction) {
    CBMFileResult *r = extract("function! SayHello()\n  echo 'Hello'\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "test", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* VimScript function extraction may or may not produce named functions */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "SayHello"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(vimscript_function_without_bang) {
    CBMFileResult *r = extract("function MyFunc(arg)\n  return arg\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "test", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "MyFunc"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(julia_function_extraction) {
    CBMFileResult *r = extract("function hello()\n  println(\"Hello, World!\")\nend\n",
                               CBM_LANG_JULIA, "test", "hello.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "hello"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(julia_function_with_args) {
    CBMFileResult *r = extract("function add(a::Int, b::Int)::Int\n  return a + b\nend\n",
                               CBM_LANG_JULIA, "test", "math.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "add"));
    }
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Cross-cutting: Calls + Imports
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_calls) {
    CBMFileResult *r =
        extract("import os\ndef main():\n    os.path.exists('/tmp')\n    print('hello')\n",
                CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Python unified extraction produces calls — verify at least some exist */
    ASSERT_GT(r->calls.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(python_iris_classMethodValue) {
    CBMFileResult *r =
        extract("import iris\n"
                "iris_obj = iris.cls('%Library.ObjectScript')\n"
                "def call_bfs(n):\n"
                "    return iris_obj.classMethodValue('Graph.KG.TraversalBFS', 'BFSFastJson', n)\n",
                CBM_LANG_PYTHON, "t", "store.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Graph.KG.TraversalBFS.BFSFastJson"));
    cbm_free_result(r);
    PASS();
}

/* #1260: count calls with an exact callee whose enclosing function qn ends
 * with ".<func>". has_call() is a substring match, which cannot tell
 * "Pkg.A.Run" emitted from want_a apart from the same callee in want_b. */
static int count_calls_in_func(CBMFileResult *r, const char *callee, const char *func) {
    int n = 0;
    size_t flen = strlen(func);
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (!c->callee_name || strcmp(c->callee_name, callee) != 0 || !c->enclosing_func_qn) {
            continue;
        }
        size_t qlen = strlen(c->enclosing_func_qn);
        if (qlen > flen && c->enclosing_func_qn[qlen - flen - 1] == '.' &&
            strcmp(c->enclosing_func_qn + qlen - flen, func) == 0) {
            n++;
        }
    }
    return n;
}

/* #1260: calls in `func` whose callee is "Run" or ends in ".Run", whatever
 * the qualifier. One iris.cls("X").Run() site must emit exactly one. */
static int count_run_calls_in_func(CBMFileResult *r, const char *func) {
    int n = 0;
    size_t flen = strlen(func);
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (!c->callee_name || !c->enclosing_func_qn) {
            continue;
        }
        size_t cl = strlen(c->callee_name);
        bool is_run = strcmp(c->callee_name, "Run") == 0 ||
                      (cl > 4 && strcmp(c->callee_name + cl - 4, ".Run") == 0);
        size_t qlen = strlen(c->enclosing_func_qn);
        if (is_run && qlen > flen && c->enclosing_func_qn[qlen - flen - 1] == '.' &&
            strcmp(c->enclosing_func_qn + qlen - flen, func) == 0) {
            n++;
        }
    }
    return n;
}

TEST(python_iris_cls_receiver_is_class_aware) {
    CBMFileResult *r = extract("import iris\n"
                               "def want_a():\n"
                               "    return iris.cls(\"Pkg.A\").Run(\"x\")\n"
                               "def want_b():\n"
                               "    return iris.cls('Pkg.B').Run('x')\n"
                               "def dynamic(name):\n"
                               "    return iris.cls(name).Run('x')\n"
                               "def fstring(n):\n"
                               "    return iris.cls(f'Pkg.{n}').Run('x')\n"
                               "def unrelated_receiver():\n"
                               "    return some_random_thing.Run('x')\n",
                               CBM_LANG_PYTHON, "t", "caller.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.A.Run", "want_a"), 1);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.B.Run", "want_b"), 1);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.A.Run", "want_b"), 0);
    /* The class-qualified callee replaces the bare one: no second call per site. */
    ASSERT_EQ(count_run_calls_in_func(r, "want_a"), 1);
    ASSERT_EQ(count_run_calls_in_func(r, "want_b"), 1);
    ASSERT_EQ(count_run_calls_in_func(r, "dynamic"), 1);
    /* A non-literal class argument names nothing: no class-qualified callee. */
    ASSERT_EQ(count_calls_in_func(r, "name.Run", "dynamic"), 0);
    /* An f-string is a Python "string" node but not a class name. */
    ASSERT_EQ(count_calls_in_func(r, "f'Pkg.{n}'.Run", "fstring"), 0);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.{n}.Run", "fstring"), 0);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.A.Run", "unrelated_receiver"), 0);
    ASSERT_EQ(count_calls_in_func(r, "Pkg.B.Run", "unrelated_receiver"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(python_iris_invokeClassMethod) {
    CBMFileResult *r =
        extract("def call(db):\n"
                "    return db.invokeClassMethod('MyApp.Service', 'SomeClassMethod', 1)\n",
                CBM_LANG_PYTHON, "t", "svc.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_calls_in_func(r, "MyApp.Service.SomeClassMethod", "call"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(go_calls) {
    CBMFileResult *r =
        extract("package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"hello\") }\n",
                CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "fmt.Println"));
    cbm_free_result(r);
    PASS();
}

TEST(python_imports) {
    CBMFileResult *r =
        extract("import os\nfrom sys import argv\nfrom collections import defaultdict\n",
                CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

/* The module_path recorded for a local name, or NULL. */
static const char *import_path_of(CBMFileResult *r, const char *local) {
    for (int i = 0; i < r->imports.count; i++) {
        if (r->imports.items[i].local_name && strcmp(r->imports.items[i].local_name, local) == 0)
            return r->imports.items[i].module_path;
    }
    return NULL;
}

/* `from . import x` names the importing file's OWN package: the path is ".x",
 * as `from .m import f` is ".m.f". Joining the all-dots module with another '.'
 * recorded "..x" (the parent package), so the import resolved one package too
 * high and fell to an arbitrary same-named definition (home-assistant: 7,175
 * calls bound to another integration's function). */
TEST(python_package_relative_import_paths) {
    CBMFileResult *r = extract("from . import async_register\n"
                               "from .. import shared\n"
                               "from . import local_fn as lf\n"
                               "from .helpers import helper_fn\n"
                               "from pkg.db import get_row\n",
                               CBM_LANG_PYTHON, "t", "comp/web/sub/mod.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const char *own = import_path_of(r, "async_register");
    const char *parent = import_path_of(r, "shared");
    const char *aliased = import_path_of(r, "lf");
    const char *member = import_path_of(r, "helper_fn");
    const char *absolute = import_path_of(r, "get_row");
    ASSERT_NOT_NULL(own);
    ASSERT_NOT_NULL(parent);
    ASSERT_NOT_NULL(aliased);
    ASSERT_NOT_NULL(member);
    ASSERT_NOT_NULL(absolute);
    ASSERT_STR_EQ(own, ".async_register");
    ASSERT_STR_EQ(parent, "..shared");
    ASSERT_STR_EQ(aliased, ".local_fn");
    ASSERT_STR_EQ(member, ".helpers.helper_fn"); /* control: unchanged */
    ASSERT_STR_EQ(absolute, "pkg.db.get_row");   /* control: unchanged */
    cbm_free_result(r);
    PASS();
}

TEST(js_imports) {
    CBMFileResult *r = extract("import React from 'react';\nimport { useState } from "
                               "'react';\nconst fs = require('fs');\n",
                               CBM_LANG_JAVASCRIPT, "t", "app.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(go_imports) {
    CBMFileResult *r =
        extract("package main\n\nimport \"fmt\"\nimport (\n    \"os\"\n    net \"net/http\"\n)\n",
                CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "fmt"));
    cbm_free_result(r);
    PASS();
}

/* cgo's `import "C"` is a pseudo-package, not a real import: keeping it lets the
 * import resolver name-match "C" onto an arbitrary project symbol called C. The
 * real imports of the same file must survive. */
TEST(go_cgo_pseudo_import_dropped) {
    CBMFileResult *r = extract("package m\n\n/*\nstatic int helper(void) { return 1; }\n*/\n"
                               "import \"C\"\n\nimport \"fmt\"\n\n"
                               "func Run() { fmt.Println(C.helper()) }\n",
                               CBM_LANG_GO, "t", "cgo.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_import(r, "fmt"));
    for (int i = 0; i < r->imports.count; i++) {
        ASSERT_NOT_NULL(r->imports.items[i].module_path);
        ASSERT_TRUE(strcmp(r->imports.items[i].module_path, "C") != 0);
    }
    cbm_free_result(r);
    PASS();
}

/* A Bash script imports the files it sources and nothing else. Every top-level
 * command used to be read as an import of its command name (`set -e` imported
 * "set", `source x.sh` imported "source"), which the import resolver bound to
 * any project symbol of that name; the sourced paths themselves were lost. */
TEST(bash_imports_are_sourced_files_only) {
    CBMFileResult *r = extract("#!/usr/bin/env bash\nset -euo pipefail\nsource ./lib/util.sh\n"
                               ". \"$DIR/other.sh\"\ncd build\nmake all\n"
                               "if true; then\n  source nested.sh\nfi\n",
                               CBM_LANG_BASH, "t", "run.sh");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(r->imports.count, 3);
    ASSERT(has_import(r, "lib/util.sh"));
    ASSERT(has_import(r, "other.sh"));
    ASSERT(has_import(r, "nested.sh"));
    static const char *const commands[] = {"set", "source", ".", "cd", "make"};
    for (int i = 0; i < r->imports.count; i++) {
        ASSERT_NOT_NULL(r->imports.items[i].module_path);
        for (size_t c = 0; c < sizeof(commands) / sizeof(commands[0]); c++) {
            ASSERT_TRUE(strcmp(r->imports.items[i].module_path, commands[c]) != 0);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* #1935: Go struct fields were never extracted — find_class_body() returns the
 * struct_type node, whose only named child is a field_declaration_list, so the
 * member loop matched nothing and every field was silently skipped (0 Field
 * nodes for ~5055 declarations on the measured repo). Interfaces hold their
 * method specs directly and always worked. The blank identifier `_` is struct
 * padding, not a referenceable field, and must stay out (241 collision edges
 * on two generated structs otherwise). */
TEST(extract_go_struct_fields_have_nodes) {
    CBMFileResult *r = extract("package fxf\n\n"
                               "type Config struct {\n"
                               "\tName    string\n"
                               "\tTimeout int\n"
                               "\tNested  *Config\n"
                               "\t_       [8]byte\n"
                               "}\n\n"
                               "type Reader interface {\n"
                               "\tRead(p []byte) (int, error)\n"
                               "\tClose() error\n"
                               "}\n",
                               CBM_LANG_GO, "t", "cfg.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* RED before the descend fix: count is 0. The blank identifier must not
     * bring it to 4. */
    ASSERT_EQ(count_defs_with_label(r, "Field"), 3);
    ASSERT_TRUE(has_def(r, "Field", "Name"));
    ASSERT_TRUE(has_def(r, "Field", "Timeout"));
    ASSERT_TRUE(has_def(r, "Field", "Nested"));
    ASSERT_FALSE(has_def(r, "Field", "_"));
    /* Each field carries its declared type in return_type. */
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (!d->label || strcmp(d->label, "Field") != 0) {
            continue;
        }
        ASSERT_NOT_NULL(d->return_type);
        if (strcmp(d->name, "Name") == 0) {
            ASSERT_TRUE(strcmp(d->return_type, "string") == 0);
        }
        if (strcmp(d->name, "Timeout") == 0) {
            ASSERT_TRUE(strcmp(d->return_type, "int") == 0);
        }
        if (strcmp(d->name, "Nested") == 0) {
            ASSERT_TRUE(strcmp(d->return_type, "*Config") == 0);
        }
    }
    /* Interface members keep extracting exactly as before. */
    ASSERT_TRUE(has_def(r, "Method", "Read"));
    ASSERT_TRUE(has_def(r, "Method", "Close"));
    cbm_free_result(r);
    PASS();
}

TEST(java_imports) {
    CBMFileResult *r = extract(
        "import java.util.List;\nimport java.util.ArrayList;\nimport static java.lang.Math.PI;\n"
        "public class Foo {}\n",
        CBM_LANG_JAVA, "t", "Foo.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "java.util.List"));
    cbm_free_result(r);
    PASS();
}

TEST(rust_imports) {
    CBMFileResult *r = extract(
        "use std::collections::HashMap;\nuse std::io::{self, Write};\nuse serde::Serialize;\n"
        "fn main() {}\n",
        CBM_LANG_RUST, "t", "main.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "std::collections::HashMap"));
    cbm_free_result(r);
    PASS();
}

TEST(c_imports) {
    CBMFileResult *r = extract("#include <stdio.h>\n#include <stdlib.h>\n#include "
                               "\"mylib.h\"\n\nint main() { return 0; }\n",
                               CBM_LANG_C, "t", "main.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "stdio.h"));
    cbm_free_result(r);
    PASS();
}

/* Every header keeps its includes inside its include guard, and plenty of
 * sources include behind `#ifdef`. Reading only the top level of the file
 * left a guarded header with no imports at all. */
TEST(c_imports_inside_preprocessor_blocks) {
    static const CBMLanguage langs[] = {CBM_LANG_C, CBM_LANG_CPP};
    for (size_t li = 0; li < sizeof(langs) / sizeof(langs[0]); li++) {
        CBMFileResult *r = extract("#ifndef GUARD_H\n"
                                   "#define GUARD_H\n"
                                   "#include \"first.h\"\n"
                                   "#include <second.h>\n"
                                   "#if defined(USE_X)\n"
                                   "#include \"x_only.h\"\n"
                                   "#elif defined(USE_Z)\n"
                                   "#include \"z_only.h\"\n"
                                   "#else\n"
                                   "#include \"y_only.h\"\n"
                                   "#endif\n"
                                   "int guarded(void);\n"
                                   "#endif\n",
                                   langs[li], "t", "guard.h");
        ASSERT_NOT_NULL(r);
        ASSERT(has_import(r, "first.h"));
        ASSERT(has_import(r, "second.h"));
        ASSERT(has_import(r, "x_only.h"));
        ASSERT(has_import(r, "z_only.h"));
        ASSERT(has_import(r, "y_only.h"));
        ASSERT_EQ(r->imports.count, 5);
        cbm_free_result(r);
    }
    /* Top-level includes come out once, as before. */
    CBMFileResult *r = extract("#include \"top.h\"\n"
                               "#ifdef WITH_EXTRA\n"
                               "#include \"extra.h\"\n"
                               "#endif\n"
                               "int f(void) { return 0; }\n",
                               CBM_LANG_C, "t", "top.c");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(r->imports.count, 2);
    ASSERT(has_import(r, "top.h"));
    ASSERT(has_import(r, "extra.h"));
    cbm_free_result(r);
    PASS();
}

TEST(ruby_imports) {
    CBMFileResult *r = extract(
        "require 'json'\nrequire 'net/http'\nrequire_relative 'helpers'\n\nclass Foo; end\n",
        CBM_LANG_RUBY, "t", "app.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "json"));
    cbm_free_result(r);
    PASS();
}

TEST(lua_imports) {
    CBMFileResult *r = extract("local json = require(\"dkjson\")\nlocal http = "
                               "require(\"socket.http\")\n\nlocal function greet() end\n",
                               CBM_LANG_LUA, "t", "main.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "dkjson"));
    cbm_free_result(r);
    PASS();
}

TEST(import_stress_go) {
    /* Stress test: 5,000 single-line Go imports.
     * Verifies O(N) behaviour — would hang indefinitely with the O(N²) loop. */
    const int N = 5000;
    /* Each line: import "pkg/NNNNN"\n  = ~20 chars; total ~100KB */
    int buf_size = N * 24 + 64;
    char *src = malloc((size_t)buf_size);
    ASSERT_NOT_NULL(src);

    int pos = 0;
    pos += snprintf(src + pos, (size_t)(buf_size - pos), "package stress\n");
    for (int k = 0; k < N; k++) {
        pos += snprintf(src + pos, (size_t)(buf_size - pos), "import \"pkg/%05d\"\n", k);
    }

    CBMFileResult *r = extract(src, CBM_LANG_GO, "t", "stress.go");
    free(src);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(r->imports.count, N);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Embedded-language import extraction
 * Host grammars (Svelte, Vue, HTML, Astro) keep <script> bodies as
 * raw_text — the embedded-imports walker re-parses each block with the
 * JS grammar so the standard ES import extractor sees real
 * import_statement nodes.
 * ═══════════════════════════════════════════════════════════════════ */

TEST(svelte_imports_basic) {
    /* Default import + named imports + namespace import */
    CBMFileResult *r = extract("<script>\n"
                               "import Foo from './Foo.svelte';\n"
                               "import { bar, baz } from '../lib/utils';\n"
                               "import * as helpers from './helpers';\n"
                               "export let value = 42;\n"
                               "</script>\n"
                               "<h1>Hello {value}</h1>\n",
                               CBM_LANG_SVELTE, "t", "Comp.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 3);
    ASSERT(has_import(r, "Foo.svelte"));
    ASSERT(has_import(r, "lib/utils"));
    ASSERT(has_import(r, "helpers"));
    cbm_free_result(r);
    PASS();
}

TEST(svelte_imports_no_script) {
    /* .svelte with no <script> block must not crash, 0 imports */
    CBMFileResult *r = extract("<h1>Static page</h1>\n"
                               "<p>No script here.</p>\n",
                               CBM_LANG_SVELTE, "t", "Static.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(vue_imports_basic) {
    /* Vue SFC: same document→script_element→raw_text AST structure */
    CBMFileResult *r = extract("<template><div>{{ msg }}</div></template>\n"
                               "<script>\n"
                               "import MyComp from './MyComp.vue';\n"
                               "import { ref } from 'vue';\n"
                               "export default { name: 'App' };\n"
                               "</script>\n",
                               CBM_LANG_VUE, "t", "App.vue");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    ASSERT(has_import(r, "MyComp.vue"));
    ASSERT(has_import(r, "vue"));
    cbm_free_result(r);
    PASS();
}

TEST(vue_embedded_structure_issue1410) {
    const char *src = "<template><div>caf\xC3\xA9</div></template>\r\n"
                      "<script>\r\n"
                      "import { external } from './dep.js';\r\n"
                      "function normalFn() { return callee(); }\r\n"
                      "</script>\r\n"
                      "<script setup lang=\"ts\">class Widget {}\r\n"
                      "function setupFn(): void { callee(); }</script>\r\n";
    CBMFileResult *r = extract(src, CBM_LANG_VUE, "t", "App.vue");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Module"), 1);
    ASSERT_EQ(count_defs_with_label(r, "Function"), 2);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 1);
    ASSERT_EQ(count_defs_named(r, "Function", "normalFn"), 1);
    ASSERT_EQ(count_defs_named(r, "Function", "setupFn"), 1);
    ASSERT_EQ(count_defs_named(r, "Class", "Widget"), 1);
    ASSERT_EQ(count_calls_named(r, "callee"), 2);
    ASSERT_EQ(r->imports.count, 1);
    ASSERT(has_import(r, "dep.js"));

    const CBMDefinition *normal = NULL;
    const CBMDefinition *widget = NULL;
    const CBMDefinition *setup = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "normalFn") == 0) {
            normal = &r->defs.items[i];
        } else if (strcmp(r->defs.items[i].name, "Widget") == 0) {
            widget = &r->defs.items[i];
        } else if (strcmp(r->defs.items[i].name, "setupFn") == 0) {
            setup = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(normal);
    ASSERT_NOT_NULL(widget);
    ASSERT_NOT_NULL(setup);
    ASSERT_EQ(normal->start_line, 4);
    ASSERT_EQ(widget->start_line, 6);
    ASSERT_EQ(setup->start_line, 7);
    cbm_free_result(r);
    PASS();
}

TEST(vue_embedded_structure_negative_controls_issue1410) {
    static const char *sources[] = {
        "<script lang=\"coffee\">function hidden() { forbidden(); }</script>\n",
        "<script src=\"./external.js\">function hidden() { forbidden(); }</script>\n",
        "<template><p>scriptless</p></template>\n",
    };
    for (int i = 0; i < 3; i++) {
        CBMFileResult *r = extract(sources[i], CBM_LANG_VUE, "t", "Negative.vue");
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        ASSERT_EQ(count_defs_with_label(r, "Module"), 1);
        ASSERT_EQ(count_defs_with_label(r, "Function"), 0);
        ASSERT_EQ(count_defs_with_label(r, "Class"), 0);
        ASSERT_EQ(r->calls.count, 0);
        ASSERT_EQ(r->imports.count, 0);
        cbm_free_result(r);
    }
    PASS();
}

/* The sibling hosts ride Vue's embedded seam: the function and call a .ts file
 * yields come out of a plain <script> (or Astro's frontmatter fence) the same
 * way, alongside the import those blocks always produced. */
TEST(embedded_structure_sibling_hosts_issue1807) {
    CBMFileResult *plain =
        extract("function plainTs(): void { target(); }\n", CBM_LANG_TYPESCRIPT, "t", "plain.ts");
    ASSERT_NOT_NULL(plain);
    ASSERT_FALSE(plain->has_error);
    ASSERT_EQ(count_defs_named(plain, "Function", "plainTs"), 1);
    ASSERT_EQ(count_calls_named(plain, "target"), 1);
    cbm_free_result(plain);

    static const struct {
        CBMLanguage language;
        const char *path;
        const char *source;
    } hosts[] = {
        {CBM_LANG_SVELTE, "Sibling.svelte",
         "<script>import value from './svelte.js'; function visible() { target(); }</script>\n"},
        {CBM_LANG_HTML, "sibling.html",
         "<script>import value from './html.js'; function visible() { target(); }</script>\n"},
        {CBM_LANG_ASTRO, "Sibling.astro",
         "---\nimport value from './astro.js'; function visible() { target(); }\n---\n"},
    };
    for (int i = 0; i < 3; i++) {
        CBMFileResult *r = extract(hosts[i].source, hosts[i].language, "t", hosts[i].path);
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        ASSERT_EQ(count_defs_with_label(r, "Module"), 1);
        ASSERT_EQ(count_defs_named(r, "Function", "visible"), 1);
        ASSERT_EQ(count_calls_named(r, "target"), 1);
        ASSERT_EQ(r->imports.count, 1);
        cbm_free_result(r);
    }
    PASS();
}

/* Blocks that must never yield inline symbols, whatever the host: an external
 * program (src=) and a non-JavaScript MIME type. The bodies are deliberately
 * code, so a leak would surface as a definition and a call. HTML's own tag
 * walker still records the src= reference as an import; that edge names the
 * external file and is not the inline body leaking through. */
TEST(embedded_structure_inert_blocks_issue1807) {
    static const struct {
        CBMLanguage language;
        const char *path;
        const char *source;
        int imports;
    } blocks[] = {
        {CBM_LANG_VUE, "Inert.vue",
         "<script type=\"application/json\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_VUE, "Inert.vue",
         "<script src=\"./x.js\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_SVELTE, "Inert.svelte",
         "<script type=\"application/json\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_SVELTE, "Inert.svelte",
         "<script src=\"./x.js\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_HTML, "inert.html",
         "<script type=\"application/json\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_HTML, "inert.html",
         "<script type=\"importmap\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_HTML, "inert.html",
         "<script type=\"text/x-template\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_HTML, "inert.html",
         "<script src=\"./x.js\">function hidden() { target(); }</script>\n", 1},
        {CBM_LANG_ASTRO, "Inert.astro",
         "<script type=\"application/json\">function hidden() { target(); }</script>\n", 0},
        {CBM_LANG_ASTRO, "Inert.astro",
         "<script src=\"./x.js\">function hidden() { target(); }</script>\n", 0},
    };
    for (int i = 0; i < 10; i++) {
        CBMFileResult *r = extract(blocks[i].source, blocks[i].language, "t", blocks[i].path);
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        ASSERT_EQ(count_defs_with_label(r, "Module"), 1);
        ASSERT_EQ(count_defs_with_label(r, "Function"), 0);
        ASSERT_EQ(r->calls.count, 0);
        ASSERT_EQ(r->imports.count, blocks[i].imports);
        cbm_free_result(r);
    }
    PASS();
}

/* Svelte's module-level block (<script context="module">, or <script module>
 * since Svelte 5) is a second block in the same file: both contribute, each
 * honouring its own lang=, in host-file coordinates. */
TEST(svelte_embedded_structure_both_blocks_issue1807) {
    static const char *sources[] = {
        "<script context=\"module\" lang=\"ts\">\n"
        "export function fromModule(): number { return shared(); }\n"
        "</script>\n"
        "<script lang=\"ts\">\n"
        "import { shared } from './shared';\n"
        "function fromInstance(): number { return shared() + fromModule(); }\n"
        "</script>\n"
        "<button on:click={fromInstance}>{fromModule()}</button>\n",
        "<script module lang=\"ts\">\n"
        "export function fromModule(): number { return shared(); }\n"
        "</script>\n"
        "<script lang=\"ts\">\n"
        "import { shared } from './shared';\n"
        "function fromInstance(): number { return shared() + fromModule(); }\n"
        "</script>\n"
        "<button onclick={fromInstance}>{fromModule()}</button>\n",
    };
    for (int i = 0; i < 2; i++) {
        CBMFileResult *r = extract(sources[i], CBM_LANG_SVELTE, "t", "Widget.svelte");
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        ASSERT_EQ(count_defs_with_label(r, "Function"), 2);
        ASSERT_EQ(count_defs_named(r, "Function", "fromModule"), 1);
        ASSERT_EQ(count_defs_named(r, "Function", "fromInstance"), 1);
        ASSERT_EQ(count_calls_named(r, "shared"), 2);
        ASSERT_EQ(count_calls_named(r, "fromModule"), 1);
        ASSERT_EQ(r->imports.count, 1);
        ASSERT(has_import(r, "shared"));
        for (int d = 0; d < r->defs.count; d++) {
            const CBMDefinition *def = &r->defs.items[d];
            if (strcmp(def->name, "fromModule") == 0) {
                ASSERT_EQ(def->start_line, 2);
            } else if (strcmp(def->name, "fromInstance") == 0) {
                ASSERT_EQ(def->start_line, 6);
            }
        }
        cbm_free_result(r);
    }
    PASS();
}

/* Every type= form HTML itself runs as JavaScript contributes, in host-file
 * coordinates; a data block on the same page does not. */
TEST(html_embedded_structure_issue1807) {
    CBMFileResult *r =
        extract("<!DOCTYPE html><html><head>\n"
                "<script type=\"module\">\n"
                "import { renderApp } from './app.js';\n"
                "function boot() { renderApp(); }\n"
                "</script>\n"
                "<script type=\"text/javascript\">\n"
                "function legacy() { boot(); }\n"
                "</script>\n"
                "<script type=\"application/javascript\">\n"
                "function fallback() { legacy(); }\n"
                "</script>\n"
                "<script type=\"application/ld+json\">{\"@type\": \"Thing\"}</script>\n"
                "</head><body></body></html>\n",
                CBM_LANG_HTML, "t", "index.html");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Function"), 3);
    ASSERT_EQ(count_calls_named(r, "renderApp"), 1);
    ASSERT_EQ(count_calls_named(r, "boot"), 1);
    ASSERT_EQ(count_calls_named(r, "legacy"), 1);
    ASSERT_EQ(r->imports.count, 1);
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (strcmp(d->name, "boot") == 0) {
            ASSERT_EQ(d->start_line, 4);
        } else if (strcmp(d->name, "legacy") == 0) {
            ASSERT_EQ(d->start_line, 7);
        } else if (strcmp(d->name, "fallback") == 0) {
            ASSERT_EQ(d->start_line, 10);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* Astro's frontmatter fence and <script> bodies are TypeScript by default: an
 * interface and typed signatures parse, and both blocks contribute in
 * host-file coordinates. */
TEST(astro_embedded_structure_issue1807) {
    CBMFileResult *r = extract("---\n"
                               "import Header from './Header.astro';\n"
                               "interface Props { title: string }\n"
                               "const { title }: Props = Astro.props;\n"
                               "function heading(): string { return format(title); }\n"
                               "---\n"
                               "<Header />\n"
                               "<script>\n"
                               "function hydrate(): void { heading(); }\n"
                               "</script>\n",
                               CBM_LANG_ASTRO, "t", "Page.astro");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Props"));
    ASSERT_EQ(count_defs_named(r, "Function", "heading"), 1);
    ASSERT_EQ(count_defs_named(r, "Function", "hydrate"), 1);
    ASSERT_EQ(count_calls_named(r, "format"), 1);
    ASSERT_EQ(count_calls_named(r, "heading"), 1);
    ASSERT_EQ(r->imports.count, 1);
    ASSERT(has_import(r, "Header.astro"));
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (strcmp(d->name, "heading") == 0) {
            ASSERT_EQ(d->start_line, 5);
        } else if (strcmp(d->name, "hydrate") == 0) {
            ASSERT_EQ(d->start_line, 9);
        }
    }
    cbm_free_result(r);
    PASS();
}

TEST(html_imports_basic) {
    /* Plain HTML with inline ES module imports — same generic walker. */
    CBMFileResult *r = extract("<!DOCTYPE html><html><head>\n"
                               "<script type=\"module\">\n"
                               "import { renderApp } from './app.js';\n"
                               "import * as utils from './utils.js';\n"
                               "renderApp();\n"
                               "</script>\n"
                               "</head><body></body></html>\n",
                               CBM_LANG_HTML, "t", "index.html");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    ASSERT(has_import(r, "app.js"));
    ASSERT(has_import(r, "utils.js"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * config_extraction_test.go ports (25 tests)
 * ═══════════════════════════════════════════════════════════════════ */

/* --- TOML (8 tests) --- */

TEST(toml_basic_table_and_pair) {
    CBMFileResult *r = extract("[database]\nhost = \"localhost\"\nport = 5432\n", CBM_LANG_TOML,
                               "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 1);
    ASSERT(has_def(r, "Class", "database"));
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

TEST(toml_nested_table) {
    CBMFileResult *r = extract("[server.http]\nport = 8080\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_table_array_element) {
    CBMFileResult *r = extract("[[servers]]\nname = \"alpha\"\n[[servers]]\nname = \"beta\"\n",
                               CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(toml_dotted_key) {
    CBMFileResult *r =
        extract("database.host = \"localhost\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_quoted_key) {
    CBMFileResult *r = extract("\"unusual-key\" = \"value\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_empty_table) {
    CBMFileResult *r = extract("[empty]\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 1);
    ASSERT(has_def(r, "Class", "empty"));
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(toml_comments_only) {
    CBMFileResult *r =
        extract("# just a comment\n# another comment\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0);
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(toml_boolean_and_integer_values) {
    CBMFileResult *r =
        extract("enabled = true\ncount = 42\nname = \"test\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

/* --- INI (4 tests) --- */

TEST(ini_basic_section_and_setting) {
    CBMFileResult *r =
        extract("[database]\nhost = localhost\nport = 5432\n", CBM_LANG_INI, "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_multiple_sections) {
    CBMFileResult *r = extract("[section1]\nkey1 = val1\n[section2]\nkey2 = val2\n", CBM_LANG_INI,
                               "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_global_keys) {
    CBMFileResult *r = extract("key1 = value1\nkey2 = value2\n", CBM_LANG_INI, "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_comments) {
    CBMFileResult *r = extract("; comment\n# another comment\n[section]\nkey = val\n", CBM_LANG_INI,
                               "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

/* --- JSON (5 tests) --- */

TEST(json_basic_pair) {
    CBMFileResult *r =
        extract("{\"host\": \"localhost\", \"port\": 5432}", CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

TEST(json_nested_object) {
    CBMFileResult *r = extract("{\"database\": {\"host\": \"localhost\", \"port\": 5432}}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

TEST(json_empty_object) {
    CBMFileResult *r = extract("{}", CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(json_boolean_null_values) {
    CBMFileResult *r = extract("{\"enabled\": true, \"value\": null, \"name\": \"test\"}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

TEST(json_package_json_deps) {
    CBMFileResult *r =
        extract("{\"name\":\"pkg\",\"dependencies\":{\"express\":\"^4.0\",\"lodash\":\"^4.17\"}}",
                CBM_LANG_JSON, "t", "package.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 4);
    ASSERT(has_def(r, "Variable", "name"));
    ASSERT(has_def(r, "Variable", "dependencies"));
    ASSERT(has_def(r, "Variable", "express"));
    ASSERT(has_def(r, "Variable", "lodash"));
    cbm_free_result(r);
    PASS();
}

/* --- XML (4 tests) --- */

TEST(xml_basic_element) {
    CBMFileResult *r = extract(
        "<?xml version=\"1.0\"?><config><database><host>localhost</host></database></config>",
        CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 3);
    ASSERT(has_def(r, "Class", "config"));
    ASSERT(has_def(r, "Class", "database"));
    ASSERT(has_def(r, "Class", "host"));
    cbm_free_result(r);
    PASS();
}

TEST(xml_self_closing_tag) {
    CBMFileResult *r =
        extract("<?xml version=\"1.0\"?><config><feature enabled=\"true\"/></config>", CBM_LANG_XML,
                "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(xml_empty_document) {
    CBMFileResult *r = extract("<?xml version=\"1.0\"?><root/>", CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(xml_multiple_children) {
    CBMFileResult *r =
        extract("<?xml version=\"1.0\"?><servers><server/><server/><server/></servers>",
                CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 4); /* servers + 3x server */
    cbm_free_result(r);
    PASS();
}

/* --- Markdown (4 tests) --- */

TEST(markdown_atx_headings) {
    CBMFileResult *r =
        extract("# Title\n## Section\n### Subsection\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 3);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0); /* Markdown: Section, not Class */
    cbm_free_result(r);
    PASS();
}

TEST(markdown_setext_headings) {
    CBMFileResult *r =
        extract("Title\n=====\nSection\n------\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(markdown_heading_content) {
    CBMFileResult *r = extract("# Installation Guide\n## Prerequisites\n## Setup\n",
                               CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 3);
    ASSERT(has_def(r, "Section", "Installation Guide"));
    ASSERT(has_def(r, "Section", "Prerequisites"));
    ASSERT(has_def(r, "Section", "Setup"));
    cbm_free_result(r);
    PASS();
}

TEST(markdown_no_headings) {
    CBMFileResult *r =
        extract("Just a paragraph\n\nAnother paragraph\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Section"), 0);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Python __init__.py Module QN collision regression
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_init_module_qn_not_collide_with_folder) {
    /* Bug: __init__.py Module QN was identical to the Folder QN for the
     * same directory, causing the Folder node to be overwritten when the
     * Module was upserted. The Module QN must contain "__init__" to
     * distinguish it from the Folder QN. */
    CBMFileResult *r = extract("class Config:\n    DEBUG = True\n\ndef setup():\n    pass\n",
                               CBM_LANG_PYTHON, "proj", "mypackage/__init__.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module node must exist */
    ASSERT_GTE(r->defs.count, 1);
    ASSERT_STR_EQ(r->defs.items[0].label, "Module");

    /* Module QN must contain __init__ (not be stripped to just "proj.mypackage") */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_NOT_NULL(strstr(r->module_qn, "__init__"));

    /* But symbols inside __init__.py should NOT have __init__ in their QN */
    int found_config = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "Config") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].qualified_name);
            /* Should be "proj.mypackage.Config", NOT "proj.mypackage.__init__.Config" */
            ASSERT_STR_EQ(r->defs.items[i].qualified_name, "proj.mypackage.Config");
            found_config = 1;
        }
    }
    ASSERT_EQ(found_config, 1);

    cbm_free_result(r);
    PASS();
}

TEST(python_init_nested_module_qn) {
    /* Deeply nested __init__.py — same collision must not happen */
    CBMFileResult *r = extract("def greet():\n    return 'hello'\n", CBM_LANG_PYTHON, "proj",
                               "docker-images/cloud-runs/bq-sync-api/__init__.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Must contain __init__ to not collide with Folder QN */
    ASSERT_NOT_NULL(strstr(r->module_qn, "__init__"));
    cbm_free_result(r);
    PASS();
}

/* ── #1548: Python defs nested in a function body ─────────────────── */

/* How many defs carry exactly this QN. */
static int pyn_def_count(const CBMFileResult *r, const char *qn) {
    int n = 0;
    for (int i = 0; i < r->defs.count; i++) {
        const char *q = r->defs.items[i].qualified_name;
        if (q && strcmp(q, qn) == 0) {
            n++;
        }
    }
    return n;
}

/* The one def with this QN, or NULL when there is none (or more than one). */
static const CBMDefinition *pyn_def(const CBMFileResult *r, const char *qn) {
    if (pyn_def_count(r, qn) != 1) {
        return NULL;
    }
    for (int i = 0; i < r->defs.count; i++) {
        const char *q = r->defs.items[i].qualified_name;
        if (q && strcmp(q, qn) == 0) {
            return &r->defs.items[i];
        }
    }
    return NULL;
}

/* Calls of `callee` whose enclosing function is exactly `caller_qn`. */
static int pyn_calls(const CBMFileResult *r, const char *callee, const char *caller_qn) {
    int n = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->callee_name && strcmp(c->callee_name, callee) == 0 && c->enclosing_func_qn &&
            strcmp(c->enclosing_func_qn, caller_qn) == 0) {
            n++;
        }
    }
    return n;
}

/* No def QN is minted twice: a nested def must not also surface as a
 * module-level one, and walking a def body must not re-extract anything. */
static bool pyn_defs_unique(const CBMFileResult *r) {
    for (int i = 0; i < r->defs.count; i++) {
        const char *q = r->defs.items[i].qualified_name;
        if (q && pyn_def_count(r, q) != 1) {
            return false;
        }
    }
    return true;
}

/* The issue's reproducer: `def nested()` inside `def factory()` was never
 * extracted. It is now a Function qualified by the def it sits in, the same
 * QN the Python LSP gives its calls. Module-level defs, and defs in a
 * module-level `if` block, keep their QNs. */
TEST(extract_python_nested_def_qualified_by_enclosing_def_issue1548) {
    CBMFileResult *r = extract("def target():\n"
                               "    return 0\n"
                               "\n"
                               "\n"
                               "def module_level():\n"
                               "    return target()\n"
                               "\n"
                               "\n"
                               "if True:\n"
                               "    def inside_if():\n"
                               "        return target()\n"
                               "\n"
                               "\n"
                               "def factory():\n"
                               "    def nested():\n"
                               "        return target()\n"
                               "    return nested\n"
                               "\n"
                               "\n"
                               "def outer():\n"
                               "    def middle():\n"
                               "        def inner():\n"
                               "            return target()\n"
                               "        return inner\n"
                               "    return middle\n",
                               CBM_LANG_PYTHON, "t", "app.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *nested = pyn_def(r, "t.app.factory.nested");
    ASSERT_NOT_NULL(nested);
    ASSERT_STR_EQ(nested->label, "Function");
    ASSERT_EQ(nested->start_line, 15);
    ASSERT_NOT_NULL(pyn_def(r, "t.app.outer.middle"));
    ASSERT_NOT_NULL(pyn_def(r, "t.app.outer.middle.inner"));
    /* Never minted flat, where it would collide with a module-level name. */
    ASSERT_EQ(pyn_def_count(r, "t.app.nested"), 0);
    ASSERT_EQ(pyn_def_count(r, "t.app.inner"), 0);
    /* Controls: unchanged. */
    ASSERT_NOT_NULL(pyn_def(r, "t.app.target"));
    ASSERT_NOT_NULL(pyn_def(r, "t.app.module_level"));
    ASSERT_NOT_NULL(pyn_def(r, "t.app.inside_if"));
    ASSERT_NOT_NULL(pyn_def(r, "t.app.factory"));
    ASSERT_TRUE(pyn_defs_unique(r));
    cbm_free_result(r);
    PASS();
}

/* A call inside a nested def belongs to that def. It used to carry the flat
 * `t.app.nested`, a QN no node has, so the edge was pinned on the file node:
 * inbound traces of target() lost the caller. It is not the outer def's
 * either. */
TEST(extract_python_nested_def_calls_attributed_to_it_issue1548) {
    CBMFileResult *r = extract("def target():\n"
                               "    return 0\n"
                               "\n"
                               "def factory():\n"
                               "    def nested():\n"
                               "        return target()\n"
                               "    return nested\n"
                               "\n"
                               "def outer():\n"
                               "    def middle():\n"
                               "        def inner():\n"
                               "            return target()\n"
                               "        return inner\n"
                               "    return middle\n",
                               CBM_LANG_PYTHON, "t", "app.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(pyn_calls(r, "target", "t.app.factory.nested"), 1);
    ASSERT_EQ(pyn_calls(r, "target", "t.app.outer.middle.inner"), 1);
    ASSERT_EQ(pyn_calls(r, "target", "t.app.factory"), 0);
    ASSERT_EQ(pyn_calls(r, "target", "t.app.nested"), 0);
    ASSERT_EQ(pyn_calls(r, "target", "t.app.inner"), 0);
    cbm_free_result(r);
    PASS();
}

/* The app-factory shape: route handlers are decorated defs inside
 * create_app. Each is extracted with its QN and carries the route its
 * decorator declares, which is what mints the Route node and its HANDLES
 * edge (pipeline_python_app_factory_routes_issue1548 checks the graph). */
TEST(extract_python_decorated_nested_route_handler_issue1548) {
    CBMFileResult *r = extract("from flask import Flask\n"
                               "\n"
                               "def create_app():\n"
                               "    app = Flask(__name__)\n"
                               "\n"
                               "    @app.route(\"/users/<uid>\")\n"
                               "    def show_user(uid):\n"
                               "        return render(uid)\n"
                               "\n"
                               "    @app.get(\"/health\")\n"
                               "    async def health():\n"
                               "        return render(\"ok\")\n"
                               "\n"
                               "    return app\n",
                               CBM_LANG_PYTHON, "t", "web.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *show = pyn_def(r, "t.web.create_app.show_user");
    ASSERT_NOT_NULL(show);
    ASSERT_STR_EQ(show->route_path, "/users/<uid>");
    ASSERT_NOT_NULL(show->decorators);
    const CBMDefinition *health = pyn_def(r, "t.web.create_app.health");
    ASSERT_NOT_NULL(health);
    ASSERT_STR_EQ(health->route_path, "/health");
    ASSERT_STR_EQ(health->route_method, "GET");
    ASSERT_EQ(pyn_calls(r, "render", "t.web.create_app.show_user"), 1);
    ASSERT_EQ(pyn_calls(r, "render", "t.web.create_app.health"), 1);
    ASSERT_TRUE(pyn_defs_unique(r));
    cbm_free_result(r);
    PASS();
}

/* A class declared in a def is qualified by the def; its methods are Methods
 * of it, and a call in such a method is the method's. */
TEST(extract_python_nested_class_issue1548) {
    CBMFileResult *r = extract("def create_app():\n"
                               "    class Settings:\n"
                               "        debug = False\n"
                               "\n"
                               "        def value(self):\n"
                               "            return load(self)\n"
                               "\n"
                               "    return Settings().value()\n",
                               CBM_LANG_PYTHON, "t", "web.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *cls = pyn_def(r, "t.web.create_app.Settings");
    ASSERT_NOT_NULL(cls);
    ASSERT_STR_EQ(cls->label, "Class");
    const CBMDefinition *value = pyn_def(r, "t.web.create_app.Settings.value");
    ASSERT_NOT_NULL(value);
    ASSERT_STR_EQ(value->label, "Method");
    ASSERT_STR_EQ(value->parent_class, "t.web.create_app.Settings");
    ASSERT_EQ(pyn_calls(r, "load", "t.web.create_app.Settings.value"), 1);
    ASSERT_EQ(pyn_def_count(r, "t.web.Settings"), 0);
    ASSERT_TRUE(pyn_defs_unique(r));
    cbm_free_result(r);
    PASS();
}

/* A def nested in a method, named like the method (django's
 * AbstractBaseUser.check_password holds a `def setter`; Tree.visit here holds
 * a `def visit`). It used to share the method's QN, so its calls -- its
 * recursion included -- were the method's. It is its own Function now: the
 * recursive call and render() are its, only visit(node) is the method's, and
 * the recursion seed flags the nested def. */
TEST(extract_python_nested_def_named_like_its_method_issue1548) {
    CBMFileResult *r = extract("class Tree:\n"
                               "    def visit(self, node):\n"
                               "        def visit(n):\n"
                               "            if n:\n"
                               "                visit(n.child)\n"
                               "                render(n)\n"
                               "\n"
                               "        visit(node)\n",
                               CBM_LANG_PYTHON, "t", "m.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *method = pyn_def(r, "t.m.Tree.visit");
    ASSERT_NOT_NULL(method);
    ASSERT_STR_EQ(method->label, "Method");
    const CBMDefinition *nested = pyn_def(r, "t.m.Tree.visit.visit");
    ASSERT_NOT_NULL(nested);
    ASSERT_STR_EQ(nested->label, "Function");
    ASSERT_EQ(nested->start_line, 3);
    ASSERT_EQ(pyn_calls(r, "visit", "t.m.Tree.visit.visit"), 1);
    ASSERT_EQ(pyn_calls(r, "render", "t.m.Tree.visit.visit"), 1);
    ASSERT_EQ(pyn_calls(r, "visit", "t.m.Tree.visit"), 1);
    ASSERT_EQ(pyn_calls(r, "render", "t.m.Tree.visit"), 0);
    ASSERT_TRUE(nested->is_recursive);
    ASSERT_TRUE(pyn_defs_unique(r));
    cbm_free_result(r);
    PASS();
}

/* Controls: a lambda and the comprehensions are expressions, not defs. They
 * mint nothing, and the calls inside them stay the enclosing def's. */
TEST(extract_python_lambda_and_comprehension_stay_in_enclosing_def_issue1548) {
    CBMFileResult *r = extract("def work(items):\n"
                               "    double = lambda x: scale(x)\n"
                               "    squares = [scale(i) for i in items]\n"
                               "    table = {k: scale(k) for k in items}\n"
                               "    return double(squares), table\n",
                               CBM_LANG_PYTHON, "t", "c.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(pyn_def(r, "t.c.work"));
    for (int i = 0; i < r->defs.count; i++) {
        const char *q = r->defs.items[i].qualified_name;
        ASSERT_FALSE(q && strncmp(q, "t.c.work.", strlen("t.c.work.")) == 0);
    }
    ASSERT_EQ(pyn_calls(r, "scale", "t.c.work"), 3);
    ASSERT_TRUE(pyn_defs_unique(r));
    cbm_free_result(r);
    PASS();
}

/* Records other than calls take their enclosing function from the same
 * unified-walk scope frame as the calls. The nested def's env read carries its
 * QN; the outer def's reads, before and after the nested def, keep the outer
 * QN once its frame is popped. */
TEST(extract_python_nested_def_env_access_attributed_to_it_issue1548) {
    CBMFileResult *r = extract("import os\n"
                               "\n"
                               "def outer():\n"
                               "    token = os.environ[\"OUTER_TOKEN\"]\n"
                               "\n"
                               "    def inner():\n"
                               "        return os.environ[\"INNER_TOKEN\"]\n"
                               "\n"
                               "    return inner, token, os.environ[\"OUTER_AGAIN\"]\n",
                               CBM_LANG_PYTHON, "t", "e.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int seen = 0;
    for (int i = 0; i < r->env_accesses.count; i++) {
        const CBMEnvAccess *ea = &r->env_accesses.items[i];
        ASSERT_NOT_NULL(ea->enclosing_func_qn);
        if (strcmp(ea->env_key, "INNER_TOKEN") == 0) {
            ASSERT_STR_EQ(ea->enclosing_func_qn, "t.e.outer.inner");
            seen++;
        } else {
            ASSERT_STR_EQ(ea->enclosing_func_qn, "t.e.outer");
            seen++;
        }
    }
    ASSERT_EQ(seen, 3);
    cbm_free_result(r);
    PASS();
}

TEST(js_index_module_qn_not_collide_with_folder) {
    /* Same bug for JS/TS index.ts files */
    CBMFileResult *r = extract("export function App() { return null; }\n", CBM_LANG_TYPESCRIPT,
                               "proj", "src/components/index.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Must contain "index" to not collide with Folder QN */
    ASSERT_NOT_NULL(strstr(r->module_qn, "index"));
    cbm_free_result(r);
    PASS();
}

TEST(python_regular_module_qn_unchanged) {
    /* Non-__init__.py Python files should be unaffected */
    CBMFileResult *r =
        extract("def helper():\n    pass\n", CBM_LANG_PYTHON, "proj", "mypackage/utils.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Regular module QN should not contain __init__ or index */
    ASSERT_STR_EQ(r->module_qn, "proj.mypackage.utils");
    cbm_free_result(r);
    PASS();
}

/* Find a definition by name; returns the item or NULL. */
static const CBMDefinition *find_def_by_name(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0) {
            return &r->defs.items[i];
        }
    }
    return NULL;
}

static int decorators_contain(const CBMDefinition *d, const char *needle) {
    if (!d || !d->decorators) {
        return 0;
    }
    for (int i = 0; d->decorators[i]; i++) {
        if (strstr(d->decorators[i], needle)) {
            return 1;
        }
    }
    return 0;
}

/* Issue #382: Java Method nodes had empty decorators / signature. */
TEST(extract_java_method_annotations_issue382) {
    CBMFileResult *r = extract("public class C {\n"
                               "  @GetMapping(\"/x\")\n"
                               "  public String cmd(String c) { return c; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "C.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *m = find_def_by_name(r, "cmd");
    ASSERT_NOT_NULL(m);
    ASSERT(decorators_contain(m, "GetMapping"));
    ASSERT_NOT_NULL(m->signature);
    ASSERT(m->signature[0] != '\0');
    cbm_free_result(r);
    PASS();
}

/* Distilled from PR #1245 (Andrew Hundt): unittest.mock's `@patch("x")` is a
 * bare decorator whose name collides with the HTTP verb, and its only argument
 * is a dotted target, not a path. The "/" fallback then minted a Route handler
 * PATCH "/" for every mocked test function. Rule: a decorator call WITH
 * arguments but no path-shaped one is not a route. */
TEST(extract_python_mock_patch_is_not_route) {
    CBMFileResult *r = extract("from unittest.mock import patch\n\n"
                               "@patch(\"subprocess.run\")\n"
                               "def test_cmd(mock_run):\n"
                               "    pass\n\n"
                               "@app.patch(\"/items/{id}\")\n"
                               "def update_item():\n"
                               "    pass\n",
                               CBM_LANG_PYTHON, "t", "test_routes.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *mocked = find_def_by_name(r, "test_cmd");
    ASSERT_NOT_NULL(mocked);
    ASSERT_NULL(mocked->route_path);
    ASSERT_NULL(mocked->route_method);

    const CBMDefinition *route = find_def_by_name(r, "update_item");
    ASSERT_NOT_NULL(route);
    ASSERT_STR_EQ(route->route_path, "/items/{id}");
    ASSERT_STR_EQ(route->route_method, "PATCH");

    cbm_free_result(r);
    PASS();
}

/* Companion to the mock-patch case: the narrowing must not cost real routes.
 * A receiver-less framework decorator with a path-shaped argument (Litestar /
 * BlackSheep `@get("/x")`) stays a route, `@mock.patch("x")` (receiver, but
 * no path) is not one, and a zero-argument `@app.route()` keeps the "/"
 * default main emits today. */
TEST(extract_python_bare_decorator_route_rules) {
    CBMFileResult *r = extract("from litestar import get\n"
                               "from unittest import mock\n\n"
                               "@get(\"/health\")\n"
                               "def health():\n"
                               "    pass\n\n"
                               "@mock.patch(\"os.getcwd\")\n"
                               "def test_cwd(mock_cwd):\n"
                               "    pass\n\n"
                               "@app.route()\n"
                               "def index():\n"
                               "    pass\n",
                               CBM_LANG_PYTHON, "t", "routes.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMDefinition *health = find_def_by_name(r, "health");
    ASSERT_NOT_NULL(health);
    ASSERT_STR_EQ(health->route_path, "/health");
    ASSERT_STR_EQ(health->route_method, "GET");

    const CBMDefinition *mocked = find_def_by_name(r, "test_cwd");
    ASSERT_NOT_NULL(mocked);
    ASSERT_NULL(mocked->route_path);
    ASSERT_NULL(mocked->route_method);

    const CBMDefinition *index = find_def_by_name(r, "index");
    ASSERT_NOT_NULL(index);
    ASSERT_STR_EQ(index->route_path, "/");
    ASSERT_STR_EQ(index->route_method, "ANY");

    cbm_free_result(r);
    PASS();
}

/* Issue #2090: Solidity modifier_invocation tracked as decorator. */
TEST(solidity_modifier_decorator) {
    CBMFileResult *r = extract("pragma solidity ^0.8.0;\n"
                               "contract Vault {\n"
                               "    modifier onlyOwner() { _; }\n"
                               "    function withdraw() public onlyOwner {\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_SOLIDITY, "t", "Vault.sol");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *m = find_def_by_name(r, "withdraw");
    ASSERT_NOT_NULL(m);
    ASSERT(decorators_contain(m, "onlyOwner"));
    cbm_free_result(r);
    PASS();
}

/* ── ArkTS (HarmonyOS .ets) ─────────────────────────────────────── */

TEST(arkts_component_struct) {
    CBMFileResult *r =
        extract("@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello'\n\n"
                "  build() {\n    Column() {\n      Text(this.message).fontSize(20)\n    }\n"
                "    .width('100%')\n  }\n}\n",
                CBM_LANG_ARKTS, "t", "Index.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "Index"));
    ASSERT(has_def(r, "Method", "build"));
    ASSERT(has_def(r, "Field", "message"));
    const CBMDefinition *s = find_def_by_name(r, "Index");
    ASSERT(decorators_contain(s, "Component"));
    ASSERT(decorators_contain(s, "Entry"));
    cbm_free_result(r);
    PASS();
}

/* The common shared-component form: `@Component export struct X` puts the
 * decorator on the export_statement; extract_decorators reaches it through
 * the prev-sibling walk (skipping the anonymous `export` token). */
TEST(arkts_exported_struct_decorators) {
    CBMFileResult *r = extract("@Component\nexport struct TitleBar {\n"
                               "  @Prop title: string\n\n  build() {\n    Row() {\n"
                               "      Text(this.title)\n    }\n  }\n}\n",
                               CBM_LANG_ARKTS, "t", "TitleBar.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "TitleBar"));
    ASSERT(decorators_contain(find_def_by_name(r, "TitleBar"), "Component"));
    ASSERT(has_def(r, "Field", "title"));
    cbm_free_result(r);
    PASS();
}

TEST(arkts_member_decorators) {
    CBMFileResult *r =
        extract("@Component\nstruct S {\n  @State a: number = 0\n  @Prop b: string\n"
                "  @Link c: boolean\n  @Provide('k') d: string = ''\n  @Consume('k') e: string\n"
                "  @StorageLink('s') f: number = 1\n  @State @Watch('onW') g: boolean = false\n\n"
                "  build() {\n  }\n}\n",
                CBM_LANG_ARKTS, "t", "S.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(decorators_contain(find_def_by_name(r, "a"), "State"));
    ASSERT(decorators_contain(find_def_by_name(r, "b"), "Prop"));
    ASSERT(decorators_contain(find_def_by_name(r, "c"), "Link"));
    ASSERT(decorators_contain(find_def_by_name(r, "d"), "Provide"));
    ASSERT(decorators_contain(find_def_by_name(r, "e"), "Consume"));
    ASSERT(decorators_contain(find_def_by_name(r, "f"), "StorageLink"));
    ASSERT(decorators_contain(find_def_by_name(r, "g"), "Watch"));
    cbm_free_result(r);
    PASS();
}

/* Spike regression: ArkUI builtins must never be emitted as definitions.
 * Routing .ets through the plain TypeScript grammar made `Column() { ... }`
 * parse chaos mint Column/Row/ListItem/... as user function DEFINITIONS
 * (0/19 components found; 28% of CALLS edges were cross-file fabrications).
 * With the arkts grammar they are call expressions — calls, never defs. */
TEST(arkts_no_phantom_builtin_defs) {
    CBMFileResult *r = extract(
        "@Component\nstruct S {\n  build() {\n    Column() {\n      Row() {\n"
        "        Text('x').fontSize(10)\n      }\n      List() {\n        ListItem() {\n"
        "          Text('y')\n        }\n      }\n      ForEach(this.items, (i: string) => {\n"
        "        Text(i)\n      })\n    }\n    .width('100%')\n  }\n}\n",
        CBM_LANG_ARKTS, "t", "S.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    static const char *builtins[] = {"Column", "Row", "Text", "List", "ListItem", "ForEach", NULL};
    for (int i = 0; builtins[i]; i++) {
        ASSERT_FALSE(has_def_any(r, builtins[i]));
    }
    ASSERT(has_call(r, "Column"));
    ASSERT(has_call(r, "ListItem"));
    ASSERT(has_call(r, "ForEach"));
    cbm_free_result(r);
    PASS();
}

TEST(arkts_builder_extend_styles) {
    CBMFileResult *r =
        extract("@Builder\nfunction card(t: string) {\n  Column() {\n    Text(t)\n  }\n}\n\n"
                "@Extend(Text)\nfunction fancy(size: number) {\n  .fontSize(size)\n}\n\n"
                "@Styles\nfunction pressed() {\n  .backgroundColor('#eee')\n}\n",
                CBM_LANG_ARKTS, "t", "b.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "card"));
    ASSERT(has_def(r, "Function", "fancy"));
    ASSERT(has_def(r, "Function", "pressed"));
    ASSERT(decorators_contain(find_def_by_name(r, "card"), "Builder"));
    ASSERT(decorators_contain(find_def_by_name(r, "fancy"), "Extend"));
    cbm_free_result(r);
    PASS();
}

TEST(arkts_lazy_import) {
    CBMFileResult *r = extract("import lazy { HeavyModule, Other } from './heavy'\n"
                               "import { router } from '@kit.ArkUI'\n"
                               "import lazy from './lazymod'\n",
                               CBM_LANG_ARKTS, "t", "i.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_import(r, "./heavy"));
    ASSERT(has_import(r, "@kit.ArkUI"));
    ASSERT(has_import(r, "./lazymod"));
    int heavy = 0, other = 0;
    for (int i = 0; i < r->imports.count; i++) {
        if (r->imports.items[i].local_name) {
            if (strcmp(r->imports.items[i].local_name, "HeavyModule") == 0) {
                heavy = 1;
            }
            if (strcmp(r->imports.items[i].local_name, "Other") == 0) {
                other = 1;
            }
        }
    }
    ASSERT(heavy);
    ASSERT(other);
    cbm_free_result(r);
    PASS();
}

TEST(arkts_ts_compat) {
    CBMFileResult *r = extract(
        "@Observed\nclass Model {\n  count: number = 0\n  bump(): void { this.count++ }\n}\n\n"
        "interface Props {\n  title: string\n}\n\n"
        "export function helper(x: number): number {\n  return x * 2\n}\n",
        CBM_LANG_ARKTS, "t", "m.ets");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Model"));
    ASSERT(has_def(r, "Method", "bump"));
    ASSERT(has_def(r, "Interface", "Props"));
    ASSERT(has_def(r, "Function", "helper"));
    cbm_free_result(r);
    PASS();
}

/* Issue #1005: JAX-RS splits a route across two annotations (@GET carries the
 * verb, a sibling @Path carries the path). Returning on the first mapping
 * annotation dropped every method-level @Path, and the class-level @Path
 * prefix was never recognized at all. */
TEST(extract_java_jaxrs_path_composition_issue1005) {
    CBMFileResult *r = extract("import jakarta.ws.rs.GET;\n"
                               "import jakarta.ws.rs.Path;\n"
                               "@Path(\"/api/v1/widgets\")\n"
                               "public class WidgetResource {\n"
                               "  @GET\n"
                               "  public String list() { return \"\"; }\n"
                               "  @GET\n"
                               "  @Path(\"/count\")\n"
                               "  public String count() { return \"\"; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "WidgetResource.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *list = find_def_by_name(r, "list");
    ASSERT_NOT_NULL(list);
    ASSERT_NOT_NULL(list->route_path);
    ASSERT_STR_EQ(list->route_path, "/api/v1/widgets");
    ASSERT_STR_EQ(list->route_method, "GET");
    const CBMDefinition *count = find_def_by_name(r, "count");
    ASSERT_NOT_NULL(count);
    ASSERT_NOT_NULL(count->route_path);
    ASSERT_STR_EQ(count->route_path, "/api/v1/widgets/count");
    ASSERT_STR_EQ(count->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* JAX-RS @Path values are URI templates relative to the enclosing resource;
 * the leading slash is optional and ignored by the framework. Relative class
 * and method templates must compose to the same rooted routes as the
 * slash-prefixed spelling above. */
TEST(extract_java_jaxrs_relative_path_templates) {
    CBMFileResult *r = extract("import jakarta.ws.rs.GET;\n"
                               "import jakarta.ws.rs.Path;\n"
                               "@Path(\"api/v1/widgets\")\n"
                               "public class WidgetResource {\n"
                               "  @GET\n"
                               "  public String list() { return \"\"; }\n"
                               "  @GET\n"
                               "  @Path(\"count\")\n"
                               "  public String count() { return \"\"; }\n"
                               "  @GET\n"
                               "  @Path(\"{id}/tags\")\n"
                               "  public String tags() { return \"\"; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "WidgetResource.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *list = find_def_by_name(r, "list");
    ASSERT_NOT_NULL(list);
    ASSERT_NOT_NULL(list->route_path);
    ASSERT_STR_EQ(list->route_path, "/api/v1/widgets");
    ASSERT_STR_EQ(list->route_method, "GET");
    const CBMDefinition *count = find_def_by_name(r, "count");
    ASSERT_NOT_NULL(count);
    ASSERT_NOT_NULL(count->route_path);
    ASSERT_STR_EQ(count->route_path, "/api/v1/widgets/count");
    ASSERT_STR_EQ(count->route_method, "GET");
    const CBMDefinition *tags = find_def_by_name(r, "tags");
    ASSERT_NOT_NULL(tags);
    ASSERT_NOT_NULL(tags->route_path);
    ASSERT_STR_EQ(tags->route_path, "/api/v1/widgets/{id}/tags");
    ASSERT_STR_EQ(tags->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* @Path("") is legal JAX-RS and means "the class path itself". Accepting
 * relative templates must not turn it into an empty route path: the method
 * has to behave exactly like one without @Path (fallback to "/", then
 * class-level composition). The class without a class-level @Path is the
 * binding case: an empty method path would otherwise drop the route. */
TEST(extract_java_jaxrs_empty_path_means_class_path) {
    CBMFileResult *r = extract("import jakarta.ws.rs.GET;\n"
                               "import jakarta.ws.rs.Path;\n"
                               "@Path(\"api/v1/widgets\")\n"
                               "class WidgetResource {\n"
                               "  @GET\n"
                               "  @Path(\"\")\n"
                               "  public String root() { return \"\"; }\n"
                               "}\n"
                               "class RootResource {\n"
                               "  @GET\n"
                               "  @Path(\"\")\n"
                               "  public String index() { return \"\"; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "Resources.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *root = find_def_by_name(r, "root");
    ASSERT_NOT_NULL(root);
    ASSERT_NOT_NULL(root->route_path);
    ASSERT_STR_EQ(root->route_path, "/api/v1/widgets");
    ASSERT_STR_EQ(root->route_method, "GET");
    const CBMDefinition *index = find_def_by_name(r, "index");
    ASSERT_NOT_NULL(index);
    ASSERT_NOT_NULL(index->route_path);
    ASSERT_STR_EQ(index->route_path, "/");
    ASSERT_STR_EQ(index->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* Negative control: relative templates are accepted for JAX-RS @Path only.
 * A slash-less string on a non-JAX-RS mapping annotation must keep the
 * previous behaviour (the literal is not read as a route path), so the
 * relaxation cannot broaden route extraction for other frameworks. */
TEST(extract_java_spring_relative_string_not_route_path) {
    CBMFileResult *r = extract("import org.springframework.web.bind.annotation.GetMapping;\n"
                               "import org.springframework.web.bind.annotation.RequestMapping;\n"
                               "@RequestMapping(\"api\")\n"
                               "public class OrderController {\n"
                               "  @GetMapping(\"orders\")\n"
                               "  public String listOrders() { return \"\"; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "OrderController.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *list = find_def_by_name(r, "listOrders");
    ASSERT_NOT_NULL(list);
    ASSERT_NOT_NULL(list->route_path);
    ASSERT_STR_EQ(list->route_path, "/");
    ASSERT_STR_EQ(list->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* Issue #1428: NestJS routes are TypeScript decorators — the class-level
 * @Controller('users') prefix composes with the method-level @Get(':id')
 * verb + path. Nest paths carry no leading slash, and the decorator's call is
 * a `call_expression` (not Python's `call`), so no Route was ever formed. */
TEST(extract_ts_nestjs_controller_routes_issue1428) {
    CBMFileResult *r =
        extract("import { Controller, Get, Post, Patch, Delete, Param } from '@nestjs/common';\n"
                "@Controller({ path: 'users', version: '1' })\n"
                "export class UsersController {\n"
                "  @Get() findAll() { return []; }\n"
                "  @Get(':id') findOne(@Param('id') id: string) { return id; }\n"
                "  @Post() create() { return 1; }\n"
                "  @Patch(':id') update(@Param('id') id: string) { return id; }\n"
                "  @Delete('/:id') remove(@Param('id') id: string) { return id; }\n"
                "  helper() { return 0; }\n"
                "}\n"
                "@Controller('health')\n"
                "export class HealthController {\n"
                "  @Get() check() { return { status: 'ok' }; }\n"
                "}\n"
                "@Controller()\n"
                "export class RootController {\n"
                "  @Get('ping') ping() { return 'pong'; }\n"
                "}\n",
                CBM_LANG_TYPESCRIPT, "t", "src/users/users.controller.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    static const struct {
        const char *name;
        const char *method;
        const char *path;
    } want[] = {
        {"findAll", "GET", "/users"},       {"findOne", "GET", "/users/:id"},
        {"create", "POST", "/users"},       {"update", "PATCH", "/users/:id"},
        {"remove", "DELETE", "/users/:id"}, {"check", "GET", "/health"},
        {"ping", "GET", "/ping"},
    };
    for (size_t i = 0; i < sizeof(want) / sizeof(want[0]); i++) {
        const CBMDefinition *d = find_def_by_name(r, want[i].name);
        ASSERT_NOT_NULL(d);
        ASSERT_NOT_NULL(d->route_path);
        ASSERT_STR_EQ(d->route_path, want[i].path);
        ASSERT_STR_EQ(d->route_method, want[i].method);
    }
    const CBMDefinition *helper = find_def_by_name(r, "helper");
    ASSERT_NOT_NULL(helper);
    ASSERT_NULL(helper->route_path);
    cbm_free_result(r);
    PASS();
}

/* #759: the one definition named `name`; NULL for none or more than one. */
static const CBMDefinition *nextjs_only_def(CBMFileResult *r, const char *name) {
    const CBMDefinition *found = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0) {
            if (found) {
                return NULL;
            }
            found = &r->defs.items[i];
        }
    }
    return found;
}

/* #759: a Next.js App Router route file's exported HTTP verb handlers are the
 * Functions extraction already makes for them, now carrying the route path of
 * the file's directories -- `[id]` as `:id`, `[...slug]` as `*slug`, a
 * `(group)` adding nothing -- and the verb as their method. A local
 * declaration exported by name (`export { GET }`) is that same Function; no
 * second definition appears. The 255-byte path is the longest that fits. */
TEST(extract_nextjs_route_metadata_contract_issue759) {
    char long_file[CBM_SZ_512];
    char long_path[CBM_SZ_256];
    char segment[CBM_SZ_256];
    memset(segment, 'x', CBM_SZ_256 - PAIR_LEN);
    segment[CBM_SZ_256 - PAIR_LEN] = '\0';
    snprintf(long_file, sizeof(long_file), "app/%s/route.ts", segment);
    snprintf(long_path, sizeof(long_path), "/%s", segment);
    static const char verbs_src[] = "export async function GET() {}\n"
                                    "export async function POST() {}\n"
                                    "export function PUT() {}\n"
                                    "export function PATCH() {}\n"
                                    "export function DELETE() {}\n"
                                    "export function HEAD() {}\n"
                                    "export function OPTIONS() {}\n";
    const struct {
        const char *file;
        const char *src;
        const char *path;
        const char *names[CBM_SZ_8];
    } cases[] = {
        {"src/app/api/users/[id]/route.ts",
         "export function GET() { return 1; }\nexport const POST = async () => 2;\n",
         "/api/users/:id",
         {"GET", "POST"}},
        {"app/api/verbs/route.ts",
         verbs_src,
         "/api/verbs",
         {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}},
        {"src/app/(public)/api/[org]/users/[id]/route.ts",
         "export async function GET() { return 1; }\n",
         "/api/:org/users/:id",
         {"GET"}},
        {"app/api/[...slug]/route.ts", "export function GET() {}\n", "/api/*slug", {"GET"}},
        {"app/api/typed/route.ts",
         "type Handler = () => Promise<number>;\nexport const GET: Handler = async () => 1;\n",
         "/api/typed",
         {"GET"}},
        {"app/route.js", "export function GET() { return 1; }\n", "/", {"GET"}},
        {"app/api/local/route.ts",
         "function GET() { return 1; }\nconst POST = async () => 2;\nexport { GET, POST };\n",
         "/api/local",
         {"GET", "POST"}},
        {long_file, "export function GET() {}\n", long_path, {"GET"}},
    };
    for (size_t c = 0; c < sizeof(cases) / sizeof(cases[0]); c++) {
        CBMLanguage lang = strstr(cases[c].file, ".js") ? CBM_LANG_JAVASCRIPT : CBM_LANG_TYPESCRIPT;
        CBMFileResult *r = extract(cases[c].src, lang, "t", cases[c].file);
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        int routed = 0;
        for (int i = 0; i < r->defs.count; i++) {
            routed += r->defs.items[i].route_path != NULL;
        }
        int want = 0;
        for (; want < CBM_SZ_8 && cases[c].names[want]; want++) {
            const CBMDefinition *d = nextjs_only_def(r, cases[c].names[want]);
            ASSERT_NOT_NULL(d);
            ASSERT_STR_EQ(d->label, "Function");
            ASSERT_STR_EQ(d->file_path, cases[c].file);
            ASSERT_NOT_NULL(d->route_path);
            ASSERT_STR_EQ(d->route_path, cases[c].path);
            ASSERT_STR_EQ(d->route_method, cases[c].names[want]);
        }
        ASSERT_EQ(routed, want);
        cbm_free_result(r);
    }
    PASS();
}

/* #759: nothing else routes. Not a route file, or a directory the route path
 * cannot spell -- an optional catch-all, a private folder, a parallel slot,
 * an intercepting route, a malformed bracket, a workspace package root, a path
 * past 255 bytes. Not a runtime export of an HTTP verb Function of this file:
 * an unexported, default, type-only or nested GET, a class method, a
 * constant, a lower-case verb; and no handler is made up for a renamed,
 * re-exported, wrapped or destructured export, or a `function` expression
 * bound to a const: none of them has a Function of its own here. */
TEST(extract_nextjs_rejects_nonroutes_issue759) {
    char long_file[CBM_SZ_512];
    char segment[CBM_SZ_256];
    memset(segment, 'x', CBM_SZ_256 - SKIP_ONE);
    segment[CBM_SZ_256 - SKIP_ONE] = '\0';
    snprintf(long_file, sizeof(long_file), "app/%s/route.ts", segment);
    const char *files[] = {
        "pages/api/route.ts",
        "app/api/page.ts",
        "app/api/route.test.ts",
        "app/api/view/route.tsx",
        "app/api/view/route.jsx",
        "app/api/module/route.mjs",
        "app/_private/route.ts",
        "src/app/api/_lib/route.ts",
        "app/@modal/route.ts",
        "app/(.)photo/route.ts",
        "app/(..)(..)photo/route.ts",
        "app/api/[[...opt]]/route.ts",
        "app/api/[broken/route.ts",
        "app/api/broken]/route.ts",
        "app/api/[]/route.ts",
        "app/api/[...]/route.ts",
        "app/api/a[id]/route.ts",
        "app/()/route.ts",
        "apps/web/app/api/route.ts",
        long_file,
    };
    const struct {
        const char *file;
        const char *src;
    } sources[] = {
        {"app/api/nonexports/route.ts", "function GET() {}\n"
                                        "export default function POST() {}\n"
                                        "function PUT() {}\n"
                                        "export type { PUT };\n"
                                        "function OPTIONS() {}\n"
                                        "export { type OPTIONS };\n"
                                        "export class Handlers { PATCH() {} }\n"
                                        "export const DELETE = 42;\n"
                                        "export function get() {}\n"
                                        "export function helper() { function HEAD() {} }\n"},
        {"app/api/bindings/route.ts", "const handler = async () => 1;\n"
                                      "export { handler as GET };\n"
                                      "export { POST } from './impl';\n"
                                      "export const PUT = wrap(handler);\n"
                                      "export const DELETE = function () {};\n"
                                      "export const { PATCH } = handlers;\n"
                                      "export const HEAD = handler as Handler;\n"
                                      "export const OPTIONS = (async () => 1) satisfies Handler;\n"
                                      "export * from './all';\n"},
    };
    const int file_count = (int)(sizeof(files) / sizeof(files[0]));
    const int source_count = (int)(sizeof(sources) / sizeof(sources[0]));
    for (int c = 0; c < file_count + source_count; c++) {
        bool by_file = c < file_count;
        const char *file = by_file ? files[c] : sources[c - file_count].file;
        CBMFileResult *r =
            extract(by_file ? "export function GET() {}\n" : sources[c - file_count].src,
                    CBM_LANG_TYPESCRIPT, "t", file);
        ASSERT_NOT_NULL(r);
        ASSERT_FALSE(r->has_error);
        if (by_file) {
            ASSERT_NOT_NULL(nextjs_only_def(r, "GET"));
        }
        for (int i = 0; i < r->defs.count; i++) {
            ASSERT_NULL(r->defs.items[i].route_path);
        }
        cbm_free_result(r);
    }
    PASS();
}

/* Return the file's Module definition (extraction pushes it first), or NULL. */
static const CBMDefinition *find_module_def(CBMFileResult *r) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].label && strcmp(r->defs.items[i].label, "Module") == 0) {
            return &r->defs.items[i];
        }
    }
    return NULL;
}

/* Blazor: a routable component declares its route with a `@page` directive in
 * MARKUP, above the `@code` block. The C# grammar recovers `@code` (that is why
 * .razor already yields methods via extra_extensions) but never sees the
 * directive, so a routable page contributes no Route node and
 * get_architecture(routes) is empty for a whole Blazor app.
 *
 * The route hangs off the file's Module definition, not off a class: a .razor
 * component's class is implicit — it is never written in the source — so there
 * is no class node to carry it. The Module's qualified name already IS the
 * component's identity (t.Pages.Counter), and insert_def_into_gbuf creates
 * Route+HANDLES for any definition carrying route_path, whatever its label. */
TEST(extract_blazor_page_directive_routes_component) {
    CBMFileResult *r = extract("@page \"/counter\"\n"
                               "@inject NavigationManager Nav\n"
                               "\n"
                               "<h1>Counter</h1>\n"
                               "<button @onclick=\"Increment\">Click</button>\n"
                               "\n"
                               "@code {\n"
                               "    private int count;\n"
                               "    private void Increment() { count++; }\n"
                               "}\n",
                               CBM_LANG_CSHARP, "t", "Pages/Counter.razor");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The markup must not cost us the @code block we already extract today. */
    ASSERT_NOT_NULL(find_def_by_name(r, "Increment"));
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->route_path);
    ASSERT_STR_EQ(mod->route_path, "/counter");
    /* A routable Blazor page is reached by navigation, i.e. GET. */
    ASSERT_NOT_NULL(mod->route_method);
    ASSERT_STR_EQ(mod->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* The directive scan must not fire on every .razor file. A non-routable
 * component (no @page) has to stay route-free, or every shared component in the
 * tree becomes a bogus Route node. */
TEST(extract_blazor_component_without_page_has_no_route) {
    CBMFileResult *r = extract("@inject IJSRuntime JS\n"
                               "\n"
                               "<div class=\"card\">@Title</div>\n"
                               "\n"
                               "@code {\n"
                               "    private void Refresh() { }\n"
                               "}\n",
                               CBM_LANG_CSHARP, "t", "Shared/Card.razor");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NULL(mod->route_path);
    cbm_free_result(r);
    PASS();
}

/* Razor Pages: `@page` is what turns a .cshtml view INTO a page — it is the
 * defining directive of the model, not an optional annotation as it is on a
 * Blazor component. So an ASP.NET Core app's routable surface lives entirely
 * in file types that were unmapped until now, and every one of those routes
 * was invisible.
 *
 * Same mechanism as the .razor case: the directive sits in markup above any
 * code block, where the C# grammar never reaches, so it is read from raw
 * source and hangs off the file's Module definition. */
TEST(extract_razor_page_directive_routes_cshtml_view) {
    CBMFileResult *r = extract("@page \"/orders\"\n"
                               "@model OrderIndexModel\n"
                               "\n"
                               "<h1>Orders</h1>\n"
                               "<table><tr><td>@Model.Count</td></tr></table>\n",
                               CBM_LANG_CSHARP, "t", "Pages/Orders/Index.cshtml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->route_path);
    ASSERT_STR_EQ(mod->route_path, "/orders");
    /* A Razor Page is reached by navigation, i.e. GET — same as a component. */
    ASSERT_NOT_NULL(mod->route_method);
    ASSERT_STR_EQ(mod->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* The overwhelming majority of .cshtml files are layouts, partials and views
 * with no `@page` at all. If the scan fired on those, an ASP.NET app would
 * gain a bogus Route node per view — worse than the missing routes it set out
 * to fix, because a wrong route looks authoritative. */
TEST(extract_razor_layout_without_page_has_no_route) {
    CBMFileResult *r = extract("@model LayoutModel\n"
                               "<!DOCTYPE html>\n"
                               "<html><body>@RenderBody()</body></html>\n",
                               CBM_LANG_CSHARP, "t", "Pages/Shared/_Layout.cshtml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NULL(mod->route_path);
    cbm_free_result(r);
    PASS();
}

/* A comment between decorators must not drop the decorators above it.
 * Comments are NAMED tree-sitter nodes, so the prev-sibling walk used to stop
 * at one — a documented route (@Post + @HttpCode above an explanatory comment)
 * silently lost those decorators and disappeared from route/authz queries. */
TEST(extract_ts_decorators_survive_interleaved_comment) {
    CBMFileResult *r = extract("class AuthController {\n"
                               "  @Post('login')\n"
                               "  @HttpCode(HttpStatus.OK)\n"
                               "  // throttled per IP and per account\n"
                               "  @Throttle({ default: { ttl: 900_000, limit: 5 } })\n"
                               "  async login(dto: LoginDto) { return 1; }\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "auth.controller.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *m = find_def_by_name(r, "login");
    ASSERT_NOT_NULL(m);
    ASSERT(decorators_contain(m, "Throttle")); /* below the comment — always worked */
    ASSERT(decorators_contain(m, "HttpCode")); /* above the comment — was dropped */
    ASSERT(decorators_contain(m, "Post"));     /* above the comment — was dropped */
    cbm_free_result(r);
    PASS();
}

/* #1892: the Swift grammar declares no "arguments" field, so the generic field
 * lookup read nothing and every Swift call lost its arguments. Without the URL
 * the service-pattern table cannot raise an HTTP_CALLS edge or a Route node,
 * even though Alamofire/Moya/URLSession are already listed in it. */
TEST(swift_call_string_arg_issue1892) {
    CBMFileResult *r =
        extract("func listWidgets() { AF.request(\"https://example.com/api/v1/widgets\") }\n",
                CBM_LANG_SWIFT, "t", "Client.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "AF.request");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "https://example.com/api/v1/widgets");
    cbm_free_result(r);
    PASS();
}

/* Swift labels its arguments, and each one sits in a value_argument node that
 * leads with the label. Reading the first child alone would return `with`
 * rather than the path. */
TEST(swift_labeled_call_string_arg_issue1892) {
    CBMFileResult *r =
        extract("func fetch() { URLSession.shared.dataTask(with: \"/api/v1/widgets/1\") }\n",
                CBM_LANG_SWIFT, "t", "Fetch.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "URLSession.shared.dataTask");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/v1/widgets/1");
    cbm_free_result(r);
    PASS();
}

/* Swift has no URL literal, so real code builds one and force-unwraps it. The
 * string then sits two levels below the argument list. */
TEST(swift_nested_url_constructor_issue1892) {
    CBMFileResult *r = extract("func fetch() { URLSession.shared.dataTask(with: URL(string: "
                               "\"https://example.com/api/v1/widgets\")!) }\n",
                               CBM_LANG_SWIFT, "t", "Fetch.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "URLSession.shared.dataTask");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "https://example.com/api/v1/widgets");
    cbm_free_result(r);
    PASS();
}

/* Without the trailing "!" the constructor is not wrapped in a
 * postfix_expression, so this covers the other shape. */
TEST(swift_nested_url_no_bang_issue1892) {
    CBMFileResult *r =
        extract("func fetch() { client.send(to: URLRequest(url: \"/api/v1/widgets/1\")) }\n",
                CBM_LANG_SWIFT, "t", "Send.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "client.send");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/v1/widgets/1");
    cbm_free_result(r);
    PASS();
}

/* A constructor that is not one of the three URL types keeps its own meaning:
 * the outer call must not borrow the inner call's string. */
TEST(swift_non_url_constructor_untouched_issue1892) {
    CBMFileResult *r = extract("func f() { log.write(to: Formatter(pattern: \"%s-%d\")) }\n",
                               CBM_LANG_SWIFT, "t", "Log.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "log.write");
    ASSERT_NOT_NULL(c);
    ASSERT_NULL(c->first_string_arg);
    cbm_free_result(r);
    PASS();
}

/* Issue #1009: URL-builder helper pattern — a function returning a URL-shaped
 * literal, consumed as client(buildPath(id)). The builder's URL is recorded in
 * the per-file constant map and resolved at the call site, for both return
 * statements and arrow expression bodies. */
TEST(extract_ts_await_generic_call_issue2210) {
    CBMFileResult *r =
        extract("function parseJsonBody<T>() { return {} as T; }\n"
                "async function plain() { return await parseJsonBody(); }\n"
                "async function generic() { return await parseJsonBody<string>(); }\n",
                CBM_LANG_TYPESCRIPT, "t", "await.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_calls_named(r, "parseJsonBody"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(extract_ts_url_builder_issue1009) {
    CBMFileResult *r = extract("function thingDetail(id: string): string {\n"
                               "  return `/api/v1/things/${id}/detail`;\n"
                               "}\n"
                               "const arrowPath = (id: string) => `/api/v1/arrows/${id}`;\n"
                               "export function useThing(id: string) {\n"
                               "  return apiGet(thingDetail(id));\n"
                               "}\n"
                               "export function useArrow(id: string) {\n"
                               "  return apiFetch(arrowPath(id));\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "builders.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c1 = find_call_by_callee(r, "apiGet");
    ASSERT_NOT_NULL(c1);
    ASSERT_NOT_NULL(c1->first_string_arg);
    ASSERT_STR_EQ(c1->first_string_arg, "/api/v1/things/{}/detail");
    const CBMCall *c2 = find_call_by_callee(r, "apiFetch");
    ASSERT_NOT_NULL(c2);
    ASSERT_NOT_NULL(c2->first_string_arg);
    ASSERT_STR_EQ(c2->first_string_arg, "/api/v1/arrows/{}");
    cbm_free_result(r);
    PASS();
}

/* A route registration names its middleware before its handler, and every
 * framework here puts the handler last. The handler scan took the FIRST
 * argument that looked like a function reference, so a named middleware won
 * and the HANDLES edge pointed at the middleware instead of the handler. */
TEST(extract_ts_route_handler_after_named_middleware) {
    CBMFileResult *r = extract("function requireAuth(req: any, res: any, next: any) { next(); }\n"
                               "function rateLimit(req: any, res: any, next: any) { next(); }\n"
                               "function listUsers(req: any, res: any) { res.json([]); }\n"
                               "routerGet(\"/users\", requireAuth, rateLimit, listUsers);\n",
                               CBM_LANG_TYPESCRIPT, "t", "routes.ts");
    ASSERT_NOT_NULL(r);
    const CBMCall *c = find_call_by_callee(r, "routerGet");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/users");
    ASSERT_NOT_NULL(c->second_arg_name);
    ASSERT_STR_EQ(c->second_arg_name, "listUsers");
    cbm_free_result(r);
    PASS();
}

/* The same route with its middleware written inline. An arrow function is not
 * one of the kinds the handler scan accepts, so three of them pushed the real
 * handler past the scan bound and no handler came back at all. */
TEST(extract_ts_route_handler_after_inline_middleware) {
    CBMFileResult *r = extract("function listOrders(req: any, res: any) { res.json([]); }\n"
                               "routerGet(\"/orders\",\n"
                               "  (req: any, res: any, next: any) => { next(); },\n"
                               "  (req: any, res: any, next: any) => { next(); },\n"
                               "  (req: any, res: any, next: any) => { next(); },\n"
                               "  listOrders);\n",
                               CBM_LANG_TYPESCRIPT, "t", "orders.ts");
    ASSERT_NOT_NULL(r);
    const CBMCall *c = find_call_by_callee(r, "routerGet");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/orders");
    ASSERT_NOT_NULL(c->second_arg_name);
    ASSERT_STR_EQ(c->second_arg_name, "listOrders");
    cbm_free_result(r);
    PASS();
}

/* Issue #1009 (composed builders): a builder whose template inlines an earlier
 * builder's call plus a query string: `return \`${basePath(id)}?${params}\``.
 * The known-substitution is inlined and the query string is truncated, so the
 * resolved URL joins the server route exactly. */
TEST(extract_ts_url_builder_composed_issue1009) {
    CBMFileResult *r = extract("function activityPath(id: string): string {\n"
                               "  return `/api/v1/team-members/${id}/activity`;\n"
                               "}\n"
                               "function buildPath(id: string, cursor: string): string {\n"
                               "  const params = new URLSearchParams();\n"
                               "  params.set('cursor', cursor);\n"
                               "  return `${activityPath(id)}?${params.toString()}`;\n"
                               "}\n"
                               "export function useActivity(id: string, cursor: string) {\n"
                               "  return apiGet(buildPath(id, cursor));\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "composed.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "apiGet");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/v1/team-members/{}/activity");
    cbm_free_result(r);
    PASS();
}

static bool any_call_arg_resolves_to(CBMFileResult *r, const char *url) {
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->first_string_arg && strcmp(c->first_string_arg, url) == 0) {
            return true;
        }
        for (int a = 0; a < c->arg_count; a++) {
            if (c->args[a].value && strcmp(c->args[a].value, url) == 0) {
                return true;
            }
        }
    }
    return false;
}

TEST(extract_c_url_builder_gated_issue1009) {
    CBMFileResult *r = extract("static const char *cfg_path(void) {\n"
                               "  return \"/srv/myapp/conf.d\";\n"
                               "}\n"
                               "void init(void) {\n"
                               "  parse_config(cfg_path());\n"
                               "}\n",
                               CBM_LANG_C, "t", "conf.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_FALSE(any_call_arg_resolves_to(r, "/srv/myapp/conf.d"));
    cbm_free_result(r);
    PASS();
}

/* One literal return next to a computed one would attribute the literal to every
 * call site, including those taking the computed branch. A builder whose returns
 * are not all URL literals is declined. */
TEST(extract_ts_url_builder_mixed_returns_issue1009) {
    CBMFileResult *r = extract("function pathFor(kind: string): string {\n"
                               "  if (kind === 'user') return '/api/users';\n"
                               "  return computePath(kind);\n"
                               "}\n"
                               "export function load(kind: string) {\n"
                               "  return apiGet(pathFor(kind));\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "mixed.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_FALSE(any_call_arg_resolves_to(r, "/api/users"));
    cbm_free_result(r);
    PASS();
}

/* Two different literal URLs make the call site's route unknowable, so the
 * builder is tombstoned and lookups miss. */
TEST(extract_ts_url_builder_ambiguous_issue1009) {
    CBMFileResult *r = extract("function pathFor(kind: string): string {\n"
                               "  if (kind === 'user') return '/api/users';\n"
                               "  return '/api/teams';\n"
                               "}\n"
                               "export function load(kind: string) {\n"
                               "  return apiGet(pathFor(kind));\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "ambiguous.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_FALSE(any_call_arg_resolves_to(r, "/api/users"));
    ASSERT_FALSE(any_call_arg_resolves_to(r, "/api/teams"));
    cbm_free_result(r);
    PASS();
}

/* Handing a builder to a callback position builds no URL. Only a call to it
 * resolves, so the mapping function does not inherit an HTTP_CALLS edge to the
 * route. */
TEST(extract_ts_url_builder_reference_issue1009) {
    CBMFileResult *r = extract("function thingPath(id: string): string {\n"
                               "  return `/api/v1/things/${id}`;\n"
                               "}\n"
                               "export function loadAll(ids: string[]) {\n"
                               "  return ids.map(thingPath);\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "reference.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_FALSE(any_call_arg_resolves_to(r, "/api/v1/things/{}"));
    cbm_free_result(r);
    PASS();
}

/* A helper returning an ordinary string is not a URL builder, so its call site
 * gets no resolved string argument. */
TEST(extract_ts_url_builder_non_url_issue1009) {
    CBMFileResult *r = extract("function label(): string {\n"
                               "  return 'plain text';\n"
                               "}\n"
                               "export function render() {\n"
                               "  return send(label());\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "label.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "send");
    ASSERT_NOT_NULL(c);
    ASSERT_NULL(c->first_string_arg);
    ASSERT_FALSE(any_call_arg_resolves_to(r, "plain text"));
    cbm_free_result(r);
    PASS();
}

/* Issue #1006: JS/TS template-literal URLs must flatten ${...} substitutions
 * to the canonical "{}" placeholder, both as call arguments (HTTP_CALLS) and
 * as URL-shaped string_refs collected from const/return positions. */
TEST(extract_ts_template_string_url_issue1006) {
    CBMFileResult *r = extract("export function detailPath(id: string): string {\n"
                               "  return `/api/v1/things/${id}/detail`;\n"
                               "}\n"
                               "export function load(id: string) {\n"
                               "  return fetch(`/api/v1/things/${id}`);\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "paths.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "fetch");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/v1/things/{}");
    int found = 0;
    for (int i = 0; i < r->string_refs.count; i++) {
        if (r->string_refs.items[i].value &&
            strcmp(r->string_refs.items[i].value, "/api/v1/things/{}/detail") == 0) {
            found = 1;
            break;
        }
    }
    ASSERT(found);
    cbm_free_result(r);
    PASS();
}

/* Issue #2235: a request-config object argument carries the URL in its `url`
 * property (Orval/axios style: `http({url: `/x/${id}`, method: 'GET'})`).
 * The property's template literal flattens to the canonical "{}" form both on
 * the argument (read by the arg-url heuristic for local helpers) and as the
 * call's URL (read by HTTP-client classification, e.g. `axios({url})`). Other
 * keys never stand in for the URL, and a route registration keeps its own
 * (object-free) handling. */
TEST(extract_ts_config_object_url_issue2235) {
    CBMFileResult *r =
        extract("export const get1 = (id: string) => {\n"
                "  return http<Customer>({url: `/api/customers/${id}`, method: 'GET'});\n"
                "};\n"
                "export const load = () => axios({method: 'POST', 'url': '/api/orders'});\n"
                "export const other = () => http({path: '/api/ignored/x'});\n"
                "export const reg = () => fastify.route({url: '/srv/x', handler: h});\n"
                "export const u = () => axiosInstance.getUri({url: `/pets`});\n",
                CBM_LANG_TYPESCRIPT, "t", "client.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = NULL;
    const CBMCall *o = NULL;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *k = &r->calls.items[i];
        if (k->callee_name && strcmp(k->callee_name, "http") == 0 && k->arg_count > 0) {
            if (k->args[0].expr && strstr(k->args[0].expr, "customers")) {
                c = k;
            } else {
                o = k;
            }
        }
    }
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->args[0].value);
    ASSERT_STR_EQ(c->args[0].value, "/api/customers/{}");
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/customers/{}");
    const CBMCall *a = find_call_by_callee(r, "axios");
    ASSERT_NOT_NULL(a);
    ASSERT_NOT_NULL(a->first_string_arg);
    ASSERT_STR_EQ(a->first_string_arg, "/api/orders");
    ASSERT_NOT_NULL(o);
    ASSERT_NULL(o->args[0].value);
    ASSERT_NULL(o->first_string_arg);
    const CBMCall *g = find_call_by_callee(r, "fastify.route");
    ASSERT_NOT_NULL(g);
    ASSERT_NULL(g->first_string_arg);
    ASSERT(g->arg_count == 0 || g->args[0].value == NULL);
    /* getUri only formats the URL; it sends no request. */
    const CBMCall *gu = find_call_by_callee(r, "axiosInstance.getUri");
    ASSERT_NOT_NULL(gu);
    ASSERT_NULL(gu->first_string_arg);
    ASSERT(gu->arg_count == 0 || gu->args[0].value == NULL);
    cbm_free_result(r);
    PASS();
}

/* Issue #1249: a mux route built as `configVar + "/literal"` (Go's idiomatic
 * configurable-base-path pattern) must index the literal suffix, both for a
 * route registration and for an outbound URL built the same way. A real BFF
 * with 47 such registrations produced only 9 Route nodes before this fix. */
TEST(extract_go_binary_concat_url_issue1249) {
    CBMFileResult *r = extract("package main\n"
                               "import \"net/http\"\n"
                               "func setup(mux *http.ServeMux, base string) {\n"
                               "    mux.HandleFunc(base+\"/login\", loginHandler)\n"
                               "}\n"
                               "func report(host string, port string) {\n"
                               "    http.Get(\"http://\" + host + \":\" + port + \"/log\")\n"
                               "}\n",
                               CBM_LANG_GO, "t", "routes.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *reg = find_call_by_callee(r, "mux.HandleFunc");
    ASSERT_NOT_NULL(reg);
    ASSERT_NOT_NULL(reg->first_string_arg);
    ASSERT_STR_EQ(reg->first_string_arg, "/login");

    const CBMCall *out = find_call_by_callee(r, "http.Get");
    ASSERT_NOT_NULL(out);
    ASSERT_NOT_NULL(out->first_string_arg);
    ASSERT_STR_EQ(out->first_string_arg, "/log");

    cbm_free_result(r);
    PASS();
}

/* Same issue: when the right side of the concatenation is not itself a
 * literal (`base + suffixVar`), there is no literal route to recover. The
 * fix must leave this unresolved rather than fabricate a path. */
TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249) {
    CBMFileResult *r = extract("package main\n"
                               "func setup(mux *http.ServeMux, base string, suffix string) {\n"
                               "    mux.HandleFunc(base+suffix, dynHandler)\n"
                               "}\n",
                               CBM_LANG_GO, "t", "routes.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *reg = find_call_by_callee(r, "mux.HandleFunc");
    ASSERT_NOT_NULL(reg);
    ASSERT_NULL(reg->first_string_arg);

    cbm_free_result(r);
    PASS();
}

/* Issue #2537: a Go 1.22 ServeMux pattern may open with a method and/or a host
 * ("POST /v1/payments", "GET api.example.com/v1/x"). The written pattern stays
 * the first string argument, and its handler is captured exactly as for a
 * plain "/v1/payments"; it was dropped because the pattern does not open with
 * a slash. */
TEST(extract_go_servemux_method_pattern_handler_issue2537) {
    CBMFileResult *r = extract("package main\n"
                               "import \"net/http\"\n"
                               "func setup(mux *http.ServeMux) {\n"
                               "    mux.HandleFunc(\"POST /v1/payments\", createPayment)\n"
                               "    mux.Handle(\"GET api.example.com/v1/x\", hostHandler)\n"
                               "}\n",
                               CBM_LANG_GO, "t", "routes.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *method = find_call_by_callee(r, "mux.HandleFunc");
    ASSERT_NOT_NULL(method);
    ASSERT_NOT_NULL(method->first_string_arg);
    ASSERT_STR_EQ(method->first_string_arg, "POST /v1/payments");
    ASSERT_NOT_NULL(method->second_arg_name);
    ASSERT_STR_EQ(method->second_arg_name, "createPayment");

    const CBMCall *host = find_call_by_callee(r, "mux.Handle");
    ASSERT_NOT_NULL(host);
    ASSERT_NOT_NULL(host->first_string_arg);
    ASSERT_STR_EQ(host->first_string_arg, "GET api.example.com/v1/x");
    ASSERT_NOT_NULL(host->second_arg_name);
    ASSERT_STR_EQ(host->second_arg_name, "hostHandler");

    cbm_free_result(r);
    PASS();
}

/* Issue #2291: the JS/TS twin of #1249. A BFF that builds its backend URL as
 * `${process.env.BACKEND_URL}/wallet/topup` from a configurable base must
 * index the literal path after the base, exactly as `BACKEND_URL + "/x"`
 * already does. The flattened "{}/wallet/topup" was dropped because it
 * neither starts with '/' nor carries a scheme, so no HTTP_CALLS edge formed
 * and the call could never be matched to the backend's route. */
TEST(extract_ts_template_base_url_issue2291) {
    CBMFileResult *r = extract("const BACKEND_URL = process.env.BACKEND_URL;\n"
                               "export async function topup(body: string) {\n"
                               "  return fetch(`${process.env.BACKEND_URL}/wallet/topup/zibal`, {\n"
                               "    method: 'POST', body });\n"
                               "}\n"
                               "export async function tickets() {\n"
                               "  return axios.get(`${BACKEND_URL}/tickets/mine`);\n"
                               "}\n"
                               "export async function items(id: string) {\n"
                               "  return got(`${BACKEND_URL}/orders/${id}/items`);\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "route.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *f = find_call_by_callee(r, "fetch");
    ASSERT_NOT_NULL(f);
    ASSERT_NOT_NULL(f->first_string_arg);
    ASSERT_STR_EQ(f->first_string_arg, "/wallet/topup/zibal");

    const CBMCall *g = find_call_by_callee(r, "axios.get");
    ASSERT_NOT_NULL(g);
    ASSERT_NOT_NULL(g->first_string_arg);
    ASSERT_STR_EQ(g->first_string_arg, "/tickets/mine");

    const CBMCall *h = find_call_by_callee(r, "got");
    ASSERT_NOT_NULL(h);
    ASSERT_NOT_NULL(h->first_string_arg);
    /* `got` has no service-table entry: preserve the raw first argument and
     * carry the recovered path as an explicit candidate for HTTP detection. */
    ASSERT_STR_EQ(h->first_string_arg, "{}/orders/{}/items");
    ASSERT_GTE(h->arg_count, 1);
    ASSERT_NOT_NULL(h->args[0].url_value);
    ASSERT_STR_EQ(h->args[0].url_value, "/orders/{}/items");

    cbm_free_result(r);
    PASS();
}

/* Same issue: with no literal path after the base (`${BASE}${path}`,
 * `${BASE}/`) there is no route to recover, so none may be fabricated. */
TEST(extract_ts_template_base_url_no_literal_path_issue2291) {
    CBMFileResult *r = extract("export async function proxy(path: string) {\n"
                               "  return fetch(`${process.env.BACKEND_URL}${path}`);\n"
                               "}\n"
                               "export async function root() {\n"
                               "  return axios.get(`${process.env.BACKEND_URL}/`);\n"
                               "}\n"
                               "export function tail(tail: string) {\n"
                               "  return axios.post(`${BASE}/${tail}`);\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "proxy.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *f = find_call_by_callee(r, "fetch");
    ASSERT_NOT_NULL(f);
    ASSERT(f->first_string_arg == NULL || f->first_string_arg[0] != '/');

    const CBMCall *g = find_call_by_callee(r, "axios.get");
    ASSERT_NOT_NULL(g);
    ASSERT(g->first_string_arg == NULL || g->first_string_arg[0] != '/');

    const CBMCall *h = find_call_by_callee(r, "axios.post");
    ASSERT_NOT_NULL(h);
    ASSERT(h->first_string_arg == NULL || h->first_string_arg[0] != '/');
    ASSERT_GTE(h->arg_count, 1);
    ASSERT_NULL(h->args[0].url_value);

    cbm_free_result(r);
    PASS();
}

/* The call `callee` made inside function `func` (its enclosing QN ends in
 * ".func"), so one file can hold several calls to the same client. */
static const CBMCall *find_call_in_func(CBMFileResult *r, const char *callee, const char *func) {
    size_t fl = strlen(func);
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        const char *q = c->enclosing_func_qn;
        if (!c->callee_name || strcmp(c->callee_name, callee) != 0 || !q) {
            continue;
        }
        size_t ql = strlen(q);
        if (ql > fl && q[ql - fl - 1] == '.' && strcmp(q + ql - fl, func) == 0) {
            return c;
        }
    }
    return NULL;
}

/* The URL a call hands to its client: first_string_arg, or "" when none. */
static const char *url_in(CBMFileResult *r, const char *callee, const char *func) {
    const CBMCall *c = find_call_in_func(r, callee, func);
    return (c && c->first_string_arg) ? c->first_string_arg : "";
}

/* True when the URL is not presented as a path or an absolute URL. */
static bool url_not_claimed(CBMFileResult *r, const char *callee, const char *func) {
    const CBMCall *call = find_call_in_func(r, callee, func);
    if (!call) {
        return false;
    }
    const char *u = call->first_string_arg;
    return !u || (u[0] != '/' && strstr(u, "://") == NULL);
}

/* Issue #706: a Python caller that centralises its endpoint URLs in module
 * constants -- `API_URL = API_BASE_URL + "some/path"` -- lost the URL, so no
 * HTTP_CALLS edge formed and cross-repo-intelligence reported 0 links. The
 * concatenation must be folded: resolved parts inline, and an unresolvable
 * base (an env var) leaves the literal path after it. */
TEST(extract_py_concat_const_url_issue706) {
    CBMFileResult *r = extract("import os\n"
                               "import requests\n"
                               "API_BASE_URL = os.environ[\"API_BASE_URL\"]\n"
                               "HOST = \"http://provider:8000\"\n"
                               "PREFIX = \"/v2\"\n"
                               "API_URL = API_BASE_URL + \"some/path\"\n"
                               "URL = API_BASE_URL + \"/foo\"\n"
                               "ORDERS_URL = HOST + \"/orders\"\n"
                               "REPORTS_URL = PREFIX + \"/reports\"\n"
                               "ITEMS_URL = f\"{API_BASE_URL}/items\"\n"
                               "DAILY_URL = REPORTS_URL + \"/daily\"\n"
                               "def send(p):\n"
                               "    requests.post(API_URL, json=p)\n"
                               "def send_foo(p):\n"
                               "    requests.post(URL, json=p)\n"
                               "def orders():\n"
                               "    return requests.get(ORDERS_URL)\n"
                               "def reports():\n"
                               "    return requests.get(REPORTS_URL)\n"
                               "def items():\n"
                               "    return requests.get(ITEMS_URL)\n"
                               "def daily():\n"
                               "    return requests.get(DAILY_URL)\n"
                               "def direct(p):\n"
                               "    return requests.post(API_BASE_URL + \"/direct\", json=p)\n"
                               "def inline():\n"
                               "    return requests.get(PREFIX + \"/inline\")\n"
                               "def kw(p):\n"
                               "    return requests.post(url=API_URL, json=p)\n",
                               CBM_LANG_PYTHON, "t", "client.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_STR_EQ(url_in(r, "requests.post", "send"), "/some/path");
    ASSERT_STR_EQ(url_in(r, "requests.post", "send_foo"), "/foo");
    ASSERT_STR_EQ(url_in(r, "requests.get", "orders"), "http://provider:8000/orders");
    ASSERT_STR_EQ(url_in(r, "requests.get", "reports"), "/v2/reports");
    ASSERT_STR_EQ(url_in(r, "requests.get", "items"), "/items");
    ASSERT_STR_EQ(url_in(r, "requests.get", "daily"), "/v2/reports/daily");
    ASSERT_STR_EQ(url_in(r, "requests.post", "direct"), "/direct");
    ASSERT_STR_EQ(url_in(r, "requests.get", "inline"), "/v2/inline");
    ASSERT_STR_EQ(url_in(r, "requests.post", "kw"), "/some/path");

    /* A fully resolved fold is an exact argument value; a path left behind by
     * an unresolvable base is not, so it never reaches the exact-URL slot. */
    const CBMCall *rep = find_call_in_func(r, "requests.get", "reports");
    ASSERT_NOT_NULL(rep);
    ASSERT_GTE(rep->arg_count, 1);
    ASSERT_NOT_NULL(rep->args[0].value);
    ASSERT_STR_EQ(rep->args[0].value, "/v2/reports");
    const CBMCall *snd = find_call_in_func(r, "requests.post", "send");
    ASSERT_NOT_NULL(snd);
    ASSERT_GTE(snd->arg_count, 1);
    ASSERT(snd->args[0].value == NULL || snd->args[0].value[0] != '/');

    cbm_free_result(r);
    PASS();
}

/* Same issue, the controls: a URL with nothing literal to recover -- a local
 * computed value, a bare env-derived base, a base plus "/" or plus another
 * variable -- must not be turned into a path or an exact URL. */
TEST(extract_py_url_fold_no_fabrication_issue706) {
    CBMFileResult *r = extract("import os\n"
                               "import requests\n"
                               "API_BASE_URL = os.environ[\"API_BASE_URL\"]\n"
                               "EMPTY = API_BASE_URL + \"/\"\n"
                               "def compute():\n"
                               "    return os.environ.get(\"X\")\n"
                               "def dyn():\n"
                               "    u = compute()\n"
                               "    return requests.get(u)\n"
                               "def bare():\n"
                               "    return requests.get(API_BASE_URL)\n"
                               "def slash():\n"
                               "    return requests.get(API_BASE_URL + \"/\")\n"
                               "def empty():\n"
                               "    return requests.get(EMPTY)\n"
                               "def two(p):\n"
                               "    return requests.get(API_BASE_URL + p)\n",
                               CBM_LANG_PYTHON, "t", "ctl.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_TRUE(url_not_claimed(r, "requests.get", "dyn"));
    ASSERT_TRUE(url_not_claimed(r, "requests.get", "bare"));
    ASSERT_TRUE(url_not_claimed(r, "requests.get", "slash"));
    ASSERT_TRUE(url_not_claimed(r, "requests.get", "empty"));
    ASSERT_TRUE(url_not_claimed(r, "requests.get", "two"));

    cbm_free_result(r);
    PASS();
}

/* Issue #523 follow-up: a Python string whose opening token is more than one
 * quote -- a prefix (r"", u"", b"", Rb"", an f"" with no field) or a triple
 * quote -- kept the prefix and the extra quotes in the URL (`f"http://..."`,
 * `""http://...""`), so the HTTP_CALLS edge never matched a route. Each must
 * yield the bare URL, positional or as `url=`. */
TEST(extract_py_prefixed_string_url_issue523) {
    CBMFileResult *r = extract("import requests\n"
                               "def f_plain():\n"
                               "    return requests.get(f\"http://svc/v2/health\")\n"
                               "def raw():\n"
                               "    return requests.get(r\"http://svc/v2/health\")\n"
                               "def uni():\n"
                               "    return requests.get(u\"http://svc/v2/health\")\n"
                               "def byt():\n"
                               "    return requests.get(b\"http://svc/v2/health\")\n"
                               "def raw_bytes():\n"
                               "    return requests.get(Rb\"http://svc/v2/health\")\n"
                               "def triple():\n"
                               "    return requests.get(\"\"\"http://svc/v2/health\"\"\")\n"
                               "def triple_single():\n"
                               "    return requests.get('''http://svc/v2/health''')\n"
                               "def f_triple():\n"
                               "    return requests.get(f\"\"\"http://svc/v2/health\"\"\")\n"
                               "def kw():\n"
                               "    return requests.get(url=r\"http://svc/v2/health\")\n",
                               CBM_LANG_PYTHON, "t", "client.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_STR_EQ(url_in(r, "requests.get", "f_plain"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "raw"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "uni"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "byt"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "raw_bytes"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "triple"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "triple_single"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "f_triple"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "kw"), "http://svc/v2/health");

    /* A wrapped literal is still a fully known value, so it is exact. */
    const CBMCall *raw = find_call_in_func(r, "requests.get", "raw");
    ASSERT_NOT_NULL(raw);
    ASSERT_GTE(raw->arg_count, 1);
    ASSERT_NOT_NULL(raw->args[0].value);
    ASSERT_STR_EQ(raw->args[0].value, "http://svc/v2/health");

    cbm_free_result(r);
    PASS();
}

/* Same issue, the controls: a plain one-quote literal keeps the literal path
 * unchanged, and an interpolating f-string still folds its field to "{}". */
TEST(extract_py_prefixed_string_url_controls_issue523) {
    CBMFileResult *r = extract("import requests\n"
                               "def plain():\n"
                               "    return requests.get(\"http://svc/v2/health\")\n"
                               "def plain_single():\n"
                               "    return requests.get('http://svc/v2/health')\n"
                               "def field(order_id):\n"
                               "    return requests.get(f\"http://svc/v2/orders/{order_id}\")\n"
                               "def raw_field(order_id):\n"
                               "    return requests.get(rf\"http://svc/v2/orders/{order_id}\")\n",
                               CBM_LANG_PYTHON, "t", "ctl.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_STR_EQ(url_in(r, "requests.get", "plain"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "plain_single"), "http://svc/v2/health");
    ASSERT_STR_EQ(url_in(r, "requests.get", "field"), "http://svc/v2/orders/{}");
    ASSERT_STR_EQ(url_in(r, "requests.get", "raw_field"), "http://svc/v2/orders/{}");

    cbm_free_result(r);
    PASS();
}

/* Issue #1147: a frontend that composes every endpoint from module constants
 * -- a base constant, template literals over it, and an object-literal map of
 * endpoints -- extracted none of its API calls. Each template / concatenation
 * over a resolvable constant must fold to the full path, `OBJ.KEY` of an
 * object-literal const must resolve, and a base that stays unresolvable
 * (`${getApiBaseUrl()}`) leaves the path after it. A relative base ('api')
 * joined to a path is a path under the client's base URL. */
TEST(extract_ts_const_template_url_issue1147) {
    CBMFileResult *r = extract(
        "const BASE = '/api'\n"
        "const REL = 'api'\n"
        "const GAMES = '/games'\n"
        "export const API_ENDPOINTS = {\n"
        "  LOGIN: `${BASE}/users/login`,\n"
        "  USER: `${REL}/users/me`,\n"
        "  GAME_LAUNCH_URL: `${REL}/games/launch`,\n"
        "  NESTED: { DEEP: BASE + '/deep' },\n"
        "} as const\n"
        "export const getApiBaseUrl = () => `${API_PROTOCOL}://${process.env.API_DOMAIN}/`\n"
        "export async function launch() { return fetch(`${BASE}/games/launch`) }\n"
        "export async function list() { return fetch(`${GAMES}/list`) }\n"
        "export async function login() { return fetch(API_ENDPOINTS.LOGIN) }\n"
        "export async function user() {\n"
        "  return fetch(`${getApiBaseUrl()}/${API_ENDPOINTS.USER}`, { method: 'GET' })\n"
        "}\n"
        "export async function game(p: unknown) {\n"
        "  return apiClient.post(API_ENDPOINTS.GAME_LAUNCH_URL, p)\n"
        "}\n"
        "export async function deep() { return fetch(API_ENDPOINTS.NESTED.DEEP) }\n"
        "export async function me() { return axios.get(BASE + '/users/me') }\n",
        CBM_LANG_TYPESCRIPT, "t", "client.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_STR_EQ(url_in(r, "fetch", "launch"), "/api/games/launch");
    ASSERT_STR_EQ(url_in(r, "fetch", "list"), "/games/list");
    ASSERT_STR_EQ(url_in(r, "fetch", "login"), "/api/users/login");
    ASSERT_STR_EQ(url_in(r, "fetch", "user"), "/api/users/me");
    ASSERT_STR_EQ(url_in(r, "apiClient.post", "game"), "api/games/launch");
    ASSERT_STR_EQ(url_in(r, "fetch", "deep"), "/api/deep");
    ASSERT_STR_EQ(url_in(r, "axios.get", "me"), "/api/users/me");

    /* A wrapper client has raw string identity plus an explicit URL candidate.
     * Only HTTP detection may select the normalized relative path. */
    const CBMCall *g = find_call_in_func(r, "apiClient.post", "game");
    ASSERT_NOT_NULL(g);
    ASSERT_GTE(g->arg_count, 1);
    ASSERT_NOT_NULL(g->args[0].value);
    ASSERT_STR_EQ(g->args[0].value, "api/games/launch");
    ASSERT_NOT_NULL(g->args[0].url_value);
    ASSERT_STR_EQ(g->args[0].url_value, "/api/games/launch");

    cbm_free_result(r);
    PASS();
}

/* Same issue, the controls: a parameter, a bare substitution, a member of an
 * unknown object, an env-only base, and an unresolvable base followed only by
 * an unresolvable tail carry no literal path, so none may be fabricated (the
 * last one used to come out as "/{}"). */
TEST(extract_ts_url_fold_no_fabrication_issue1147) {
    CBMFileResult *r =
        extract("const HEALTH_BASE = process.env.HEALTH_BASE\n"
                "export async function dynamic(path: string) { return fetch(path) }\n"
                "export async function dynTpl(x: string) { return fetch(`${x}`) }\n"
                "export async function missing() { return fetch(API_ENDPOINTS.MISSING) }\n"
                "export async function tail(t: string) { return fetch(`${getBase()}/${t}`) }\n"
                "export async function envOnly() { return fetch(HEALTH_BASE) }\n",
                CBM_LANG_TYPESCRIPT, "t", "ctl.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT_TRUE(url_not_claimed(r, "fetch", "dynamic"));
    ASSERT_TRUE(url_not_claimed(r, "fetch", "dynTpl"));
    ASSERT_TRUE(url_not_claimed(r, "fetch", "missing"));
    ASSERT_TRUE(url_not_claimed(r, "fetch", "tail"));
    ASSERT_TRUE(url_not_claimed(r, "fetch", "envOnly"));

    cbm_free_result(r);
    PASS();
}

/* Shared folding must preserve topic/string identity before service resolution. */
TEST(extract_ts_folded_topics_keep_raw_identity) {
    CBMFileResult *r = extract(
        "const TENANT = 'tenant';\n"
        "const TOPIC = `${TENANT}/events`;\n"
        "const TOPICS = { EVENTS: `${TENANT}/events` };\n"
        "const PREFIX = 'tenant/';\n"
        "const DOUBLE = `${PREFIX}/events`;\n"
        "const UNKNOWN = `${tenant}/events`;\n"
        "const UNKNOWN_TOPICS = { EVENTS: `${tenant}/events` };\n"
        "const PLAIN = 'tenant/events';\n"
        "export function direct() { mqtt.publish(`${TENANT}/events`, 'payload'); }\n"
        "export function constant() { mqtt.publish(TOPIC, 'payload'); }\n"
        "export function member() { mqtt.publish(TOPICS.EVENTS, 'payload'); }\n"
        "export function literal() { mqtt.publish('tenant/events', 'payload'); }\n"
        "export function plain() { mqtt.publish(PLAIN, 'payload'); }\n"
        "export function doubled() { mqtt.publish(`${PREFIX}/events`, 'payload'); }\n"
        "export function doubledConstant() { mqtt.publish(DOUBLE, 'payload'); }\n"
        "export function unknown() { mqtt.publish(`${tenant}/events`, 'payload'); }\n"
        "export function unknownConstant() { mqtt.publish(UNKNOWN, 'payload'); }\n"
        "export function unknownMember() { mqtt.publish(UNKNOWN_TOPICS.EVENTS, 'payload'); }\n"
        "export function alias() { bus.publish(TOPICS.EVENTS, 'payload'); }\n",
        CBM_LANG_TYPESCRIPT, "t", "topics.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const char *functions[] = {"direct", "constant", "member",         "literal",
                               "plain",  "doubled",  "doubledConstant"};
    for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
        const CBMCall *c = find_call_in_func(r, "mqtt.publish", functions[i]);
        const char *expected = i < 5 ? "tenant/events" : "tenant//events";
        ASSERT_NOT_NULL(c);
        ASSERT_NOT_NULL(c->first_string_arg);
        ASSERT_STR_EQ(c->first_string_arg, expected);
        ASSERT_GTE(c->arg_count, 1);
        ASSERT_NOT_NULL(c->args[0].value);
        ASSERT_STR_EQ(c->args[0].value, expected);
    }
    const char *unknowns[] = {"unknown", "unknownConstant", "unknownMember"};
    for (size_t i = 0; i < sizeof(unknowns) / sizeof(unknowns[0]); i++) {
        const CBMCall *c = find_call_in_func(r, "mqtt.publish", unknowns[i]);
        ASSERT_NOT_NULL(c);
        ASSERT_NOT_NULL(c->first_string_arg);
        ASSERT_STR_EQ(c->first_string_arg, "{}/events");
        ASSERT_GTE(c->arg_count, 1);
        ASSERT(c->args[0].value == NULL || c->args[0].value[0] != '/');
    }
    const CBMCall *alias = find_call_in_func(r, "bus.publish", "alias");
    ASSERT_NOT_NULL(alias);
    ASSERT_STR_EQ(alias->first_string_arg, "tenant/events");
    ASSERT_GTE(alias->arg_count, 1);
    ASSERT_STR_EQ(alias->args[0].value, "tenant/events");
    /* Classification has not happened yet: raw and URL views stay distinct. */
    ASSERT_NOT_NULL(alias->args[0].url_value);
    ASSERT_STR_EQ(alias->args[0].url_value, "/tenant/events");
    cbm_free_result(r);
    PASS();
}

TEST(extract_py_folded_topic_keywords_keep_raw_identity) {
    CBMFileResult *r = extract("TENANT = 'tenant'\n"
                               "TOPIC = f'{TENANT}/events'\n"
                               "PREFIX = 'tenant/'\n"
                               "DOUBLE = PREFIX + '/events'\n"
                               "UNKNOWN = f'{tenant}/events'\n"
                               "def direct():\n    mqtt.publish(f'{TENANT}/events', 'payload')\n"
                               "def topic():\n    mqtt.publish(topic=TOPIC, payload='x')\n"
                               "def queue():\n    mqtt.publish(queue=TOPIC, payload='x')\n"
                               "def channel():\n    mqtt.publish(channel=TOPIC, payload='x')\n"
                               "def subject():\n    mqtt.publish(subject=TOPIC, payload='x')\n"
                               "def unknown():\n    mqtt.publish(topic=UNKNOWN, payload='x')\n"
                               "def doubled():\n    mqtt.publish(topic=DOUBLE, payload='x')\n"
                               "def unknown_callee():\n    send(topic=TOPIC, payload='x')\n",
                               CBM_LANG_PYTHON, "t", "topics.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const char *functions[] = {"direct", "topic", "queue", "channel", "subject"};
    for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
        const CBMCall *c = find_call_in_func(r, "mqtt.publish", functions[i]);
        ASSERT_NOT_NULL(c);
        ASSERT_STR_EQ(c->first_string_arg, "tenant/events");
        ASSERT_GTE(c->arg_count, 1);
        ASSERT_STR_EQ(c->args[0].value, "tenant/events");
        if (i > 0) {
            ASSERT_NULL(c->args[0].url_value);
        }
    }
    ASSERT_STR_EQ(url_in(r, "mqtt.publish", "unknown"), "{}/events");
    ASSERT_STR_EQ(url_in(r, "mqtt.publish", "doubled"), "tenant//events");
    const CBMCall *c = find_call_in_func(r, "send", "unknown_callee");
    ASSERT_NOT_NULL(c);
    ASSERT_STR_EQ(c->first_string_arg, "tenant/events");
    ASSERT_GTE(c->arg_count, 1);
    ASSERT_STR_EQ(c->args[0].value, "tenant/events");
    ASSERT_NULL(c->args[0].url_value);
    cbm_free_result(r);
    PASS();
}

/* #2235's URL slot carries the projection separately; unknown callees stay raw. */
TEST(extract_ts_folded_config_url_and_exclusions) {
    CBMFileResult *r =
        extract("const REL = 'api';\n"
                "const API_ENDPOINTS = { USER: `${REL}/users/me` };\n"
                "export function config() { return http({url: API_ENDPOINTS.USER}); }\n"
                "export function format() { return axios.getUri({url: API_ENDPOINTS.USER}); }\n"
                "export function register() { app.route({url: API_ENDPOINTS.USER, handler}); }\n"
                "export function relative() { return fetch(`${REL}/users/me`); }\n",
                CBM_LANG_TYPESCRIPT, "t", "config.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_in_func(r, "http", "config");
    ASSERT_NOT_NULL(c);
    ASSERT_STR_EQ(c->first_string_arg, "api/users/me");
    ASSERT_GTE(c->arg_count, 1);
    ASSERT_STR_EQ(c->args[0].value, "api/users/me");
    ASSERT_NOT_NULL(c->args[0].url_value);
    ASSERT_STR_EQ(c->args[0].url_value, "/api/users/me");
    const char *callees[] = {"axios.getUri", "app.route"};
    const char *functions[] = {"format", "register"};
    for (size_t i = 0; i < sizeof(callees) / sizeof(callees[0]); i++) {
        c = find_call_in_func(r, callees[i], functions[i]);
        ASSERT_NOT_NULL(c);
        ASSERT_NULL(c->first_string_arg);
        ASSERT_GTE(c->arg_count, 1);
        ASSERT_NULL(c->args[0].value);
        ASSERT_NULL(c->args[0].url_value);
    }
    c = find_call_in_func(r, "fetch", "relative");
    ASSERT_NOT_NULL(c);
    ASSERT_STR_EQ(c->first_string_arg, "/api/users/me");
    ASSERT_GTE(c->arg_count, 1);
    ASSERT_STR_EQ(c->args[0].value, "api/users/me");
    ASSERT_STR_EQ(c->args[0].url_value, "/api/users/me");
    cbm_free_result(r);
    PASS();
}

/* Reproduce-first: Java module QN must derive from the CONTAINING DIRECTORY, not
 * the filename stem, so a top-level class `Outer` in `Outer.java` is `t.Outer`,
 * NOT the doubled `t.Outer.Outer`. The nested method def QN must also equal the
 * QN the textual calls-enclosing path records for an in-body call (the
 * lsp_resolve join keys on exact caller_qn == enclosing_func_qn equality). */
TEST(extract_java_no_double_class_qn) {
    CBMFileResult *r = extract("class Outer {\n"
                               "    int helper(int x) { return x + 2; }\n"
                               "    class Inner {\n"
                               "        int run(int v) { return helper(v); }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "Outer.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module QN is the directory (root) → just the project. */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_STR_EQ(r->module_qn, "t");

    /* No def QN anywhere may double the top-level class name. */
    for (int i = 0; i < r->defs.count; i++) {
        const char *qn = r->defs.items[i].qualified_name;
        if (qn) {
            ASSERT_EQ(strstr(qn, "Outer.Outer"), NULL);
        }
    }

    /* The nested class and its method carry the single-form QN. */
    const CBMDefinition *outer = find_def_by_name(r, "Outer");
    ASSERT_NOT_NULL(outer);
    ASSERT_STR_EQ(outer->qualified_name, "t.Outer");

    const CBMDefinition *run = find_def_by_name(r, "run");
    ASSERT_NOT_NULL(run);
    ASSERT_STR_EQ(run->qualified_name, "t.Outer.Inner.run");

    /* The in-body call to helper() must be attributed to the SAME QN as the
     * method def — this is the equality the LSP cross-resolution join relies on
     * for nested classes (the lsp_outer_dispatch repro). */
    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, run->qualified_name);

    cbm_free_result(r);
    PASS();
}

/* Reproduce-first: Go module QN must derive from the CONTAINING DIRECTORY
 * (package), not the filename stem, so a type/method in `myapp/db/conn.go`
 * belongs to module `proj.myapp.db` and is NOT polluted with the `.conn.`
 * filename segment. */
TEST(extract_go_no_filename_in_module_qn) {
    CBMFileResult *r = extract("package db\n\n"
                               "type Conn struct{}\n\n"
                               "func (c *Conn) Query() {}\n",
                               CBM_LANG_GO, "proj", "myapp/db/conn.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module is the directory `myapp/db`, NOT `myapp/db/conn`. */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_STR_EQ(r->module_qn, "proj.myapp.db");

    /* The type and method QNs must not contain the filename segment `.conn.`. */
    const CBMDefinition *conn = find_def_by_name(r, "Conn");
    ASSERT_NOT_NULL(conn);
    ASSERT_STR_EQ(conn->qualified_name, "proj.myapp.db.Conn");

    /* Go method nodes carry a receiver-qualified QN (module + receiver type +
     * name) plus the parent_class link — the QN must carry the
     * directory-based module and NOT the `.conn.` filename segment. */
    const CBMDefinition *query = find_def_by_name(r, "Query");
    ASSERT_NOT_NULL(query);
    ASSERT_STR_EQ(query->qualified_name, "proj.myapp.db.Conn.Query");
    ASSERT_EQ(strstr(query->qualified_name, ".conn."), NULL);
    /* The method's parent_class must match the type node QN (for DEFINES_METHOD). */
    ASSERT_NOT_NULL(query->parent_class);
    ASSERT_STR_EQ(query->parent_class, "proj.myapp.db.Conn");

    cbm_free_result(r);
    PASS();
}

/* Issue #213: large TS files were indexed as a File node with zero children. */
TEST(extract_large_ts_has_functions_issue213) {
    enum { NFUNCS = 4000 };
    size_t cap = (size_t)NFUNCS * 80 + 64;
    char *src = (char *)malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t off = 0;
    for (int i = 0; i < NFUNCS; i++) {
        off +=
            (size_t)snprintf(src + off, cap - off,
                             "export function fn%d(a: number): number { return a + %d; }\n", i, i);
    }
    CBMFileResult *r =
        cbm_extract_file(src, (int)off, CBM_LANG_TYPESCRIPT, "t", "big.ts", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int fns = count_defs_with_label(r, "Function");
    ASSERT_GT(fns, 0); /* must not silently produce zero children */
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group: per-function complexity metrics (Tier A — local AST metrics)
 *
 * cbm_compute_complexity stamps each Function/Method with cyclomatic,
 * cognitive, loop_count and loop_depth in the same tree-sitter walk that
 * extracts the definition. loop_depth (max nested-loop depth) is the
 * polynomial-degree proxy used as a queryable bottleneck signal.
 * ═══════════════════════════════════════════════════════════════════ */

/* Return the first definition with the given name, or NULL. */
static const CBMDefinition *find_def(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0)
            return &r->defs.items[i];
    }
    return NULL;
}

TEST(complexity_nested_loops_depth) {
    CBMFileResult *r = extract("package p\n"
                               "func deepLoops() {\n"
                               "    for i := 0; i < 10; i++ {\n"
                               "        for j := 0; j < 10; j++ {\n"
                               "            for k := 0; k < 10; k++ {\n"
                               "                doWork()\n"
                               "            }\n"
                               "        }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "deep.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "deepLoops");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 3); /* three nested for-loops */
    ASSERT_EQ(d->loop_count, 3);
    cbm_free_result(r);
    PASS();
}

TEST(complexity_loop_with_branch) {
    CBMFileResult *r = extract("package p\n"
                               "func single() {\n"
                               "    for i := 0; i < 10; i++ {\n"
                               "        if i > 5 {\n"
                               "            doWork()\n"
                               "        }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "single.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "single");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 1);
    ASSERT_EQ(d->loop_count, 1);
    /* the nested `if` contributes a branch, so cyclomatic > 1 and the
     * nesting-weighted cognitive score is non-zero. */
    ASSERT_GT(d->complexity, 1);
    ASSERT_GT(d->cognitive, 0);
    cbm_free_result(r);
    PASS();
}

TEST(complexity_flat_no_loops) {
    CBMFileResult *r = extract("package p\n"
                               "func flat() {\n"
                               "    doWork()\n"
                               "    doMore()\n"
                               "}\n",
                               CBM_LANG_GO, "t", "flat.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "flat");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 0);
    ASSERT_EQ(d->loop_count, 0);
    cbm_free_result(r);
    PASS();
}

/* A linear-scan call (contains) inside a loop → hidden O(n^2) signal. */
TEST(complexity_linear_scan_in_loop) {
    CBMFileResult *r = extract("package p\n"
                               "func scanInLoop(xs []int, t int) bool {\n"
                               "    for i := 0; i < len(xs); i++ {\n"
                               "        if contains(xs, t) {\n"
                               "            return true\n"
                               "        }\n"
                               "    }\n"
                               "    return false\n"
                               "}\n",
                               CBM_LANG_GO, "t", "scan.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "scanInLoop");
    ASSERT_NOT_NULL(d);
    ASSERT_GT(d->linear_scan_in_loop, 0); /* contains() called inside the for-loop */
    cbm_free_result(r);
    PASS();
}

/* Self-call inside a loop, not guarded by any conditional → recursion_in_loop
 * and unguarded_recursion both set. */
TEST(complexity_recursion_in_loop_unguarded) {
    CBMFileResult *r = extract("package p\n"
                               "func recurInLoop(n int) {\n"
                               "    for i := 0; i < n; i++ {\n"
                               "        recurInLoop(n - 1)\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "recur.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recurInLoop");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_TRUE(d->recursion_in_loop);
    ASSERT_TRUE(d->unguarded_recursion); /* no self-call inside a conditional */
    cbm_free_result(r);
    PASS();
}

/* Self-call inside an `if` (a base-case guard) → recursive but NOT unguarded. */
TEST(complexity_guarded_recursion) {
    CBMFileResult *r = extract("package p\n"
                               "func guarded(n int) int {\n"
                               "    if n > 0 {\n"
                               "        return guarded(n - 1)\n"
                               "    }\n"
                               "    return 0\n"
                               "}\n",
                               CBM_LANG_GO, "t", "guarded.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "guarded");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->recursion_in_loop);
    ASSERT_FALSE(d->unguarded_recursion); /* self-call is guarded by `if n > 0` */
    cbm_free_result(r);
    PASS();
}

/* #599: super().save() inside a method named save is a parent-class call —
 * the receiver is super(), never self — so it must NOT flag self-recursion.
 * super()-ONLY fixture: no self.save() alongside, so the assertion cannot pass
 * vacuously off a genuine self-call. */
TEST(complexity_super_only_not_recursive) {
    CBMFileResult *r = extract("class B(A):\n"
                               "    def save(self):\n"
                               "        super().save()\n",
                               CBM_LANG_PYTHON, "t", "super_only.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* parent-class call, not self-recursion */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #599: a same-named call on an unrelated receiver (axios.get inside a
 * function also named get) is delegation, not self-recursion. */
TEST(complexity_same_name_other_receiver_not_recursive) {
    CBMFileResult *r = extract("function get(url) {\n"
                               "    return axios.get(url);\n"
                               "}\n",
                               CBM_LANG_JAVASCRIPT, "t", "axios_get.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "get");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* axios.get targets axios, not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* Guard: genuine self-recursion through self/this receivers still trips the
 * detector after the receiver-aware narrowing (#599). */
TEST(complexity_self_receiver_still_recursive) {
    /* Python: self.recur() — same object. */
    CBMFileResult *r = extract("class C:\n"
                               "    def recur(self, n):\n"
                               "        if n > 0:\n"
                               "            self.recur(n - 1)\n",
                               CBM_LANG_PYTHON, "t", "self_recur.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recur");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if n > 0` */
    cbm_free_result(r);

    /* JS: this.step() — same object. */
    r = extract("class C {\n"
                "    step(n) {\n"
                "        if (n > 0) { this.step(n - 1); }\n"
                "    }\n"
                "}\n",
                CBM_LANG_JAVASCRIPT, "t", "this_step.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "step");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if (n > 0)` */
    cbm_free_result(r);
    PASS();
}

/* #599: chained receiver — self.obj.recur() inside recur targets self's FIELD
 * obj, a different object. The whole receiver chain ("self.obj") must be
 * compared, not just its first segment ("self"). */
TEST(complexity_chained_receiver_not_self) {
    CBMFileResult *r = extract("class C:\n"
                               "    def recur(self, n):\n"
                               "        self.obj.recur(n)\n",
                               CBM_LANG_PYTHON, "t", "chained_recur.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recur");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* self.obj is not self */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #599: Go method receiver — the enclosing def's own receiver identifier
 * (`s` in `func (s *Store) save()`) is whitelisted dynamically from
 * CBMDefinition.receiver, so s.save() still counts as self-recursion while
 * s.backup.save() (a field's same-named method) does not. */
TEST(complexity_go_method_receiver_self_recursion) {
    CBMFileResult *r = extract("package p\n"
                               "type Store struct{}\n"
                               "func (s *Store) save(n int) {\n"
                               "    if n > 0 {\n"
                               "        s.save(n - 1)\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "store.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);         /* s.save() == receiver s → self */
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if n > 0` */
    cbm_free_result(r);

    /* Same-named method on a field of the receiver: NOT self-recursion. */
    r = extract("package p\n"
                "type Store struct{ backup *Store }\n"
                "func (s *Store) save(n int) {\n"
                "    s.backup.save(n)\n"
                "}\n",
                CBM_LANG_GO, "t", "store_backup.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* s.backup is not s */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #876: the delegation/store bucket left open after #599 — same-named calls
 * whose receiver is a CALL RESULT (_get_store().get), a module singleton
 * (_default.check), or a local cursor inside a loop (cur.execute) are not
 * self-recursion. All three are the reporter's exact v0.8.1 false positives;
 * fixed by the receiver-aware narrowing (87091ed), guarded here so the
 * bucket never regresses. */
TEST(complexity_delegation_receivers_not_recursive_issue876) {
    /* Store wrapper: _get_store().get() inside get — receiver is the call
     * result, a different object. */
    CBMFileResult *r = extract("def _get_store():\n"
                               "    return object()\n"
                               "\n"
                               "def get(collection, record_id):\n"
                               "    rec = _get_store().get(collection, record_id)\n"
                               "    return rec\n",
                               CBM_LANG_PYTHON, "t", "soil.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "get");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* _get_store() result is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);

    /* Module-singleton delegation: _default.check() inside check. */
    r = extract("class _Checker:\n"
                "    def check(self, app_id, tool_name):\n"
                "        return (True, \"ok\")\n"
                "\n"
                "_default = _Checker()\n"
                "\n"
                "def check(app_id, tool_name):\n"
                "    return _default.check(app_id, tool_name)\n",
                CBM_LANG_PYTHON, "t", "gleipnir.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The module-level wrapper (not the method) must stay clean. */
    d = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, "check") == 0 &&
            strcmp(r->defs.items[i].label, "Function") == 0) {
            d = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* _default is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);

    /* Same-named method on a local, called inside a loop (willow.nuke case):
     * neither recursive nor recursion_in_loop. */
    r = extract("def execute(conn, paths):\n"
                "    for p in paths:\n"
                "        cur = conn.cursor()\n"
                "        cur.execute(\"DELETE FROM t WHERE p = %s\", (p,))\n"
                "    return True\n",
                CBM_LANG_PYTHON, "t", "nuke.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "execute");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* cur is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    ASSERT_FALSE(d->recursion_in_loop);
    cbm_free_result(r);
    PASS();
}

/* Deep chained member access + parameter count structure smells. */
TEST(complexity_access_depth_and_params) {
    CBMFileResult *r = extract("package p\n"
                               "func deepAccess(x Foo, a int, b int, c int) int {\n"
                               "    return x.alpha.beta.gamma.delta\n"
                               "}\n",
                               CBM_LANG_GO, "t", "access.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "deepAccess");
    ASSERT_NOT_NULL(d);
    ASSERT_GT(d->max_access_depth, 2); /* x.alpha.beta.gamma.delta */
    ASSERT_GTE(d->param_count, 3);     /* x, a, b, c (grouping may vary) */
    cbm_free_result(r);
    PASS();
}

/* The definitions walk kept its pending frames under a ceiling (8M frames,
 * env CBM_WALK_DEFS_MAX) and stopped pushing once it was reached. Children are
 * pushed last-to-first, so a file wider than the ceiling lost its FIRST
 * top-level definitions. The ceiling and its env knob are gone; the knob is set
 * here to a value this file exceeds to prove it no longer decides content. */
enum { WIDE_DEFS = 1000, WIDE_DEFS_OLD_CAP = 256 };

TEST(walk_defs_wide_file_extracts_every_definition) {
    size_t cap = (size_t)WIDE_DEFS * 32 + 64;
    char *src = malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t pos = 0;
    for (int i = 0; i < WIDE_DEFS; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos, "int wd%d(void) { return %d; }\n", i, i);
    }
    char lim[16];
    snprintf(lim, sizeof(lim), "%d", WIDE_DEFS_OLD_CAP);
    cbm_setenv("CBM_WALK_DEFS_MAX", lim, 1);
    CBMFileResult *r = extract(src, CBM_LANG_C, "t", "wide_defs.c");
    cbm_unsetenv("CBM_WALK_DEFS_MAX");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < WIDE_DEFS; i++) {
        char name[16];
        snprintf(name, sizeof(name), "wd%d", i);
        ASSERT_NOT_NULL(find_def(r, name));
    }
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ── Walker stacks must never cap graph content ──────────────────────
 *
 * The complexity walkers and the body-token sampler used fixed-size pending
 * stacks (4096 / 512 nodes) and silently stopped pushing children once full.
 * Children are pushed last-to-first, so a wide body lost its FIRST statements:
 * a function with 5000 top-level branches under-reported its cyclomatic count,
 * and the token sampler started mid-body. These build bodies wider than either
 * old cap and assert the exact metrics. */
enum { WIDE_STMTS = 5000, WIDE_CALLS = 600, BODY_TOKEN_PREFIX = 100 };

/* C function `wide` whose body holds `n` top-level statements alternating
 * `if (x) g();` and `while (x) g();`. Caller frees. */
static char *build_wide_branch_fn(int n) {
    size_t cap = (size_t)n * 24 + 64;
    char *src = malloc(cap);
    if (!src)
        return NULL;
    size_t pos = (size_t)snprintf(src, cap, "void g(void);\nvoid wide(int x) {\n");
    for (int i = 0; i < n; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos, "%s",
                                (i % 2 == 0) ? "if (x) g();\n" : "while (x) g();\n");
    }
    snprintf(src + pos, cap - pos, "}\n");
    return src;
}

TEST(complexity_wide_body_exceeds_old_stack_cap) {
    char *src = build_wide_branch_fn(WIDE_STMTS);
    ASSERT_NOT_NULL(src);
    CBMFileResult *r = extract(src, CBM_LANG_C, "t", "wide.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "wide");
    ASSERT_NOT_NULL(d);
    /* every if/while is one branching node at nesting depth 0 */
    ASSERT_EQ(d->complexity, WIDE_STMTS);
    ASSERT_EQ(d->cognitive, WIDE_STMTS);
    ASSERT_EQ(d->loop_count, WIDE_STMTS / 2);
    ASSERT_EQ(d->loop_depth, 1);
    cbm_free_result(r);
    free(src);
    PASS();
}

TEST(count_branching_wide_body_exceeds_old_stack_cap) {
    char *src = build_wide_branch_fn(WIDE_STMTS);
    ASSERT_NOT_NULL(src);
    TSParser *parser = ts_parser_new();
    ASSERT_NOT_NULL(parser);
    ASSERT_TRUE(ts_parser_set_language(parser, cbm_ts_language(CBM_LANG_C)));
    TSTree *tree = ts_parser_parse_string(parser, NULL, src, (uint32_t)strlen(src));
    ASSERT_NOT_NULL(tree);
    int n = cbm_count_branching(ts_tree_root_node(tree),
                                cbm_lang_spec(CBM_LANG_C)->branching_node_types);
    ASSERT_EQ(n, WIDE_STMTS);
    ts_tree_delete(tree);
    ts_parser_delete(parser);
    free(src);
    PASS();
}

/* The body-token sampler's contract is "the first BODY_TOKEN_CAP unique
 * identifiers in source order". A body with 600 distinct calls must sample
 * from f0 on, not a window starting mid-body (the capped stack began at f91).
 * Only the source-order prefix f0..f99 is asserted: the sampler's dedupe key
 * (hash | 1) also merges identifiers whose hashes differ only in bit 0, which
 * drops a few later names (f122, f124, ...) -- a separate dedupe property this
 * test deliberately does not pin. */
TEST(body_tokens_wide_body_samples_from_the_start) {
    size_t cap = (size_t)WIDE_CALLS * 16 + 64;
    char *src = malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t pos = (size_t)snprintf(src, cap, "void wide_calls(void) {\n");
    for (int i = 0; i < WIDE_CALLS; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos, "f%d();\n", i);
    }
    snprintf(src + pos, cap - pos, "}\n");
    char expect[BODY_TOKEN_PREFIX * 8];
    size_t ep = 0;
    for (int i = 0; i < BODY_TOKEN_PREFIX; i++) {
        ep += (size_t)snprintf(expect + ep, sizeof(expect) - ep, "f%d ", i);
    }
    CBMFileResult *r = extract(src, CBM_LANG_C, "t", "wide_calls.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "wide_calls");
    ASSERT_NOT_NULL(d);
    ASSERT_NOT_NULL(d->body_tokens);
    ASSERT_GTE(strlen(d->body_tokens), ep);
    ASSERT_MEM_EQ(d->body_tokens, expect, ep);
    cbm_free_result(r);
    free(src);
    PASS();
}

/* The YAML walkers kept their pending mappings in fixed-size stacks (256 for
 * the dotted key-path walk, 512 for the infrastructure-binding scan) and
 * silently stopped pushing once full (#2388). A root mapping with more nested
 * sibling mappings than the old cap lost the full dotted key_path of every
 * leaf past it: `k299.url` was only ever recorded as the bare `url` that the
 * per-mapping walk of the nested block emits. */
enum { WIDE_YAML_KEYS = 300, WIDE_YAML_ITEMS = 600 };

static int has_string_ref_path(CBMFileResult *r, const char *key_path, const char *value) {
    for (int i = 0; i < r->string_refs.count; i++) {
        const CBMStringRef *s = &r->string_refs.items[i];
        if (s->key_path && s->value && strcmp(s->key_path, key_path) == 0 &&
            strcmp(s->value, value) == 0) {
            return 1;
        }
    }
    return 0;
}

TEST(yaml_key_paths_wide_mapping_exceed_old_stack_cap) {
    size_t cap = (size_t)WIDE_YAML_KEYS * 48 + 64;
    char *src = malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t pos = 0;
    for (int i = 0; i < WIDE_YAML_KEYS; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos,
                                "k%d:\n  url: \"https://h%d.example.com/x\"\n", i, i);
    }
    CBMFileResult *r = extract(src, CBM_LANG_YAML, "t", "wide.yaml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < WIDE_YAML_KEYS; i++) {
        char path[32];
        char value[48];
        snprintf(path, sizeof(path), "k%d.url", i);
        snprintf(value, sizeof(value), "https://h%d.example.com/x", i);
        ASSERT(has_string_ref_path(r, path, value));
    }
    cbm_free_result(r);
    free(src);
    PASS();
}

static int has_infra_source(CBMFileResult *r, const char *source, const char *url) {
    for (int i = 0; i < r->infra_bindings.count; i++) {
        const CBMInfraBinding *b = &r->infra_bindings.items[i];
        if (b->source_name && b->target_url && strcmp(b->source_name, source) == 0 &&
            strcmp(b->target_url, url) == 0) {
            return 1;
        }
    }
    return 0;
}

TEST(yaml_infra_bindings_wide_sequence_exceed_old_stack_cap) {
    size_t cap = (size_t)WIDE_YAML_ITEMS * 64 + 64;
    char *src = malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t pos = 0;
    for (int i = 0; i < WIDE_YAML_ITEMS; i++) {
        pos += (size_t)snprintf(src + pos, cap - pos,
                                "- topic: t%d\n  push_endpoint: \"https://h%d.example.com/p\"\n", i,
                                i);
    }
    CBMFileResult *r = extract(src, CBM_LANG_YAML, "t", "pubsub.yaml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < WIDE_YAML_ITEMS; i++) {
        char source[16];
        char url[48];
        snprintf(source, sizeof(source), "t%d", i);
        snprintf(url, sizeof(url), "https://h%d.example.com/p", i);
        ASSERT(has_infra_source(r, source, url));
    }
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Perl call-graph noise (#459 follow-up)
 * ═══════════════════════════════════════════════════════════════════ */

/* Count calls whose callee_name is exactly `name` (has_call is substring). */
static int count_calls_exact(CBMFileResult *r, const char *name) {
    int n = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, name) == 0)
            n++;
    }
    return n;
}

/* (b) A dotted config string must never be extracted as a callee. */
TEST(extract_perl_config_string_not_a_callee) {
    CBMFileResult *r = extract("package C;\n"
                               "sub run {\n"
                               "  my $cfg = { \"log4perl.appender.File.utf8\" => 1 };\n"
                               "  helper();\n"
                               "}\n"
                               "sub helper { return 1; }\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "app.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* No callee may contain a '.' (config/string tokens are rejected). */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_TRUE(strchr(r->calls.items[i].callee_name, '.') == NULL);
    }
    /* (d) The genuine intra-file function call is still extracted. */
    ASSERT_TRUE(count_calls_exact(r, "helper") >= 1);
    cbm_free_result(r);
    PASS();
}

/* (a) A Perl builtin call is extracted as a non-method callee. Suppression of
 *     the resulting CALLS edge happens in the resolver (see test_registry.c /
 *     end-to-end); extraction itself keeps the bare builtin token. */
TEST(extract_perl_builtin_call_is_function_not_method) {
    CBMFileResult *r = extract("package B;\n"
                               "sub run {\n"
                               "  my @x;\n"
                               "  push @x, 1;\n"
                               "  keys %h;\n"
                               "}\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "b.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* push / keys are extracted (they are valid identifiers) ... */
    ASSERT_TRUE(has_call(r, "push"));
    /* ... and crucially are NOT flagged as method calls. */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    cbm_free_result(r);
    PASS();
}

/* (c) An arrow/method call is extracted with is_method=true so the resolver
 *     can suppress generic short-name matching for it. */
TEST(extract_perl_method_call_flags_is_method) {
    CBMFileResult *r = extract("package M;\n"
                               "sub run {\n"
                               "  my $self = shift;\n"
                               "  $self->commit();\n"
                               "  $dbh->commit();\n"
                               "  helper();\n"
                               "}\n"
                               "sub helper { return 1; }\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "m.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Every "commit" call is a method call (is_method set). */
    int commit_calls = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "commit") == 0) {
            commit_calls++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        /* The genuine function call is NOT a method. */
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(commit_calls >= 1);
    /* (d) genuine intra-file function call still extracted. */
    ASSERT_TRUE(count_calls_exact(r, "helper") >= 1);
    cbm_free_result(r);
    PASS();
}

/* The def QN of `name` and the enclosing-function QN of the call `callee` inside
 * it, from one extraction result. */
static void rust_def_and_scope(const CBMFileResult *r, const char *name, const char *callee,
                               const char **def_qn, const char **scope_qn) {
    *def_qn = NULL;
    *scope_qn = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && d->qualified_name && strcmp(d->name, name) == 0) {
            *def_qn = d->qualified_name;
        }
    }
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->callee_name && strcmp(c->callee_name, callee) == 0 && c->enclosing_func_qn &&
            strstr(c->enclosing_func_qn, name)) {
            *scope_qn = c->enclosing_func_qn;
        }
    }
}

/* F-R4: a method of a generic impl (`impl<T> Gen<T>`, `impl<'a> Life<'a>`) got a
 * call scope that kept the generic arguments ("...Gen<T>.in_generic") while the
 * def side strips them ("...Gen.in_generic"), so no node carried the scope and
 * every call in the body fell back to the File node (base census: 84,331 Rust
 * CALLS sourced from a File although inside a function, 96% of all File-sourced
 * Rust CALLS). The def QN and the call scope must agree. */
TEST(extract_rust_generic_impl_call_scope_matches_def) {
    CBMFileResult *r = extract("pub struct Plain;\n"
                               "impl Plain {\n"
                               "    pub fn in_plain(&self) -> u32 { helper() }\n"
                               "}\n"
                               "pub struct Gen<T> { v: T }\n"
                               "impl<T> Gen<T> {\n"
                               "    pub fn in_generic(&self) -> u32 { helper() }\n"
                               "}\n"
                               "pub struct Life<'a> { s: &'a str }\n"
                               "impl<'a> Life<'a> {\n"
                               "    pub fn in_lifetime(&self) -> u32 { helper() }\n"
                               "}\n"
                               "pub fn helper() -> u32 { 1 }\n",
                               CBM_LANG_RUST, "t", "src/lib.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    static const char *const methods[] = {"in_plain", "in_generic", "in_lifetime", NULL};
    for (int m = 0; methods[m]; m++) {
        const char *def_qn = NULL;
        const char *scope_qn = NULL;
        rust_def_and_scope(r, methods[m], "helper", &def_qn, &scope_qn);
        ASSERT_NOT_NULL(def_qn);
        ASSERT_NOT_NULL(scope_qn);
        ASSERT_STR_EQ(scope_qn, def_qn);
    }
    cbm_free_result(r);
    PASS();
}

/* Languages OUTSIDE the is_method flag set (Perl, Python, TS/JS/TSX and Go set
 * it) must be unaffected: a Rust method call never sets is_method. */
TEST(extract_flag_exempt_method_call_not_flagged_is_method) {
    /* Rust is flag-exempt: only Perl, Python, TS/JS and Go set is_method.
     * Guards the blast radius of the receiver-aware flags for every other
     * language. */
    CBMFileResult *r = extract("fn run(o: Obj) {\n"
                               "    o.commit();\n"
                               "    helper();\n"
                               "}\n",
                               CBM_LANG_RUST, "t", "x.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    cbm_free_result(r);
    PASS();
}

/* Python receiver-aware flag (#1276; same intent as the Perl and TS/JS flags).
 * Pins BOTH directions: an unknown receiver (a parameter, or an attribute of
 * self) IS flagged so the resolver can suppress a weak short-name match, while
 * self/cls/super() and import-bound receivers — Python's canonical cross-file
 * call shape — are NOT, so their true edges survive. */
TEST(extract_python_member_call_flags_is_method) {
    CBMFileResult *r = extract("from pkg import helper\n"
                               "import tools as toolkit\n"
                               "\n"
                               "class C(Base):\n"
                               "    def run(self, external):\n"
                               "        external.commit()\n"
                               "        self.client.send()\n"
                               "        self.helper()\n"
                               "        super ( ).render()\n"
                               "        helper.compute()\n"
                               "        toolkit.format()\n"
                               "        helper()\n",
                               CBM_LANG_PYTHON, "t", "x.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int external = 0;
    int nested = 0;
    int self_call = 0;
    int super_call = 0;
    int imported_module = 0;
    int imported_alias = 0;
    int bare = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (strcmp(cn, "external.commit") == 0) {
            /* parameter receiver — unknown type */
            external++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        } else if (strcmp(cn, "self.client.send") == 0) {
            /* receiver is `self.client`, an attribute of unknown type — NOT self */
            nested++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        } else if (strcmp(cn, "self.helper") == 0) {
            self_call++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        } else if (strstr(cn, "render") != NULL) {
            super_call++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        } else if (strcmp(cn, "helper.compute") == 0) {
            imported_module++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        } else if (strcmp(cn, "toolkit.format") == 0) {
            /* aliased import: local_name is "toolkit" */
            imported_alias++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        } else if (strcmp(cn, "helper") == 0) {
            bare++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    /* Each shape must appear exactly once, so a missed extraction cannot make
     * the loop above pass vacuously. */
    ASSERT_EQ(external, 1);
    ASSERT_EQ(nested, 1);
    ASSERT_EQ(self_call, 1);
    ASSERT_EQ(super_call, 1);
    ASSERT_EQ(imported_module, 1);
    ASSERT_EQ(imported_alias, 1);
    ASSERT_EQ(bare, 1);
    cbm_free_result(r);
    PASS();
}

/* Python bare-call local-binding flag (the bare-call counterpart of the
 * receiver flag above). Pins BOTH directions: a callee shadowed by a parameter
 * of an enclosing scope IS flagged so the resolver can suppress a weak
 * short-name match, while an unshadowed callee — a genuine module-level
 * function, an imported name, or a nested `def` — is NOT, so its true edge
 * survives. Every parameter binding form the grammar produces is covered, since
 * a form the extractor silently missed would leave that shape unguarded. */
TEST(extract_python_bare_call_flags_locally_bound_callee) {
    CBMFileResult *r = extract("from pkg import helper\n"
                               "\n"
                               "def outer(run, *rest, timeout=5, label: str = 'x', **opts):\n"
                               "    def inner():\n"
                               "        return run()\n"
                               "    rest()\n"
                               "    timeout()\n"
                               "    label()\n"
                               "    opts()\n"
                               "    module_level()\n"
                               "    helper()\n"
                               "    return inner()\n"
                               "\n"
                               "def typed(cb: Callable):\n"
                               "    return cb()\n"
                               "\n"
                               "apply_it = lambda fn: fn()\n",
                               CBM_LANG_PYTHON, "t", "x.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* callee name -> (expected flag, seen count) */
    struct {
        const char *callee;
        bool expect_bound;
        int seen;
    } cases[] = {
        {"run", true, 0},           /* closure over an ENCLOSING function's parameter */
        {"rest", true, 0},          /* *args   -> list_splat_pattern                  */
        {"timeout", true, 0},       /* default_parameter                              */
        {"label", true, 0},         /* typed_default_parameter (keyword-only)         */
        {"opts", true, 0},          /* **kwargs -> dictionary_splat_pattern           */
        {"cb", true, 0},            /* typed_parameter, no default                    */
        {"fn", true, 0},            /* lambda parameter                               */
        {"module_level", false, 0}, /* unbound: the true cross-file edge         */
        {"helper", false, 0},       /* imported name, not a parameter            */
        {"inner", false, 0},        /* nested def: a real target, keep the edge  */
    };
    const int case_count = (int)(sizeof(cases) / sizeof(cases[0]));

    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (!cn) {
            continue;
        }
        for (int c = 0; c < case_count; c++) {
            if (strcmp(cn, cases[c].callee) != 0) {
                continue;
            }
            cases[c].seen++;
            if (r->calls.items[i].callee_is_locally_bound != cases[c].expect_bound) {
                printf("  bare-call flag mismatch for %s(): got %d, expected %d\n", cases[c].callee,
                       r->calls.items[i].callee_is_locally_bound ? 1 : 0,
                       cases[c].expect_bound ? 1 : 0);
            }
            ASSERT_EQ(r->calls.items[i].callee_is_locally_bound, cases[c].expect_bound);
        }
    }
    /* Each shape must appear exactly once, so a missed extraction cannot let the
     * loop above pass vacuously. */
    for (int c = 0; c < case_count; c++) {
        if (cases[c].seen != 1) {
            printf("  bare call %s() extracted %d times, expected 1\n", cases[c].callee,
                   cases[c].seen);
        }
        ASSERT_EQ(cases[c].seen, 1);
    }
    cbm_free_result(r);
    PASS();
}

TEST(extract_go_selector_call_flags_is_method) {
    /* Go selector calls are flagged so the weak-match guard can fire when the
     * Go LSP cannot type the receiver; bare calls stay unflagged. */
    CBMFileResult *r = extract("package m\n"
                               "func run(o Obj) { o.Commit(); helper() }\n",
                               CBM_LANG_GO, "t", "x.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    bool saw_selector = false;
    bool saw_bare = false;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->callee_name && strstr(c->callee_name, "Commit") != NULL) {
            ASSERT_TRUE(c->is_method);
            saw_selector = true;
        }
        if (c->callee_name && strcmp(c->callee_name, "helper") == 0) {
            ASSERT_FALSE(c->is_method);
            saw_bare = true;
        }
    }
    ASSERT_TRUE(saw_selector);
    ASSERT_TRUE(saw_bare);
    cbm_free_result(r);
    PASS();
}

/* The bare-call flag is DEPTH-INDEPENDENT, and the binding is UNWOUND when its
 * scope closes.
 *
 * Both properties come from the same design decision. The answer is carried by
 * the unified walk -- parameters are bound when a def or lambda scope opens and
 * unwound when it closes -- rather than recomputed per call by ascending the
 * tree. An ascending walk is O(depth) per call, and every level of f(f(f(...)))
 * is itself a bare call, so it is quadratic in a file's nesting depth; that hung
 * stack_overflow_b's 30,000-deep fixture rather than merely slowing it. An
 * earlier cut capped the ascent at 64 ancestors and FAILED OPEN past it, which
 * silently stopped suppressing on deep-but-ordinary code.
 *
 * Pinned deterministically rather than by wall clock -- a timing assertion would
 * be a lottery, not a gate. The depth case fails if a cap is reintroduced; the
 * unwind case fails if a frame's bindings outlive its scope. */
TEST(extract_python_bare_call_flag_is_depth_independent) {
    /* Shallow: return_statement / block / function_definition — 3 ancestors. */
    CBMFileResult *shallow = extract("def shallow(handler):\n"
                                     "    return handler()\n",
                                     CBM_LANG_PYTHON, "t", "s.py");
    ASSERT_NOT_NULL(shallow);
    ASSERT_FALSE(shallow->has_error);
    int shallow_seen = 0;
    for (int i = 0; i < shallow->calls.count; i++) {
        const char *cn = shallow->calls.items[i].callee_name;
        if (cn && strcmp(cn, "handler") == 0) {
            shallow_seen++;
            ASSERT_TRUE(shallow->calls.items[i].callee_is_locally_bound);
        }
    }
    ASSERT_EQ(shallow_seen, 1);
    cbm_free_result(shallow);

    /* Deep: 200 parenthesized_expression ancestors separate the SAME call from
     * its enclosing def. The parameter still shadows it, so it stays flagged --
     * depth changes nothing. This is the case a 64-ancestor cap got wrong. */
    const int PARENS = 200;
    size_t sz = (size_t)PARENS * 2 + 128;
    char *src = malloc(sz);
    ASSERT_NOT_NULL(src);
    char *w = src;
    w += snprintf(w, sz, "def deep(handler):\n    return ");
    memset(w, '(', (size_t)PARENS);
    w += PARENS;
    w += snprintf(w, sz - (size_t)(w - src), "handler()");
    memset(w, ')', (size_t)PARENS);
    w += PARENS;
    snprintf(w, sz - (size_t)(w - src), "\n");

    CBMFileResult *deep = extract(src, CBM_LANG_PYTHON, "t", "d.py");
    ASSERT_NOT_NULL(deep);
    ASSERT_FALSE(deep->has_error);
    int deep_seen = 0;
    for (int i = 0; i < deep->calls.count; i++) {
        const char *cn = deep->calls.items[i].callee_name;
        if (cn && strcmp(cn, "handler") == 0) {
            deep_seen++;
            ASSERT_TRUE(deep->calls.items[i].callee_is_locally_bound);
        }
    }
    ASSERT_EQ(deep_seen, 1);
    cbm_free_result(deep);
    free(src);

    /* Unwind: `handler` is a parameter of shadowed() and a module-level function
     * of the same name. The call INSIDE shadowed() is flagged; the call in
     * sibling(), after that scope closed, must NOT be — it really does resolve
     * to the module-level def. A binding that outlived its frame would flag it
     * and destroy a true edge, which is the one direction this guard must never
     * fail in. Nested same-name defs also pin the count: leaving the inner scope
     * must not unbind the outer one. */
    CBMFileResult *unwound = extract("def handler():\n"
                                     "    return 1\n"
                                     "\n"
                                     "def shadowed(handler):\n"
                                     "    def inner(handler):\n"
                                     "        return handler()\n"
                                     "    return inner(handler) or handler()\n"
                                     "\n"
                                     "def sibling():\n"
                                     "    return handler()\n",
                                     CBM_LANG_PYTHON, "t", "u.py");
    ASSERT_NOT_NULL(unwound);
    ASSERT_FALSE(unwound->has_error);
    int flagged = 0;
    int unflagged = 0;
    for (int i = 0; i < unwound->calls.count; i++) {
        const char *cn = unwound->calls.items[i].callee_name;
        if (!cn || strcmp(cn, "handler") != 0) {
            continue;
        }
        if (unwound->calls.items[i].callee_is_locally_bound) {
            flagged++;
        } else {
            unflagged++;
        }
    }
    /* Two shadowed calls (inner body, and shadowed()'s own tail) and exactly one
     * unshadowed call in sibling(). */
    ASSERT_EQ(flagged, 2);
    ASSERT_EQ(unflagged, 1);
    cbm_free_result(unwound);
    PASS();
}

TEST(extract_go_method_receiver_qualified_qn) {
    /* A Go method QN carries the receiver type (proj.pkg.Recv.method), same
     * shape as C++ out-of-line methods and Go interface members — so two
     * same-name methods on different receivers no longer collide in the
     * graph upsert. Free functions keep the flat package QN. */
    CBMFileResult *r = extract("package m\n"
                               "type Storage struct{}\n"
                               "type Cache struct{}\n"
                               "func (s *Storage) Close() {}\n"
                               "func (c Cache) Close() {}\n"
                               "func Shutdown() {}\n",
                               CBM_LANG_GO, "t", "x.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    bool saw_storage = false;
    bool saw_cache = false;
    bool saw_free = false;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (!d->name || !d->qualified_name) {
            continue;
        }
        if (strcmp(d->name, "Close") == 0 && strcmp(d->qualified_name, "t.Storage.Close") == 0) {
            ASSERT_STR_EQ(d->label, "Method");
            ASSERT_STR_EQ(d->parent_class, "t.Storage");
            saw_storage = true;
        }
        if (strcmp(d->name, "Close") == 0 && strcmp(d->qualified_name, "t.Cache.Close") == 0) {
            ASSERT_STR_EQ(d->parent_class, "t.Cache");
            saw_cache = true;
        }
        if (strcmp(d->name, "Shutdown") == 0) {
            ASSERT_STR_EQ(d->qualified_name, "t.Shutdown");
            saw_free = true;
        }
    }
    ASSERT_TRUE(saw_storage);
    ASSERT_TRUE(saw_cache);
    ASSERT_TRUE(saw_free);
    cbm_free_result(r);
    PASS();
}

/* Templ shares Go's method grammar (method_declaration with a receiver), but
 * only Go method QNs are receiver-qualified (#1913); templ's call-scope QN
 * stays flat. The method's def QN and the enclosing-function QN of a call
 * inside it must agree, or the call has no source node and degrades to the
 * File node. */
TEST(extract_templ_method_qn_matches_call_scope) {
    CBMFileResult *r = extract("package views\n"
                               "\n"
                               "type Page struct{}\n"
                               "\n"
                               "func (p Page) Title() string {\n"
                               "\treturn helper()\n"
                               "}\n"
                               "\n"
                               "func helper() string { return \"x\" }\n"
                               "\n"
                               "templ hello(name string) {\n"
                               "\t<div>{ name }</div>\n"
                               "}\n",
                               CBM_LANG_TEMPL, "t", "x.templ");
    ASSERT_NOT_NULL(r);
    const char *title_qn = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && d->qualified_name && strcmp(d->name, "Title") == 0) {
            title_qn = d->qualified_name;
        }
    }
    const char *scope = NULL;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->callee_name && strcmp(c->callee_name, "helper") == 0) {
            scope = c->enclosing_func_qn;
        }
    }
    ASSERT_NOT_NULL(title_qn);
    ASSERT_NOT_NULL(scope);
    ASSERT_STR_EQ(scope, title_qn);
    cbm_free_result(r);
    PASS();
}

TEST(extract_go_multiple_init_disambiguated) {
    /* Go allows several init() per package (even per file); each gets a
     * file+ordinal-suffixed QN (#495 cfg-twin pattern) so none is lost to the
     * same-QN upsert. The ordinal — unlike a line number — must not move when
     * code is inserted above the function: the QN is node identity, and a
     * line-based suffix would churn nodes on every unrelated edit. */
    CBMFileResult *r = extract("package m\n"
                               "func init() { a() }\n"
                               "func init() { b() }\n"
                               "func a() {}\n"
                               "func b() {}\n",
                               CBM_LANG_GO, "t", "x.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const char *first = NULL;
    const char *second = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (!d->name || strcmp(d->name, "init") != 0) {
            continue;
        }
        if (!first) {
            first = d->qualified_name;
        } else {
            second = d->qualified_name;
        }
    }
    ASSERT_NOT_NULL(first);
    ASSERT_NOT_NULL(second);
    ASSERT_STR_EQ(first, "t.init#x.go:1");
    ASSERT_STR_EQ(second, "t.init#x.go:2");

    /* Stability: an insertion ABOVE both inits must not change either QN. */
    CBMFileResult *r2 = extract("package m\n"
                                "import \"fmt\"\n"
                                "var shifted = fmt.Sprint(\"pad\")\n"
                                "func init() { a() }\n"
                                "func init() { b() }\n"
                                "func a() {}\n"
                                "func b() {}\n",
                                CBM_LANG_GO, "t", "x.go");
    ASSERT_NOT_NULL(r2);
    ASSERT_FALSE(r2->has_error);
    int seen = 0;
    for (int i = 0; i < r2->defs.count; i++) {
        const CBMDefinition *d = &r2->defs.items[i];
        if (!d->name || strcmp(d->name, "init") != 0) {
            continue;
        }
        seen++;
        if (seen == 1) {
            ASSERT_STR_EQ(d->qualified_name, "t.init#x.go:1");
        } else {
            ASSERT_STR_EQ(d->qualified_name, "t.init#x.go:2");
        }
    }
    ASSERT_EQ(seen, 2);
    cbm_free_result(r2);
    cbm_free_result(r);
    PASS();
}

/* TS/JS/TSX receiver-aware flag (#592/#606; same intent as the Perl flag above).
 * A member call x.foo() with a non-this/super receiver is flagged is_method so
 * the resolver can suppress a weak short-name match (`re.test()` must not bind a
 * project `test`); a bare call is not flagged. */
TEST(extract_ts_member_call_flags_is_method) {
    CBMFileResult *r = extract("const re = /^a+$/;\n"
                               "export function checkFormat(s: string) { return re.test(s); }\n"
                               "function helper() { return 1; }\n"
                               "export function run() { return helper(); }\n",
                               CBM_LANG_TYPESCRIPT, "t", "a.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int member = 0;
    int bare = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (strcmp(cn, "re.test") == 0) {
            member++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        if (strcmp(cn, "helper") == 0) {
            bare++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(member >= 1); /* re.test() flagged */
    ASSERT_TRUE(bare >= 1);   /* helper() not flagged */
    cbm_free_result(r);
    PASS();
}

/* this/super receivers keep the enclosing-class target, where a weak
 * namespace-proximity match is usually correct — so they are NOT flagged. A
 * new_expression has no member receiver and is never flagged either. */
TEST(extract_ts_this_super_receiver_not_flagged) {
    CBMFileResult *r = extract("class A extends B {\n"
                               "  m() { this.helper(); super.render(); return new A(); }\n"
                               "  helper() {}\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "b.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Every call here has a self receiver (this/super) or is a new-expression,
     * so NONE may be flagged. */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    /* Sanity: the this/super member calls were actually extracted. */
    ASSERT_TRUE(has_call(r, "helper")); /* this.helper */
    ASSERT_TRUE(has_call(r, "render")); /* super.render */
    cbm_free_result(r);
    PASS();
}

/* JS dialect behaves like TS (the flag is gated on the language set, not the
 * dialect). Replaces the pre-#592 test that asserted JS never flags is_method. */
TEST(extract_js_member_call_flags_is_method) {
    CBMFileResult *r =
        extract("function run(o){ o.commit(); helper(); }\n", CBM_LANG_JAVASCRIPT, "t", "x.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int member = 0;
    int bare = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (strcmp(cn, "o.commit") == 0) {
            member++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        if (strcmp(cn, "helper") == 0) {
            bare++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(member >= 1); /* o.commit() flagged */
    ASSERT_TRUE(bare >= 1);   /* helper() not flagged */
    cbm_free_result(r);
    PASS();
}

/* #961: a C function whose body braces are split across #ifdef/#else
 * branches (one open brace per branch, a single shared close) parses with
 * an ERROR region on the raw source — both branches are present at once —
 * and the defs walk silently dropped the function while its callers stayed
 * (cbm_path_within_root, handle_process_kill). The preprocessed second
 * pass (simplecpp picks one branch, same-file token lines stay aligned)
 * must recover the definition with its original line. */
TEST(extract_c_ifdef_split_brace_fn_recovered_issue961) {
    CBMFileResult *r = extract("static int a(void) { return 1; }\n"
                               "static int b(void) { return 2; }\n"
                               "int split_brace_fn(int x) {\n"
                               "#ifdef _WIN32\n"
                               "    if (a() && b()) {\n"
                               "#else\n"
                               "    if (a() || b()) {\n"
                               "#endif\n"
                               "        x += 1;\n"
                               "    }\n"
                               "    return x;\n"
                               "}\n"
                               "int after_fn(int x) { return x; }\n",
                               CBM_LANG_C, "t", "split.c");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def(r, "split_brace_fn");
    if (!d) {
        fprintf(stderr, "  [961] FAIL split_brace_fn dropped (defs walk lost the "
                        "#ifdef-split function)\n");
    }
    ASSERT_NOT_NULL(d);
    ASSERT_EQ((int)d->start_line, 3);
    /* Error recovery must stay localized: neighbours extract either way. */
    ASSERT_NOT_NULL(find_def(r, "a"));
    ASSERT_NOT_NULL(find_def(r, "after_fn"));
    cbm_free_result(r);
    PASS();
}

static const char *CPP_PREPROC_SIGNATURE_GAP_SRC =
    "struct Rect {};\n"
    "struct IBinder {};\n"
    "struct IRegionSamplingListener {};\n"
    "typedef int status_t;\n"
    "\n"
    "class SurfaceFlinger {\n"
    "public:\n"
    "    status_t addRegionSamplingListener(const Rect&, const IBinder&,\n"
    "                                       const IRegionSamplingListener&, bool);\n"
    "    status_t addRegionSamplingListener(const Rect&, const IBinder&,\n"
    "                                       const IRegionSamplingListener&);\n"
    "    void commit();\n"
    "    void composite();\n"
    "};\n"
    "\n"
    "#ifdef FLYME_GRAPHICS_EXTEND_LUMARGB\n"
    "status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,\n"
    "                                                   const IBinder& stopLayerHandle,\n"
    "                                                   const IRegionSamplingListener& listener,\n"
    "                                                   const bool rgbSample) {\n"
    "#else\n"
    "status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,\n"
    "                                                   const IBinder& stopLayerHandle,\n"
    "                                                   const IRegionSamplingListener& listener) "
    "{\n"
    "#endif\n"
    "    return 0;\n"
    "}\n"
    "\n"
    "void SurfaceFlinger::commit() {}\n"
    "\n"
    "void SurfaceFlinger::composite() {}\n";

/* #946 fixture from the original report: both preprocessor choices must keep
 * raw definitions primary while recovering later methods at original lines. */
TEST(extract_cpp_preproc_signature_gap_issue946) {
    const char *defines[] = {"FLYME_GRAPHICS_EXTEND_LUMARGB", NULL};
    for (int enabled = 0; enabled < 2; enabled++) {
        CBMFileResult *r = cbm_extract_file(
            CPP_PREPROC_SIGNATURE_GAP_SRC, (int)strlen(CPP_PREPROC_SIGNATURE_GAP_SRC), CBM_LANG_CPP,
            "t", "SurfaceFlinger.cpp", 0, enabled ? defines : NULL, NULL);
        ASSERT_NOT_NULL(r);
        const CBMDefinition *add = find_def(r, "addRegionSamplingListener");
        const CBMDefinition *commit = find_def(r, "commit");
        const CBMDefinition *composite = find_def(r, "composite");
        ASSERT_NOT_NULL(add);
        ASSERT_NOT_NULL(commit);
        ASSERT_NOT_NULL(composite);
        ASSERT_EQ(add->start_line, 22u);
        ASSERT_EQ(add->end_line, 27u);
        ASSERT_EQ(commit->start_line, 29u);
        ASSERT_EQ(commit->end_line, 29u);
        ASSERT_EQ(composite->start_line, 31u);
        ASSERT_EQ(composite->end_line, 31u);
        cbm_free_result(r);
    }
    PASS();
}

/* Macro expansion can produce callable-looking AST nodes, but no callable
 * definition exists in the original span; recovery must fail closed. */
TEST(extract_cpp_preproc_macro_generated_callable_skipped_issue949) {
    const char *src = "#define MAKE_FN(name) int name() { return 1; }\n"
                      "#ifdef ENABLE_GENERATED\n"
                      "MAKE_FN(generated)\n"
                      "#endif\n"
                      "int visible() { return 0; }\n";
    const char *defines[] = {"ENABLE_GENERATED", NULL};
    CBMFileResult *r =
        cbm_extract_file(src, (int)strlen(src), CBM_LANG_CPP, "t", "macro.cpp", 0, defines, NULL);
    ASSERT_NOT_NULL(r);
    ASSERT_NULL(find_def(r, "generated"));
    ASSERT_NOT_NULL(find_def(r, "visible"));
    ASSERT_TRUE(r->parse_incomplete);
    ASSERT_GTE(r->error_region_count, 1);
    ASSERT_NOT_NULL(r->error_ranges);
    cbm_free_result(r);
    PASS();
}

/* #949 follow-up: an included header shifts physical lines in simplecpp's
 * expanded output. The #1050 name-on-same-line guard skipped this recoverable
 * definition; explicit source ownership mapping must restore its original
 * coordinates while keeping header definitions out of the main file. */
TEST(extract_c_ifdef_split_brace_after_include_remapped_issue949) {
    char tmpdir[512];
    snprintf(tmpdir, sizeof(tmpdir), "%s/cbm_line_map_XXXXXX", cbm_tmpdir());
    ASSERT_NOT_NULL(cbm_mkdtemp(tmpdir));

    char header_path[512];
    snprintf(header_path, sizeof(header_path), "%s/padding.h", tmpdir);
    FILE *header = cbm_fopen(header_path, "wb");
    ASSERT_NOT_NULL(header);
    for (int i = 0; i < 40; i++) {
        ASSERT_GTE(fprintf(header, "static int header_pad_%d(void) { return %d; }\n", i, i), 0);
    }
    ASSERT_EQ(fclose(header), 0);

    const char *includes[] = {tmpdir, NULL};
    const char *src = "#include \"padding.h\"\n"
                      "static int before(void) { return 1; }\n"
                      "int shifted_split(int x) {\n"
                      "#ifdef _WIN32\n"
                      "    if (before()) {\n"
                      "#else\n"
                      "    if (x > 0) {\n"
                      "#endif\n"
                      "        x += 1;\n"
                      "    }\n"
                      "    return x;\n"
                      "}\n"
                      "int after(void) { return 2; }\n";
    CBMFileResult *r =
        cbm_extract_file(src, (int)strlen(src), CBM_LANG_C, "t", "shifted.c", 0, NULL, includes);
    cbm_unlink(header_path);
    cbm_rmdir(tmpdir);

    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def(r, "shifted_split");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->start_line, 3u);
    ASSERT_EQ(d->end_line, 12u);
    ASSERT_NULL(find_def(r, "header_pad_0"));
    ASSERT_NOT_NULL(find_def(r, "after"));
    ASSERT_FALSE(r->parse_incomplete);
    ASSERT_EQ(r->error_region_count, 0);
    ASSERT_NULL(r->error_ranges);
    cbm_free_result(r);
    PASS();
}

/* #961 inverse guard: a clean C file must not gain duplicate or phantom
 * defs from the recovery path (it only engages on raw-parse ERROR regions). */
TEST(extract_c_clean_file_no_recovery_duplicates_issue961) {
    CBMFileResult *r = extract("#ifdef _WIN32\n"
                               "static int w(void) { return 1; }\n"
                               "#else\n"
                               "static int u(void) { return 2; }\n"
                               "#endif\n"
                               "int use(int x) { return x; }\n",
                               CBM_LANG_C, "t", "clean.c");
    ASSERT_NOT_NULL(r);
    int use_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, "use") == 0)
            use_count++;
    }
    ASSERT_EQ(use_count, 1);
    cbm_free_result(r);
    PASS();
}

/* True when `qn` carries the token-joined spelling of the `box<int, 2>`
 * template-id that the preprocessed buffer used to produce. */
static bool qn_has_token_spaced_box(const char *qn) {
    return qn && (strstr(qn, "box <") || strstr(qn, "< int") || strstr(qn, "int ,"));
}

/* dotnet/runtime vxsort shape (src/coreclr/gc/vxsort/smallsort/
 * bitonic_sort.*.generated.h): methods of an explicit specialization
 * `template<> struct bitonic<int64_t, AVX2>` carry an attribute macro defined in
 * another header (INLINE / NOINLINE), so the raw parse has ERROR regions on the
 * method lines and the #961 rescue re-extracts them from the preprocessed
 * buffer. That buffer used to join every token with one space, spelling the
 * scope `box < int , 2 >` where the raw pass spells `box<int, 2>`; the QN dedup
 * (strcmp) missed, so every method got a second node and the CALLS split across
 * both. One definition, one spelling, on every path. */
TEST(extract_cpp_template_specialization_preprocessed_qn_single_spelling) {
    CBMFileResult *r = extract("#ifndef BOX_H\n"
                               "#define BOX_H\n"
                               "namespace ns {\n"
                               "template <typename T, int M> struct box {\n"
                               "    static void sort(T *p);\n"
                               "};\n"
                               "template<> struct box<int, 2> {\n"
                               "    static INLINE void first(int *p) { p[0] = 0; }\n"
                               "    static INLINE void second(int *p) { first(p); }\n"
                               "};\n"
                               "}\n"
                               "#endif\n",
                               CBM_LANG_CPP, "t", "box.h");
    ASSERT_NOT_NULL(r);
    int first_count = 0;
    int second_count = 0;
    const char *first_qn = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (qn_has_token_spaced_box(d->qualified_name)) {
            fprintf(stderr, "  [tmplqn] FAIL token-spaced def QN: %s\n", d->qualified_name);
        }
        ASSERT_FALSE(qn_has_token_spaced_box(d->qualified_name));
        if (d->name && strcmp(d->name, "first") == 0) {
            first_count++;
            first_qn = d->qualified_name;
        }
        if (d->name && strcmp(d->name, "second") == 0) {
            second_count++;
        }
    }
    ASSERT_EQ(first_count, 1);
    ASSERT_EQ(second_count, 1);
    ASSERT_NOT_NULL(first_qn);
    ASSERT_NOT_NULL(strstr(first_qn, "ns.box<int, 2>.first"));
    /* Call scopes and LSP-resolved endpoints name the same single spelling, so
     * no CALLS edge lands on (or starts from) a phantom second node. */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(qn_has_token_spaced_box(r->calls.items[i].enclosing_func_qn));
    }
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        ASSERT_FALSE(qn_has_token_spaced_box(rc->caller_qn));
        ASSERT_FALSE(qn_has_token_spaced_box(rc->callee_qn));
    }
    cbm_free_result(r);
    PASS();
}

/* Defs of `r` with this label, name and start line; `*qn` gets the last one's QN. */
static int count_defs_at(const CBMFileResult *r, const char *label, const char *name, uint32_t line,
                         const char **qn) {
    int n = 0;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && d->name && strcmp(d->label, label) == 0 && strcmp(d->name, name) == 0 &&
            d->start_line == line) {
            *qn = d->qualified_name;
            n++;
        }
    }
    return n;
}

/* A macro-generated struct body (the kernel's lib/tests/randstruct_kunit.c:
 * `struct s { DO_MANY_MEMBERS(m) };`, `struct t { mixed_members };`) opens a
 * raw ERROR region in which every later struct nests inside the broken one,
 * while the preprocessed parse gets them flat. The #961 rescue adopted the
 * flat copies next to the mis-nested raw ones: one definition, two QNs. The
 * flat copy replaces the raw one, and what sat under the raw QN (Fields, a
 * real nested struct, resolved member references) moves to the flat QN. The
 * body's `__aligned(16)` is unknown without the kernel headers, as in the
 * real file: a local error in the expanded parse that must not block it. */
TEST(extract_c_misnested_raw_struct_replaced_by_flat_copy) {
    CBMFileResult *r = extract("#define DO_MEMBERS(macro) macro(a) macro(b)\n"
                               "#define long_member(x) unsigned long x;\n"
                               "struct plain {\n"
                               "\tDO_MEMBERS(long_member)\n"
                               "};\n"
                               "\n"
                               "#define mixed_members \\\n"
                               "\tint a __aligned(16); \\\n"
                               "\tunion {       \\\n"
                               "\t\tchar c;   \\\n"
                               "\t\tlong g;   \\\n"
                               "\t};\n"
                               "\n"
                               "struct mixed_untouched {\n"
                               "\tmixed_members\n"
                               "};\n"
                               "\n"
                               "struct mixed_shuffled {\n"
                               "\tmixed_members\n"
                               "} __randomize_layout;\n"
                               "\n"
                               "struct contains_untouched {\n"
                               "\tint before;\n"
                               "\tstruct nested_real {\n"
                               "\t\tint deep;\n"
                               "\t} real;\n"
                               "\tstruct mixed_shuffled inner;\n"
                               "\tint after;\n"
                               "};\n"
                               "\n"
                               "static int helper(int x)\n"
                               "{\n"
                               "\treturn x + 1;\n"
                               "}\n"
                               "\n"
                               "static int check_layout(struct contains_untouched *c)\n"
                               "{\n"
                               "\treturn helper(c->before) + c->real.deep;\n"
                               "}\n",
                               CBM_LANG_C, "t", "mixed.c");
    ASSERT_NOT_NULL(r);
    static const struct {
        const char *label;
        const char *name;
        uint32_t line;
        const char *qn;
    } want[] = {
        {"Class", "mixed_shuffled", 18, "t.mixed.mixed_shuffled"},
        {"Class", "contains_untouched", 22, "t.mixed.contains_untouched"},
        {"Field", "before", 23, "t.mixed.contains_untouched.before"},
        {"Field", "after", 28, "t.mixed.contains_untouched.after"},
        /* A real nested struct keeps its real nesting. */
        {"Class", "nested_real", 24, "t.mixed.contains_untouched.nested_real"},
        {"Field", "deep", 25, "t.mixed.contains_untouched.nested_real.deep"},
        {"Function", "check_layout", 36, "t.mixed.check_layout"},
    };
    for (size_t i = 0; i < sizeof(want) / sizeof(want[0]); i++) {
        const char *qn = NULL;
        int n = count_defs_at(r, want[i].label, want[i].name, want[i].line, &qn);
        if (n != 1 || !qn || strcmp(qn, want[i].qn) != 0) {
            fprintf(stderr, "  [misnested] %s %s L%u: %d def(s), last QN %s (want one, %s)\n",
                    want[i].label, want[i].name, want[i].line, n, qn ? qn : "(none)", want[i].qn);
        }
        ASSERT_EQ(n, 1);
        ASSERT_STR_EQ(qn, want[i].qn);
    }
    /* Nothing is left on the mis-nested chain: no def, no call scope, no
     * resolved caller or member target. */
    static const char *const chain = "mixed_untouched.mixed_shuffled";
    for (int i = 0; i < r->defs.count; i++) {
        ASSERT_NULL(strstr(r->defs.items[i].qualified_name, chain));
    }
    int helper_calls = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        ASSERT_TRUE(!c->enclosing_func_qn || !strstr(c->enclosing_func_qn, chain));
        if (c->callee_name && strcmp(c->callee_name, "helper") == 0) {
            ASSERT_STR_EQ(c->enclosing_func_qn, "t.mixed.check_layout");
            helper_calls++;
        }
    }
    ASSERT_TRUE(helper_calls >= 1);
    int before_refs = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *c = &r->resolved_calls.items[i];
        ASSERT_TRUE(!c->caller_qn || !strstr(c->caller_qn, chain));
        ASSERT_TRUE(!c->callee_qn || !strstr(c->callee_qn, chain));
        if (c->callee_qn && strcmp(c->callee_qn, "t.mixed.contains_untouched.before") == 0) {
            before_refs++;
        }
    }
    ASSERT_TRUE(before_refs >= 1);
    cbm_free_result(r);
    PASS();
}

/* The #961 rescue recovers defs the raw pass LOST. When the expanded tree scopes
 * a def differently from the raw one, its QN differs although the raw pass
 * already extracted the very same definition (same label, name, line). Here a
 * namespace-opening macro defined in the file is an identifier to the raw parse
 * and `namespace inner {` to the expanded one; rapidjson reader.h hits the same
 * divergence on the `NumberStream<...>` specializations nested in GenericReader.
 * Adopting the expanded copy mints a second node for one definition: the raw
 * copy wins. */
TEST(extract_cpp_preprocessed_rescue_skips_raw_def_on_same_line) {
    CBMFileResult *r = extract("#define OPEN_NS namespace inner {\n"
                               "#define CLOSE_NS }\n"
                               "OPEN_NS\n"
                               "template <typename T, int M> struct box {};\n"
                               "template<> struct box<int, 2> {\n"
                               "    static INLINE void first(int *p) { p[0] = 0; }\n"
                               "};\n"
                               "CLOSE_NS\n",
                               CBM_LANG_CPP, "t", "ns.h");
    ASSERT_NOT_NULL(r);
    int first_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && strcmp(d->name, "first") == 0) {
            fprintf(stderr, "  [rescue-site] def first: %s line %u\n", d->qualified_name,
                    d->start_line);
            first_count++;
        }
    }
    ASSERT_EQ(first_count, 1);
    cbm_free_result(r);
    PASS();
}

/* The raw copy wins a same-site disagreement only while its QN is its own:
 * coreclr inc/holder.h's nested `class AddressInitHolder` loses its
 * `BaseWrapper` scope on the raw parse, and the raw parse also reads the
 * FORCEINLINE constructor as a file-scope Function of the same QN. Keeping the
 * raw Class there left no Class node at all (one node per QN); the correctly
 * scoped expanded copy must survive. */
TEST(extract_cpp_rescue_keeps_expanded_class_when_raw_qn_is_taken) {
    /* Minimized from holder.h (delta debugging against the rule with and
     * without this check). */
    CBMFileResult *r = extract(
        "class BaseWrapper : public BaseHolder<TYPE, BASE, DEFAULTVALUE, IS_NULL>\n"
        "{\n"
        "    class AddressInitHolder\n"
        "    {\n"
        "        FORCEINLINE AddressInitHolder(BaseWrapper<TYPE,BASE,DEFAULTVALUE,IS_NULL> &holder)\n"
        "        {\n"
        "            unknown = static_cast<IUnknown*>(m_holder.m_value);\n"
        "        }\n"
        "#if defined(FEATURE_COMINTEROP) && !defined(STRIKE)\n"
        "        FORCEINLINE operator IInspectable **()\n"
        "#endif // FEATURE_COMINTEROP\n"
        "    {\n"
        "    }\n"
        "    }\n",
        CBM_LANG_CPP, "t", "holder.h");
    ASSERT_NOT_NULL(r);
    bool scoped_class = false;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->name && strcmp(d->name, "AddressInitHolder") == 0) {
            fprintf(stderr, "  [rescue-taken] %s %s line %u\n", d->label ? d->label : "-",
                    d->qualified_name, d->start_line);
            if (d->label && strcmp(d->label, "Class") == 0 && d->qualified_name &&
                strstr(d->qualified_name, "BaseWrapper.AddressInitHolder") != NULL &&
                strstr(d->qualified_name, "AddressInitHolder.AddressInitHolder") == NULL) {
                scoped_class = true;
            }
        }
    }
    ASSERT_TRUE(scoped_class);
    cbm_free_result(r);
    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();
}

/* ── PR C1: C graph defects behind the C/Doxygen doc-link audit ──────── */

static const CBMDefinition *c1_def(CBMFileResult *r, const char *label, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && d->name && strcmp(d->label, label) == 0 && strcmp(d->name, name) == 0) {
            return d;
        }
    }
    return NULL;
}

/* Caller QN of the first raw-pass call to `callee`, or "" when there is none. */
static const char *c1_call_scope(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->callee_name && strcmp(c->callee_name, callee) == 0 &&
            c->source_origin == CBM_SOURCE_ORIGIN_RAW) {
            return c->enclosing_func_qn ? c->enclosing_func_qn : "";
        }
    }
    return "";
}

/* Caller QN of the first C-LSP resolution whose callee QN ends in ".<leaf>". */
static const char *c1_lsp_caller(CBMFileResult *r, const char *leaf) {
    size_t ll = strlen(leaf);
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        size_t cl = rc->callee_qn ? strlen(rc->callee_qn) : 0;
        if (cl > ll && rc->callee_qn[cl - ll - 1] == '.' &&
            strcmp(rc->callee_qn + cl - ll, leaf) == 0) {
            return rc->caller_qn ? rc->caller_qn : "";
        }
    }
    return "";
}

/* xxhash.h shape: `XXH_PUBLIC_API <RetT> name(...)` has one leading identifier more than
 * the grammar admits. tree-sitter-cpp (every .h is C++) recovers it as `RetT::name` with a
 * zero-width MISSING "::" (a Method of the return type), with a pointer return as
 * `RetT::*name` (no name at all: the function was dropped), or keeps RetT as the name and
 * puts the real one in an ERROR before the parameters. The implementation sits behind a
 * guard the preprocessed pass does not take, as in xxhash.h, so only the raw parse sees
 * it. Def QN, call-scope QN and C-LSP caller QN must all name the real function. */
static const char *C1_MACRO_PREFIX_SRC =
    "#if defined(XXH_IMPLEMENTATION)\n"
    "XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)\n"
    "{\n"
    "    XXH_free(statePtr);\n"
    "    return XXH_OK;\n"
    "}\n"
    "\n"
    "XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)\n"
    "{\n"
    "    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));\n"
    "}\n"
    "\n"
    "XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)\n"
    "{\n"
    "    return XXH32_endian_align(input, len, seed);\n"
    "}\n"
    "#endif\n";

TEST(extract_cpp_macro_prefixed_function_names_c1) {
    CBMFileResult *r = extract(C1_MACRO_PREFIX_SRC, CBM_LANG_CPP, "p", "xxhash.h");
    ASSERT_NOT_NULL(r);
    char want[256];

    const CBMDefinition *free_state = c1_def(r, "Function", "XXH32_freeState");
    ASSERT_NOT_NULL(free_state);
    ASSERT_EQ(count_defs_named(r, "Method", "XXH32_freeState"), 0);
    snprintf(want, sizeof(want), "%s.XXH32_freeState", r->module_qn);
    ASSERT_STR_EQ(free_state->qualified_name, want);
    ASSERT_STR_EQ(c1_call_scope(r, "XXH_free"), want);

    const CBMDefinition *create = c1_def(r, "Function", "XXH32_createState");
    ASSERT_NOT_NULL(create);
    ASSERT_EQ((int)create->start_line, 8);
    ASSERT_EQ((int)create->end_line, 11);
    ASSERT_NOT_NULL(create->signature);

    const CBMDefinition *xxh32 = c1_def(r, "Function", "XXH32");
    ASSERT_NOT_NULL(xxh32);
    ASSERT_FALSE(has_def_any(r, "XXH32_hash_t"));
    ASSERT_STR_EQ(c1_call_scope(r, "XXH32_endian_align"), xxh32->qualified_name);
    cbm_free_result(r);
    PASS();
}

/* The C-LSP walks declarators on its own (c_process_function); its caller QN must
 * name the recovered function too, or the exact-equality LSP join drops the
 * type-aware resolution of every call inside it (the call falls back to a textual
 * strategy). jemalloc-style prefix: not an export-macro candidate, so the
 * preprocessed pass keeps the same misparse and cannot mask the raw one. */
TEST(extract_cpp_macro_prefixed_lsp_caller_c1) {
    CBMFileResult *r = extract("static int je_helper(int v) { return v; }\n"
                               "JE_ALWAYS_INLINE je_errorcode je_reset(je_state_t *st)\n"
                               "{\n"
                               "    return je_helper(1);\n"
                               "}\n"
                               "JE_ALWAYS_INLINE je_hash_t je_hash (const void *in, size_t n)\n"
                               "{\n"
                               "    return je_helper(2);\n"
                               "}\n",
                               CBM_LANG_CPP, "p", "je.h");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *reset = c1_def(r, "Function", "je_reset");
    const CBMDefinition *hash = c1_def(r, "Function", "je_hash");
    ASSERT_NOT_NULL(reset);
    ASSERT_NOT_NULL(hash);
    int from_reset = 0;
    int from_hash = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const char *caller = r->resolved_calls.items[i].caller_qn;
        from_reset += caller && strcmp(caller, reset->qualified_name) == 0;
        from_hash += caller && strcmp(caller, hash->qualified_name) == 0;
    }
    ASSERT_GT(from_reset, 0);
    ASSERT_GT(from_hash, 0);
    ASSERT_STR_EQ(c1_lsp_caller(r, "je_helper"), reset->qualified_name);
    cbm_free_result(r);
    PASS();
}

/* The same recovery in the C grammar (lua's LUA_API): named after the return type
 * before. A function-like macro invocation that only looks like a declarator
 * (`... TEST_BEGIN (test_alignment) {`) has an untyped "parameter" no definition can
 * have, so its macro name is never adopted as the function name. */
TEST(extract_c_macro_prefixed_function_name_c1) {
    CBMFileResult *r =
        extract("#if defined(LUA_CORE)\n"
                "LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {\n"
                "  lua_CFunction old = G(L)->panic;\n"
                "  return old;\n"
                "}\n"
                "\n"
                "XXH_TEST_API XXH32_hash_t TEST_BEGIN (test_alignment) {\n"
                "  helper(1);\n"
                "}\n"
                "#endif\n",
                CBM_LANG_C, "p", "lapi.c");
    ASSERT_NOT_NULL(r);
    ASSERT_NOT_NULL(c1_def(r, "Function", "lua_atpanic"));
    ASSERT_FALSE(has_def_any(r, "lua_CFunction"));
    ASSERT_FALSE(has_def_any(r, "TEST_BEGIN"));
    cbm_free_result(r);
    PASS();
}

/* `struct X` / `enum X` / `class X` without a body is a reference, not a definition:
 * no Class/Enum def, so nothing competes with the real definition for its QN (a later
 * or smaller-path reference used to take the node: curl 132 structs, kernel
 * task_struct, redis redisServer) and no phantom type node appears in every file that
 * merely mentions the type (`struct timeval`). */
TEST(extract_c_tag_reference_is_not_a_definition_c1) {
    CBMFileResult *r = extract("struct node {\n"
                               "    int value;\n"
                               "    struct node *next;\n"
                               "};\n"
                               "struct node *head;\n"
                               "struct timeval tv;\n"
                               "enum color { RED, GREEN };\n"
                               "enum color paint(enum color c);\n"
                               "void walk(struct node *n);\n"
                               "struct opaque;\n",
                               CBM_LANG_C, "p", "list.c");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Class", "node"), 1);
    const CBMDefinition *node = c1_def(r, "Class", "node");
    ASSERT_EQ((int)node->start_line, 1);
    ASSERT_EQ((int)node->end_line, 4);
    ASSERT_EQ(count_defs_named(r, "Enum", "color"), 1);
    ASSERT_EQ((int)c1_def(r, "Enum", "color")->start_line, 7);
    ASSERT_FALSE(has_def_any(r, "timeval"));
    ASSERT_FALSE(has_def_any(r, "opaque"));
    cbm_free_result(r);

    /* .h is parsed as C++: a forward declaration before the definition. */
    r = extract("class Widget;\n"
                "struct Config;\n"
                "Widget *make_widget(struct Config *cfg);\n"
                "class Widget {\n"
                "    int size;\n"
                "};\n",
                CBM_LANG_CPP, "p", "widget.h");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Class", "Widget"), 1);
    ASSERT_EQ((int)c1_def(r, "Class", "Widget")->start_line, 4);
    ASSERT_FALSE(has_def_any(r, "Config"));
    cbm_free_result(r);
    PASS();
}

/* tree-sitter can give up on a whole region and leave the definition head as loose
 * ERROR tokens (kernel include/linux/sched.h: `struct task_struct {` at 826 is never a
 * struct_specifier). Its only nodes were then the references (642 won); with
 * references no longer minting defs the head itself must be recovered, spanning to
 * its matching brace counted over the first branch of each #if group. */
TEST(extract_c_struct_head_in_error_region_recovered_c1) {
    CBMFileResult *r = extract("#ifndef SCHED_H\n"
                               "#define SCHED_H\n"
                               "struct task_struct;\n"
                               "typedef struct task_struct *(*pick_f)(int cpu);\n"
                               "\n"
                               "/* Per-task scheduler state. */\n"
                               "struct task_struct {\n"
                               "\tint state;\n"
                               "#ifdef CONFIG_SMP\n"
                               "\tstruct {\n"
                               "#else\n"
                               "\tunion {\n"
                               "#endif\n"
                               "\t\tint on_cpu;\n"
                               "\t};\n"
                               "\tint prio;\n"
                               "};\n"
                               "#endif\n",
                               CBM_LANG_CPP, "p", "sched.h");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Class", "task_struct"), 1);
    const CBMDefinition *ts = c1_def(r, "Class", "task_struct");
    ASSERT_EQ((int)ts->start_line, 7);
    ASSERT_EQ((int)ts->end_line, 17);
    ASSERT_NOT_NULL(c1_def(r, "Type", "pick_f"));
    cbm_free_result(r);
    PASS();
}

/* A stray `;` after an if-block leaves the following `else if (...) {...}` without its
 * `if`; inside a function the raw parse already lost (whole-file guard + split brace),
 * error recovery reads it as a DEFINITION: type `else`, name `if`. A C keyword is never
 * a function name (curl lib/vtls/openssl.c:4242, redis deps/tre/lib/tre-parse.c:1315). */
TEST(extract_c_keyword_is_never_a_function_name_c1) {
    CBMFileResult *r = extract("#ifdef USE_OPENSSL\n"
                               "static int check(int lib, int reason)\n"
                               "{\n"
                               "  int result = 0;\n"
                               "  if(lib == 1) {\n"
                               "#ifndef HAVE_BORINGSSL_LIKE\n"
                               "    result = 1; {\n"
                               "#else\n"
                               "    result = 2; {\n"
                               "#endif\n"
                               "  }\n"
                               "  };\n"
                               "  else if(reason == 2) {\n"
                               "    result = trace_retry(reason);\n"
                               "  }\n"
                               "  return result;\n"
                               "}\n"
                               "#endif\n",
                               CBM_LANG_C, "p", "openssl.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(has_def_any(r, "if"));
    ASSERT_TRUE(has_call(r, "trace_retry"));
    cbm_free_result(r);
    PASS();
}

/* Preprocessor-split code the raw parse cannot read: `#ifndef X (a)) { #else (b)) {
 * #endif` leaves an extra `{`, the file-level ERROR swallows the function header and
 * the function gets no node. The #961 rescue re-parses the preprocessed text, but a
 * whole-file `#ifdef USE_OPENSSL` with no build defines leaves it nothing to parse.
 * The first-branch projection restores it (curl ossl_connect_step2,
 * Curl_ossl_ctx_init, mbed_configure_ssl, ...: all 11 curl misses). */
TEST(extract_c_function_lost_to_split_branches_restored_c1) {
    CBMFileResult *r = extract("#ifdef USE_OPENSSL\n"
                               "static int ossl_step(int lib, int reason)\n"
                               "{\n"
                               "  int result = 0;\n"
                               "  if(lib == 1) {\n"
                               "    result = 1;\n"
                               "  }\n"
                               "  else if((lib == 2) &&\n"
                               "#ifndef HAVE_BORINGSSL_LIKE\n"
                               "          (reason == 3)) {\n"
                               "#else\n"
                               "          (reason == 4)) {\n"
                               "#endif\n"
                               "    result = trace_retry(reason);\n"
                               "  }\n"
                               "  return result;\n"
                               "}\n"
                               "\n"
                               "int ossl_after(void)\n"
                               "{\n"
                               "  return ossl_step(1, 2);\n"
                               "}\n"
                               "#endif\n",
                               CBM_LANG_C, "p", "openssl.c");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *step = c1_def(r, "Function", "ossl_step");
    ASSERT_NOT_NULL(step);
    ASSERT_EQ((int)step->start_line, 2);
    ASSERT_EQ((int)step->end_line, 17);
    ASSERT_EQ(count_defs_named(r, "Function", "ossl_after"), 1);
    cbm_free_result(r);
    PASS();
}

/* C typedefs carry no `name` field (the alias lives in the declarators), so no typedef
 * ever became a node and an anonymous `typedef struct {...} Name;` lost its fields and
 * enum constants too. xxhash: `@ref XXH32_state_t` could only resolve to the namespace
 * rename macro `#define XXH32_state_t XXH_IPREF(XXH32_state_t)`. */
TEST(extract_c_typedef_names_are_definitions_c1) {
    CBMFileResult *r = extract("typedef struct XXH32_state_s XXH32_state_t;\n"
                               "typedef struct {\n"
                               "    unsigned char digest[4];\n"
                               "} XXH32_canonical_t;\n"
                               "typedef enum { XXH_OK = 0, XXH_ERROR = 1 } XXH_errorcode;\n"
                               "typedef unsigned int XXH32_hash_t;\n"
                               "typedef int (*cmp_fn)(const void *a, const void *b);\n"
                               "typedef struct opaque_s opaque_s;\n"
                               "typedef struct node node;\n"
                               "struct node { int v; };\n"
                               "typedef struct named_s { int y; } named_t;\n"
                               "typedef struct same { int z; } same;\n",
                               CBM_LANG_C, "p", "xxhash.c");
    ASSERT_NOT_NULL(r);
    char want[256];
    ASSERT_NOT_NULL(c1_def(r, "Type", "XXH32_state_t"));
    const CBMDefinition *canon = c1_def(r, "Class", "XXH32_canonical_t");
    ASSERT_NOT_NULL(canon);
    ASSERT_EQ((int)canon->start_line, 2);
    snprintf(want, sizeof(want), "%s.XXH32_canonical_t.digest", r->module_qn);
    ASSERT_TRUE(has_def_qn(r, want));
    ASSERT_NOT_NULL(c1_def(r, "Enum", "XXH_errorcode"));
    snprintf(want, sizeof(want), "%s.XXH_OK", r->module_qn);
    ASSERT_TRUE(has_def_qn(r, want));
    ASSERT_NOT_NULL(c1_def(r, "Type", "XXH32_hash_t"));
    ASSERT_NOT_NULL(c1_def(r, "Type", "cmp_fn"));
    /* identity alias of an incomplete struct: often the only declaration of an
     * opaque handle type */
    ASSERT_NOT_NULL(c1_def(r, "Type", "opaque_s"));
    /* identity alias of a struct defined in the same file: the definition owns it */
    ASSERT_EQ(count_defs_named(r, "Class", "node"), 1);
    ASSERT_EQ(count_defs_named(r, "Type", "node"), 0);
    ASSERT_NOT_NULL(c1_def(r, "Class", "named_s"));
    ASSERT_NOT_NULL(c1_def(r, "Type", "named_t"));
    ASSERT_EQ(count_defs_named(r, "Class", "same"), 1);
    ASSERT_EQ(count_defs_named(r, "Type", "same"), 0);
    cbm_free_result(r);
    PASS();
}

static const CBMDefinition *c1_def_qn(CBMFileResult *r, const char *qn) {
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->qualified_name && strcmp(d->qualified_name, qn) == 0) {
            return d;
        }
    }
    return NULL;
}

static bool qn_ends_with(const CBMDefinition *d, const char *tail) {
    size_t n = d && d->qualified_name ? strlen(d->qualified_name) : 0;
    size_t t = strlen(tail);
    return n >= t && strcmp(d->qualified_name + n - t, tail) == 0;
}

/* A field and a same-named method of one class body would share one qualified
 * name (one node per QN): the field is fenced `<Owner>.<name>#field` and the
 * method keeps the plain name. A field without a namesake keeps its name, and
 * so does a nested class's field named like a method of the outer class. */
TEST(field_named_like_method_is_fenced) {
    CBMFileResult *r = extract("package demo;\npublic class Starter {\n"
                               "    private String executable;\n"
                               "    private String dir;\n"
                               "    public Starter executable(String p) { return this; }\n"
                               "    public void size() {}\n"
                               "    static class Inner { int size; }\n}\n",
                               CBM_LANG_JAVA, "t", "Starter.java");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *field = c1_def(r, "Field", "executable");
    const CBMDefinition *method = c1_def(r, "Method", "executable");
    ASSERT_NOT_NULL(field);
    ASSERT_NOT_NULL(method);
    ASSERT_TRUE(qn_ends_with(field, "Starter.executable#field"));
    ASSERT_TRUE(qn_ends_with(method, "Starter.executable"));
    ASSERT_TRUE(qn_ends_with(c1_def(r, "Field", "dir"), "Starter.dir"));
    ASSERT_TRUE(qn_ends_with(c1_def(r, "Field", "size"), "Inner.size"));
    cbm_free_result(r);
    PASS();
}

/* The def with this label and name that starts on `line`. */
static const CBMDefinition *c1_def_at(CBMFileResult *r, const char *label, const char *name,
                                      int line) {
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && d->name && strcmp(d->label, label) == 0 && strcmp(d->name, name) == 0 &&
            (int)d->start_line == line) {
            return d;
        }
    }
    return NULL;
}

/* A preprocessor macro's QN is `<module>.<NAME>#macro` (CBM_MACRO_QN_SUFFIX); name and
 * label stay. C keeps macros apart from ordinary identifiers, so a macro and the
 * function, type or enumerator of the same name are two entities and need two QNs: the
 * namespace rename `#define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)` held the QN of the
 * function XXH32 (110 of 174 audited xxhash doc links ended on such a macro), and the
 * #else stand-in `#define match_proxy(a) 1` replaced the function it stands in for
 * (curl, 41 functions). Every language routed through the #define path is covered,
 * and in each of them a macro defined twice carries `variants`: the namespace and the
 * list follow one language predicate. */
TEST(extract_c_macro_qn_is_fenced_c1) {
    static const struct {
        CBMLanguage lang;
        const char *file;
    } cases[] = {{CBM_LANG_C, "cfg.c"},       {CBM_LANG_CPP, "cfg.h"},
                 {CBM_LANG_OBJC, "cfg.m"},    {CBM_LANG_CUDA, "cfg.cu"},
                 {CBM_LANG_GLSL, "cfg.glsl"}, {CBM_LANG_ISPC, "cfg.ispc"}};
    for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
        CBMFileResult *r = extract("#define MAX_LEN 10\n"
                                   "#define SQUARE(x) ((x) * (x))\n"
                                   "#define MAX_LEN 20\n",
                                   cases[i].lang, "p", cases[i].file);
        ASSERT_NOT_NULL(r);
        char want[256];
        const CBMDefinition *max_len = c1_def(r, "Macro", "MAX_LEN");
        ASSERT_NOT_NULL(max_len);
        snprintf(want, sizeof(want), "%s.MAX_LEN" CBM_MACRO_QN_SUFFIX, r->module_qn);
        ASSERT_STR_EQ(max_len->qualified_name, want);
        const CBMDefinition *square = c1_def(r, "Macro", "SQUARE");
        ASSERT_NOT_NULL(square);
        snprintf(want, sizeof(want), "%s.SQUARE#macro", r->module_qn);
        ASSERT_STR_EQ(square->qualified_name, want);
        /* the plain QN is free for a definition of that name */
        snprintf(want, sizeof(want), "%s.MAX_LEN", r->module_qn);
        ASSERT_NULL(c1_def_qn(r, want));
        const CBMDefinition *redefined = c1_def_at(r, "Macro", "MAX_LEN", 3);
        ASSERT_NOT_NULL(redefined);
        ASSERT_NOT_NULL(redefined->variants);
        cbm_free_result(r);
    }

    CBMFileResult *r = extract("#ifdef USE_PROXY\n"
                               "int match_proxy(int a) { return a; }\n"
                               "#else\n"
                               "#define match_proxy(a) 1\n"
                               "#endif\n",
                               CBM_LANG_C, "p", "proxy.c");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *fn = c1_def(r, "Function", "match_proxy");
    const CBMDefinition *mac = c1_def(r, "Macro", "match_proxy");
    ASSERT_NOT_NULL(fn);
    ASSERT_NOT_NULL(mac);
    char want[256];
    snprintf(want, sizeof(want), "%s.match_proxy", r->module_qn);
    ASSERT_STR_EQ(fn->qualified_name, want);
    snprintf(want, sizeof(want), "%s.match_proxy#macro", r->module_qn);
    ASSERT_STR_EQ(mac->qualified_name, want);
    cbm_free_result(r);
    PASS();
}

/* The enumerators of a C enum live in the scope that holds the enum, so their QN is
 * `<scope>.<CONST>`: the enum's own name is not a segment. That is how a reference
 * spells them (`XXH_OK`, never `XXH_errorcode.XXH_OK`), and it gives the constants of
 * an anonymous enum, which has no name to nest under, a QN at all. `parent_class`
 * (the enum's QN) keeps the membership; an anonymous enum has no node to point at. */
TEST(extract_c_enumerators_are_flat_c1) {
    CBMFileResult *r = extract("enum color { RED, GREEN = 2 };\n"
                               "enum { ANON_A, ANON_B };\n"
                               "typedef enum { TD_A, TD_B } td_t;\n",
                               CBM_LANG_C, "p", "e.c");
    ASSERT_NOT_NULL(r);
    char qn[256];
    char parent[256];

    snprintf(qn, sizeof(qn), "%s.RED", r->module_qn);
    snprintf(parent, sizeof(parent), "%s.color", r->module_qn);
    const CBMDefinition *red = c1_def_qn(r, qn);
    ASSERT_NOT_NULL(red);
    ASSERT_STR_EQ(red->label, "Variable");
    ASSERT_NOT_NULL(red->parent_class);
    ASSERT_STR_EQ(red->parent_class, parent);
    snprintf(qn, sizeof(qn), "%s.GREEN", r->module_qn);
    ASSERT_NOT_NULL(c1_def_qn(r, qn));
    snprintf(qn, sizeof(qn), "%s.color.RED", r->module_qn);
    ASSERT_NULL(c1_def_qn(r, qn));
    ASSERT_NOT_NULL(c1_def_qn(r, parent)); /* the Enum itself keeps its QN */

    snprintf(qn, sizeof(qn), "%s.ANON_A", r->module_qn);
    const CBMDefinition *anon = c1_def_qn(r, qn);
    ASSERT_NOT_NULL(anon);
    ASSERT_STR_EQ(anon->label, "Variable");
    ASSERT_NULL(anon->parent_class);
    snprintf(qn, sizeof(qn), "%s.ANON_B", r->module_qn);
    ASSERT_NOT_NULL(c1_def_qn(r, qn));

    snprintf(qn, sizeof(qn), "%s.TD_A", r->module_qn);
    snprintf(parent, sizeof(parent), "%s.td_t", r->module_qn);
    const CBMDefinition *td = c1_def_qn(r, qn);
    ASSERT_NOT_NULL(td);
    ASSERT_NOT_NULL(td->parent_class);
    ASSERT_STR_EQ(td->parent_class, parent);
    ASSERT_EQ(count_defs_named(r, "Variable", "TD_A"), 1);
    cbm_free_result(r);
    PASS();
}

/* C++: an unscoped enum's enumerators belong to the enclosing scope (module, namespace
 * or class), whatever nesting holds the enum; `enum class` and `enum struct` are
 * scopes of their own and keep `<Enum>.<CONST>`. */
TEST(extract_cpp_enum_scoping_c1) {
    CBMFileResult *r = extract("enum Color { RED, GREEN };\n"
                               "namespace gfx {\n"
                               "enum Blend { ADD, MULTIPLY };\n"
                               "class Brush {\n"
                               "public:\n"
                               "    enum Shape { ROUND, SQUARE };\n"
                               "};\n"
                               "}\n"
                               "enum class Mode { FAST, SLOW };\n"
                               "enum struct Level { LOW, HIGH };\n",
                               CBM_LANG_CPP, "p", "shapes.hpp");
    ASSERT_NOT_NULL(r);
    static const struct {
        const char *qn_tail;
        const char *parent_tail;
    } want[] = {{"RED", "Color"},
                {"GREEN", "Color"},
                {"gfx.ADD", "gfx.Blend"},
                {"gfx.MULTIPLY", "gfx.Blend"},
                {"gfx.Brush.ROUND", "gfx.Brush.Shape"},
                {"gfx.Brush.SQUARE", "gfx.Brush.Shape"},
                {"Mode.FAST", "Mode"},
                {"Mode.SLOW", "Mode"},
                {"Level.LOW", "Level"},
                {"Level.HIGH", "Level"}};
    for (size_t i = 0; i < sizeof(want) / sizeof(want[0]); i++) {
        char qn[256];
        char parent[256];
        snprintf(qn, sizeof(qn), "%s.%s", r->module_qn, want[i].qn_tail);
        snprintf(parent, sizeof(parent), "%s.%s", r->module_qn, want[i].parent_tail);
        const CBMDefinition *d = c1_def_qn(r, qn);
        if (!d) {
            fprintf(stderr, "  [c1] no def with QN %s\n", qn);
        }
        ASSERT_NOT_NULL(d);
        ASSERT_STR_EQ(d->label, "Variable");
        ASSERT_NOT_NULL(d->parent_class);
        ASSERT_STR_EQ(d->parent_class, parent);
    }
    char qn[256];
    snprintf(qn, sizeof(qn), "%s.Color.RED", r->module_qn);
    ASSERT_NULL(c1_def_qn(r, qn));
    snprintf(qn, sizeof(qn), "%s.FAST", r->module_qn);
    ASSERT_NULL(c1_def_qn(r, qn));
    cbm_free_result(r);
    PASS();
}

/* A named and an anonymous enum inside a struct, and an anonymous one inside a union:
 * one C-looking source, read under each C-family language by the two tests below. */
static const char *const C1_ENUM_IN_STRUCT_SRC = "struct conn {\n"
                                                 "    enum state { ST_IDLE, ST_BUSY } st;\n"
                                                 "    enum { KIND_A, KIND_B } kind;\n"
                                                 "    int fd;\n"
                                                 "};\n"
                                                 "union box {\n"
                                                 "    enum { BOX_A, BOX_B } tag;\n"
                                                 "    int v;\n"
                                                 "};\n";

/* Is `<module>[.<scope>].<name>` the ONE Variable def of that name, with parent_class
 * `<module>.<parent_tail>` (NULL: no parent_class)? */
static bool c1_enumerator_at(CBMFileResult *r, const char *scope, const char *name,
                             const char *parent_tail) {
    char qn[256];
    snprintf(qn, sizeof(qn), "%s%s%s.%s", r->module_qn, scope[0] ? "." : "", scope, name);
    const CBMDefinition *d = c1_def_qn(r, qn);
    if (!d || !d->label || strcmp(d->label, "Variable") != 0 ||
        count_defs_named(r, "Variable", name) != 1) {
        const CBMDefinition *other = c1_def(r, "Variable", name);
        fprintf(stderr, "  [c1] want the one Variable %s, the Variable of that name is %s\n", qn,
                other ? other->qualified_name : "(none)");
        return false;
    }
    if (!parent_tail) {
        return d->parent_class == NULL;
    }
    char parent[256];
    snprintf(parent, sizeof(parent), "%s.%s", r->module_qn, parent_tail);
    return d->parent_class && strcmp(d->parent_class, parent) == 0;
}

/* C has no struct scope for ordinary identifiers: an enum declared inside a struct or
 * union puts its enumerators in the scope around it, and the code names them
 * unqualified (curl lib/cf-h1-proxy.c: `ts->keepon = KEEPON_CONNECT;`). In C and
 * Objective-C the struct is therefore no segment of a flat enumerator's QN, named
 * enum or anonymous; `parent_class` still names a named enum. */
TEST(extract_c_enum_inside_struct_is_file_scope_c1) {
    static const struct {
        CBMLanguage lang;
        const char *file;
    } cases[] = {{CBM_LANG_C, "link.c"}, {CBM_LANG_OBJC, "link.m"}};
    for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
        CBMFileResult *r = extract(C1_ENUM_IN_STRUCT_SRC, cases[i].lang, "p", cases[i].file);
        ASSERT_NOT_NULL(r);
        ASSERT_TRUE(c1_enumerator_at(r, "", "ST_IDLE", "conn.state"));
        ASSERT_TRUE(c1_enumerator_at(r, "", "ST_BUSY", "conn.state"));
        ASSERT_TRUE(c1_enumerator_at(r, "", "KIND_A", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "", "KIND_B", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "", "BOX_A", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "", "BOX_B", NULL));
        cbm_free_result(r);
    }
    PASS();
}

/* C++ does scope them: `conn::ST_IDLE`. The enclosing class stays the scope in C++ and
 * CUDA -- and so in every .h, which is parsed as C++ -- for the same source. This pins
 * the other side of the rule above: the C treatment must not reach C++. */
TEST(extract_cpp_enum_inside_class_keeps_class_scope_c1) {
    static const struct {
        CBMLanguage lang;
        const char *file;
    } cases[] = {{CBM_LANG_CPP, "link.h"}, {CBM_LANG_CUDA, "link.cu"}};
    for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
        CBMFileResult *r = extract(C1_ENUM_IN_STRUCT_SRC, cases[i].lang, "p", cases[i].file);
        ASSERT_NOT_NULL(r);
        ASSERT_TRUE(c1_enumerator_at(r, "conn", "ST_IDLE", "conn.state"));
        ASSERT_TRUE(c1_enumerator_at(r, "conn", "ST_BUSY", "conn.state"));
        ASSERT_TRUE(c1_enumerator_at(r, "conn", "KIND_A", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "conn", "KIND_B", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "box", "BOX_A", NULL));
        ASSERT_TRUE(c1_enumerator_at(r, "box", "BOX_B", NULL));
        cbm_free_result(r);
    }
    PASS();
}

/* A macro inside an enumerator list is not enumerator grammar; the parser keeps every
 * bare identifier it can as an `enumerator` and wraps the rest in ERROR nodes. curl.h
 * declares its options as `CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2),`: the
 * second argument came back as a constant 115 times and, flattened, took the plain QN
 * of the macro `CURLOPTTYPE_LONG`. `X CURL_DEPRECATED(7.55.0, "Use Y") = BASE + 16,`
 * turned BASE and the words of the message into constants. Only the enumerator that
 * opens a slot is a constant; the comment above the macro call documents it. */
TEST(extract_c_enum_macro_wrapped_list_c1) {
    CBMFileResult *r = extract("typedef enum {\n"
                               "  /* doc of the first option */\n"
                               "  OPT(OPT_FIRST, TYPE_LONG, 1),\n"
                               "  OPT(OPT_SECOND, TYPE_STRING, 2),\n"
                               "  OPT_THIRD DEPRECATED(1.0, \"Use OPT_FIRST instead\")\n"
                               "      = BASE_LONG + 3,\n"
                               "  OPT_LAST\n"
                               "} option_t;\n",
                               CBM_LANG_C, "p", "opts.c");
    ASSERT_NOT_NULL(r);
    static const char *const real[] = {"OPT_FIRST", "OPT_SECOND", "OPT_THIRD", "OPT_LAST"};
    for (size_t i = 0; i < sizeof(real) / sizeof(real[0]); i++) {
        ASSERT_EQ(count_defs_named(r, "Variable", real[i]), 1);
    }
    static const char *const bogus[] = {"TYPE_LONG", "TYPE_STRING", "BASE_LONG",
                                        "Use",       "instead",     "OPT"};
    for (size_t i = 0; i < sizeof(bogus) / sizeof(bogus[0]); i++) {
        ASSERT_EQ(count_defs_named(r, "Variable", bogus[i]), 0);
    }
    const CBMDefinition *first = c1_def(r, "Variable", "OPT_FIRST");
    ASSERT_NOT_NULL(first->docstring);
    ASSERT_NOT_NULL(strstr(first->docstring, "doc of the first option"));
    ASSERT_NULL(c1_def(r, "Variable", "OPT_SECOND")->docstring);
    cbm_free_result(r);
    PASS();
}

/* One file may define a QN several times under one label: both branches of an #if, a
 * macro redefined per platform. The graph keeps one node per QN (the last by start
 * line), and before this the other definitions left no trace (curl 123 groups, redis
 * 87). The definition the graph keeps carries `variants`: every span of the group,
 * the kept one included, sorted by start line. A name defined once carries nothing. */
TEST(extract_c_variants_lists_same_file_duplicates_c1) {
    CBMFileResult *r = extract("#if A\n"
                               "int pick(int a) { return a; }\n"
                               "#else\n"
                               "int pick(int a) {\n"
                               "    return a + 1;\n"
                               "}\n"
                               "#endif\n"
                               "#ifdef B\n"
                               "#define LIMIT 1\n"
                               "#else\n"
                               "#define LIMIT 2\n"
                               "#endif\n"
                               "int once(void) { return 0; }\n",
                               CBM_LANG_C, "p", "v.c");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Function", "pick"), 2);
    const CBMDefinition *kept = c1_def_at(r, "Function", "pick", 4);
    const CBMDefinition *other = c1_def_at(r, "Function", "pick", 2);
    ASSERT_NOT_NULL(kept);
    ASSERT_NOT_NULL(other);
    ASSERT_NOT_NULL(kept->variants);
    ASSERT_STR_EQ(kept->variants, "[{\"file_path\":\"v.c\",\"start_line\":2,\"end_line\":2},"
                                  "{\"file_path\":\"v.c\",\"start_line\":4,\"end_line\":6}]");
    ASSERT_NULL(other->variants); /* one carrier per group: the node the graph keeps */

    const CBMDefinition *lim_a = c1_def_at(r, "Macro", "LIMIT", 9);
    const CBMDefinition *lim_b = c1_def_at(r, "Macro", "LIMIT", 11);
    ASSERT_NOT_NULL(lim_a);
    ASSERT_NOT_NULL(lim_b);
    char want[256];
    snprintf(want, sizeof(want),
             "[{\"file_path\":\"v.c\",\"start_line\":%u,\"end_line\":%u},"
             "{\"file_path\":\"v.c\",\"start_line\":%u,\"end_line\":%u}]",
             lim_a->start_line, lim_a->end_line, lim_b->start_line, lim_b->end_line);
    ASSERT_NOT_NULL(lim_b->variants);
    ASSERT_STR_EQ(lim_b->variants, want);
    ASSERT_NULL(lim_a->variants);

    ASSERT_NULL(c1_def(r, "Function", "once")->variants);
    cbm_free_result(r);
    PASS();
}

/* `variants` describes conditional compilation, so only the C-preprocessor languages
 * get it (cbm_is_c_preprocessor_lang, the six of the test above). A repeated QN
 * elsewhere is another matter: a JSON file repeats one key name thousands of times
 * (redis src/commands: 1,618 nodes, one of them with a 75-span list), a Python module
 * may rebind a function. Both fixtures DO repeat a (QN, label) on DIFFERENT lines
 * (two defs on one span count as one and would get no list anyway), which is asserted
 * so the guard cannot go inert. */
TEST(extract_variants_only_in_c_preprocessor_languages_c1) {
    static const struct {
        CBMLanguage lang;
        const char *file;
        const char *src;
    } cases[] = {
        {CBM_LANG_JSON, "cmd.json", "{\n  \"a\": {\"name\": 1},\n  \"b\": {\"name\": 2}\n}\n"},
        {CBM_LANG_PYTHON, "mod.py",
         "def pick(a):\n    return a\n\n\ndef pick(a):\n    return a + 1\n"},
    };
    for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
        CBMFileResult *r = extract(cases[i].src, cases[i].lang, "p", cases[i].file);
        ASSERT_NOT_NULL(r);
        int listed = 0;
        bool distinct_lines = false;
        for (int d = 0; d < r->defs.count; d++) {
            const CBMDefinition *a = &r->defs.items[d];
            listed += a->variants != NULL;
            for (int e = 0; a->qualified_name && a->label && e < d; e++) {
                const CBMDefinition *b = &r->defs.items[e];
                distinct_lines =
                    distinct_lines ||
                    (b->qualified_name && b->label &&
                     strcmp(a->qualified_name, b->qualified_name) == 0 &&
                     strcmp(a->label, b->label) == 0 && a->start_line != b->start_line);
            }
        }
        if (listed != 0 || !distinct_lines) {
            fprintf(stderr,
                    "  [c1-guard] %s: defs with variants=%d, repeated on distinct lines=%d\n",
                    cases[i].file, listed, distinct_lines);
        }
        ASSERT_TRUE(distinct_lines);
        ASSERT_EQ(listed, 0);
        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();
}

/* The call to `callee` on source line `line`, or NULL. */
static const CBMCall *call_at_line(CBMFileResult *r, const char *callee, int line) {
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *c = &r->calls.items[i];
        if (c->start_line == line && c->callee_name && strcmp(c->callee_name, callee) == 0) {
            return c;
        }
    }
    return NULL;
}

/* #946: ReGameDLL_CS defines its hookable methods as
 * `void CBasePlayer::__API_HOOK(ReloadWeapons)(...)`, a function-like macro in
 * the declarator (`#define __API_HOOK(fname) fname`, from a header). The grammar
 * nests that macro call as a function_declarator directly inside the definition's
 * own function_declarator, and the declarator walk named the definition after the
 * macro: every hook of a class collapsed into one Method `__API_HOOK`, calls in
 * each body were sourced to whichever hook was minted last, and no caller of
 * ReloadWeapons could reach it. The macro lives in a header here, as it does in
 * ReGameDLL, so the preprocessed second pass cannot expand it either. */
TEST(extract_cpp_macro_wrapped_declarator_names_def_issue946) {
    CBMFileResult *r = extract("#include \"precompiled.h\"\n"                            /* 1 */
                               "void helper();\n"                                        /* 2 */
                               "class CBasePlayer {\n"                                   /* 3 */
                               "public:\n"                                               /* 4 */
                               "    void ReloadWeapons(int slot);\n"                     /* 5 */
                               "    void Spawn();\n"                                     /* 6 */
                               "};\n"                                                    /* 7 */
                               "void CBasePlayer::__API_HOOK(ReloadWeapons)(int slot)\n" /* 8 */
                               "{\n"                                                     /* 9 */
                               "    helper();\n"                                         /* 10 */
                               "}\n"                                                     /* 11 */
                               "void EXT_FUNC CBasePlayer::__API_HOOK(Spawn)()\n"        /* 12 */
                               "{\n"                                                     /* 13 */
                               "    ReloadWeapons(0);\n"                                 /* 14 */
                               "}\n"                                                     /* 15 */
                               "void EXT_FUNC __API_HOOK(PM_Move)(int server)\n"         /* 16 */
                               "{\n"                                                     /* 17 */
                               "    helper();\n"                                         /* 18 */
                               "}\n",                                                    /* 19 */
                               CBM_LANG_CPP, "p", "player.cpp");
    ASSERT_NOT_NULL(r);
    /* One definition per hook, named after the macro argument. */
    ASSERT_EQ(count_defs_named(r, "Method", "__API_HOOK"), 0);
    ASSERT_EQ(count_defs_named(r, "Function", "__API_HOOK"), 0);
    ASSERT_TRUE(has_def_qn(r, "p.player.CBasePlayer.ReloadWeapons"));
    ASSERT_TRUE(has_def_qn(r, "p.player.CBasePlayer.Spawn"));
    ASSERT_TRUE(has_def_qn(r, "p.player.PM_Move"));
    const CBMDefinition *reload = find_def(r, "ReloadWeapons");
    ASSERT_NOT_NULL(reload);
    ASSERT_STR_EQ(reload->label, "Method");
    ASSERT_EQ((int)reload->start_line, 8);
    ASSERT_EQ((int)reload->end_line, 11);
    /* The real parameter list, not the macro's argument list. */
    ASSERT_EQ(reload->param_count, 1);
    /* Each in-body call is sourced to the hook whose body contains it. */
    const CBMCall *c10 = call_at_line(r, "helper", 10);
    ASSERT_NOT_NULL(c10);
    ASSERT_STR_EQ(c10->enclosing_func_qn, "p.player.CBasePlayer.ReloadWeapons");
    const CBMCall *c14 = call_at_line(r, "ReloadWeapons", 14);
    ASSERT_NOT_NULL(c14);
    ASSERT_STR_EQ(c14->enclosing_func_qn, "p.player.CBasePlayer.Spawn");
    const CBMCall *c18 = call_at_line(r, "helper", 18);
    ASSERT_NOT_NULL(c18);
    ASSERT_STR_EQ(c18->enclosing_func_qn, "p.player.PM_Move");
    cbm_free_result(r);
    PASS();
}

/* #946 precision controls: only a DEFINITION whose declarator nests a one-name
 * macro call is renamed. Macro call statements (file scope or in a body), calls
 * through a returned function pointer, a real function returning a function
 * pointer, a prototype, and a multi-argument wrapper whose name is ambiguous must
 * not mint a definition named after a macro argument. */
TEST(extract_c_macro_wrapped_declarator_controls_issue946) {
    CBMFileResult *r = extract("int (*get_handler(int k))(int);\n" /* 1 */
                               "int (*pick(int k))(int)\n"         /* 2 */
                               "{\n"                               /* 3 */
                               "    return 0;\n"                   /* 4 */
                               "}\n"                               /* 5 */
                               "REGISTER(on_boot);\n"              /* 6 */
                               "void WRAP(proto_only)(void);\n"    /* 7 */
                               "void PAIR(alpha, beta)(void)\n"    /* 8 */
                               "{\n"                               /* 9 */
                               "}\n"                               /* 10 */
                               "void run(int v)\n"                 /* 11 */
                               "{\n"                               /* 12 */
                               "    get_handler(v)(v);\n"          /* 13 */
                               "    TRACE(v_trace);\n"             /* 14 */
                               "}\n",                              /* 15 */
                               CBM_LANG_C, "p", "controls.c");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(has_def(r, "Function", "pick"));
    ASSERT_TRUE(has_def(r, "Function", "run"));
    ASSERT_FALSE(has_def_any(r, "on_boot"));
    ASSERT_FALSE(has_def_any(r, "proto_only"));
    ASSERT_FALSE(has_def_any(r, "alpha"));
    ASSERT_FALSE(has_def_any(r, "beta"));
    ASSERT_FALSE(has_def_any(r, "v"));
    ASSERT_FALSE(has_def_any(r, "v_trace"));
    const CBMCall *handler = call_at_line(r, "get_handler", 13);
    ASSERT_NOT_NULL(handler);
    ASSERT_STR_EQ(handler->enclosing_func_qn, "p.controls.run");
    cbm_free_result(r);
    PASS();
}

/* #1957: the same root cause in C. `static void FNAME(first_caller)(void)` and
 * `static void FNAME(later_function)(void)` collapsed into one Function FNAME
 * (the later one won), and sink() inside first_caller, on line 9, was sourced
 * to it: a call site outside its caller's range, from the textual extractor and
 * the C LSP alike. The second file is the kernel template-header shape
 * (arch/x86/kvm/mmu/paging_tmpl.h): FNAME token-pastes and is defined only
 * inside #if branches, so no preprocessing can expand it. */
TEST(extract_c_fname_macro_definitions_stay_distinct_issue1957) {
    CBMFileResult *r = extract("#define FNAME(x) x\n"                      /* 1 */
                               "\n"                                        /* 2 */
                               "static void sink(void)\n"                  /* 3 */
                               "{\n"                                       /* 4 */
                               "}\n"                                       /* 5 */
                               "\n"                                        /* 6 */
                               "static void FNAME(first_caller)(void)\n"   /* 7 */
                               "{\n"                                       /* 8 */
                               "    sink();\n"                             /* 9 */
                               "}\n"                                       /* 10 */
                               "\n"                                        /* 11 */
                               "static void FNAME(later_function)(void)\n" /* 12 */
                               "{\n"                                       /* 13 */
                               "}\n"                                       /* 14 */
                               "\n"                                        /* 15 */
                               "int main(void)\n"                          /* 16 */
                               "{\n"                                       /* 17 */
                               "    first_caller();\n"                     /* 18 */
                               "    return 0;\n"                           /* 19 */
                               "}\n",                                      /* 20 */
                               CBM_LANG_C, "p", "repro.c");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_defs_named(r, "Function", "FNAME"), 0);
    const CBMDefinition *first = find_def(r, "first_caller");
    ASSERT_NOT_NULL(first);
    ASSERT_EQ((int)first->start_line, 7);
    ASSERT_EQ((int)first->end_line, 10);
    const CBMDefinition *later = find_def(r, "later_function");
    ASSERT_NOT_NULL(later);
    ASSERT_EQ((int)later->start_line, 12);
    const CBMCall *sink = call_at_line(r, "sink", 9);
    ASSERT_NOT_NULL(sink);
    ASSERT_STR_EQ(sink->enclosing_func_qn, "p.repro.first_caller");
    int lsp_sink = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->callee_qn && strcmp(rc->callee_qn, "p.repro.sink") == 0) {
            ASSERT_STR_EQ(rc->caller_qn, "p.repro.first_caller");
            lsp_sink++;
        }
    }
    ASSERT_GTE(lsp_sink, 1);
    cbm_free_result(r);

    CBMFileResult *t = extract("#if PTTYPE == 64\n"                                /* 1 */
                               "\t#define FNAME(name) paging##64_##name\n"         /* 2 */
                               "#else\n"                                           /* 3 */
                               "\t#error Invalid PTTYPE value\n"                   /* 4 */
                               "#endif\n"                                          /* 5 */
                               "static int FNAME(is_present)(unsigned long pte)\n" /* 6 */
                               "{\n"                                               /* 7 */
                               "\treturn test_bit(pte);\n"                         /* 8 */
                               "}\n"                                               /* 9 */
                               "static int FNAME(walk)(unsigned long pte)\n"       /* 10 */
                               "{\n"                                               /* 11 */
                               "\treturn check_pte(pte);\n"                        /* 12 */
                               "}\n",                                              /* 13 */
                               CBM_LANG_C, "p", "paging_tmpl.h");
    ASSERT_NOT_NULL(t);
    ASSERT_EQ(count_defs_named(t, "Function", "FNAME"), 0);
    ASSERT_TRUE(has_def_qn(t, "p.paging_tmpl.is_present"));
    ASSERT_TRUE(has_def_qn(t, "p.paging_tmpl.walk"));
    const CBMCall *bit = call_at_line(t, "test_bit", 8);
    ASSERT_NOT_NULL(bit);
    ASSERT_STR_EQ(bit->enclosing_func_qn, "p.paging_tmpl.is_present");
    const CBMCall *chk = call_at_line(t, "check_pte", 12);
    ASSERT_NOT_NULL(chk);
    ASSERT_STR_EQ(chk->enclosing_func_qn, "p.paging_tmpl.walk");
    cbm_free_result(t);
    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
 * SILENTLY DROPPED every top-level definition past 4096. The growable heap stack
 * fixes both: a file with > 4096 top-level defs must extract ALL of them. RED
 * before the fix (extracted count capped near 4096), GREEN after. */
TEST(walk_defs_no_truncation_over_4096_issue668) {
    enum { N = 5000 };
    /* N top-level Python defs → N Function defs, all direct module children, so
     * walk_defs pushes all N children at once — the >4096 truncation site. */
    size_t cap = (size_t)N * 24 + 1;
    char *src = (char *)malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t off = 0;
    for (int i = 0; i < N; i++) {
        off += (size_t)snprintf(src + off, cap - off, "def f%d(): pass\n", i);
    }
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "big.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int nfuncs = count_defs_with_label(r, "Function");
    ASSERT(nfuncs >= N); /* all N present — not truncated at the old 4096 cap */
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Suite
 * ═══════════════════════════════════════════════════════════════════ */

/* Rust: inline #[test]/#[tokio::test] functions must be marked is_test so the
 * store.c `is_test != 1` filter excludes them from graph context. Detection is
 * otherwise file-path-based (cbm_is_test_file), so test fns in a regular .rs
 * file leak. (#855) */
TEST(extract_rust_test_attr_marks_is_test_issue855) {
    CBMFileResult *r = extract("pub fn real_fn() {}\n"
                               "\n"
                               "#[test]\n"
                               "fn sync_test() {}\n"
                               "\n"
                               "#[tokio::test]\n"
                               "async fn async_test() {}\n",
                               CBM_LANG_RUST, "t", "src/lib.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    int real = -1, sync = -1, asyn = -1;
    for (int i = 0; i < r->defs.count; i++) {
        const char *n = r->defs.items[i].name;
        if (!n) {
            continue;
        }
        if (strcmp(n, "real_fn") == 0) {
            real = r->defs.items[i].is_test ? 1 : 0;
        } else if (strcmp(n, "sync_test") == 0) {
            sync = r->defs.items[i].is_test ? 1 : 0;
        } else if (strcmp(n, "async_test") == 0) {
            asyn = r->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(real >= 0 && sync >= 0 && asyn >= 0 && "all three fns extracted");
    ASSERT(real == 0 && "real_fn is NOT a test");
    ASSERT(sync == 1 && "#[test] fn is_test");
    ASSERT(asyn == 1 && "#[tokio::test] fn is_test");

    cbm_free_result(r);
    PASS();
}

/* Function.is_test must follow the file's test-directory membership, not just
 * a test_/_test basename convention: a helper under tests/ with none of those
 * naming conventions (tests/helpers/fixtures.c) was previously indexed as an
 * ordinary, non-test Function — invisible to store.c's `is_test != 1`
 * dead-code/search filters even though trace_path's own independent path
 * check already treated the same file as a test (#1294). */
TEST(extract_c_test_dir_marks_is_test_issue1294) {
    const char *src = "void helper(void) {}\n";

    /* Regression: a test_*-named file directly under tests/ must remain a
     * test (this already worked before the fix). */
    CBMFileResult *r1 = extract(src, CBM_LANG_C, "t", "tests/test_pipeline.c");
    ASSERT_NOT_NULL(r1);
    ASSERT_FALSE(r1->has_error);
    ASSERT(has_def(r1, "Function", "helper"));
    int reg = -1;
    for (int i = 0; i < r1->defs.count; i++) {
        if (strcmp(r1->defs.items[i].label, "Function") == 0 && r1->defs.items[i].name &&
            strcmp(r1->defs.items[i].name, "helper") == 0) {
            reg = r1->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(reg == 1 && "test_*.c directly under tests/ is a test (regression)");
    cbm_free_result(r1);

    /* Positive: a file under tests/ that matches none of the test_/_test
     * naming conventions must now ALSO be a test. */
    CBMFileResult *r2 = extract(src, CBM_LANG_C, "t", "tests/helpers/fixtures.c");
    ASSERT_NOT_NULL(r2);
    ASSERT_FALSE(r2->has_error);
    ASSERT(has_def(r2, "Function", "helper"));
    int nonconv = -1;
    for (int i = 0; i < r2->defs.count; i++) {
        if (strcmp(r2->defs.items[i].label, "Function") == 0 && r2->defs.items[i].name &&
            strcmp(r2->defs.items[i].name, "helper") == 0) {
            nonconv = r2->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(nonconv == 1 && "non-test_-named file under tests/ is now a test");
    cbm_free_result(r2);

    /* Negative: a file with no test/ directory or test_/_test naming in its
     * path must never be flagged — this fix must not widen detection beyond
     * the tests/ (and sibling) directory tree. */
    CBMFileResult *r3 = extract(src, CBM_LANG_C, "t", "src/pipeline/helper.c");
    ASSERT_NOT_NULL(r3);
    ASSERT_FALSE(r3->has_error);
    ASSERT(has_def(r3, "Function", "helper"));
    int outside = -1;
    for (int i = 0; i < r3->defs.count; i++) {
        if (strcmp(r3->defs.items[i].label, "Function") == 0 && r3->defs.items[i].name &&
            strcmp(r3->defs.items[i].name, "helper") == 0) {
            outside = r3->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(outside == 0 && "file outside tests/ is never a test");
    cbm_free_result(r3);

    PASS();
}

/* Same convergence for Method definitions (push_method_def), which take a
 * separate code path from free functions: a class method on a class defined
 * under tests/ with no test_/_test naming (e.g. tests/helpers/base.py) must
 * be marked is_test too, and a method on the same class outside tests/ must
 * not be (#1294). */
TEST(extract_python_method_test_dir_marks_is_test_issue1294) {
    const char *src = "class Foo:\n"
                      "    def helper(self):\n"
                      "        pass\n";

    /* Python's LSP layer injects synthetic builtin stub Methods (str.upper,
     * dict.get, ...) into defs.items alongside real ones (py_builtins.c), so
     * matching must key on name, not just label="Method". */
    CBMFileResult *r1 = extract(src, CBM_LANG_PYTHON, "t", "tests/helpers/base.py");
    ASSERT_NOT_NULL(r1);
    ASSERT_FALSE(r1->has_error);
    ASSERT(has_def(r1, "Method", "helper"));
    int in_tests = -1;
    for (int i = 0; i < r1->defs.count; i++) {
        if (strcmp(r1->defs.items[i].label, "Method") == 0 && r1->defs.items[i].name &&
            strcmp(r1->defs.items[i].name, "helper") == 0) {
            in_tests = r1->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(in_tests == 1 && "method on a class under tests/helpers/ is a test");
    cbm_free_result(r1);

    CBMFileResult *r2 = extract(src, CBM_LANG_PYTHON, "t", "app/models/base.py");
    ASSERT_NOT_NULL(r2);
    ASSERT_FALSE(r2->has_error);
    ASSERT(has_def(r2, "Method", "helper"));
    int outside_tests = -1;
    for (int i = 0; i < r2->defs.count; i++) {
        if (strcmp(r2->defs.items[i].label, "Method") == 0 && r2->defs.items[i].name &&
            strcmp(r2->defs.items[i].name, "helper") == 0) {
            outside_tests = r2->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(outside_tests == 0 && "method on a class outside tests/ is never a test");
    cbm_free_result(r2);

    PASS();
}

/* #1017: docstring truncation at MAX_COMMENT_LEN (500 bytes) could split a
 * multi-byte UTF-8 character, leaving an incomplete byte sequence.
 * Craft a Go comment whose 498th-500th bytes are a 3-byte CJK character
 * (U+6210 = 成 = e6 88 90), where a raw byte cut at offset 500 lands one
 * byte past the character start. Docstrings are no longer cut at all, so
 * the whole comment is kept and still ends on a complete codepoint. */
TEST(docstring_utf8_truncation_boundary_issue1017) {
    /* Build a comment: "// " (3 bytes) + 495 ASCII 'A' + "成成成" (9 bytes)
     * Total comment text = 3 + 495 + 9 = 507 bytes.
     * MAX_COMMENT_LEN = 500.  The first kanji (成 = e6 88 90) occupies
     * offsets 498-500, so text[500] = '\0' keeps bytes 0-499: the lead
     * byte 0xe6 plus one continuation 0x88 — an incomplete 2-of-3 sequence.
     * Before fix: the truncated string ended with that broken pair. */
    char comment[600];
    int off = 0;
    comment[off++] = '/';
    comment[off++] = '/';
    comment[off++] = ' ';
    for (int i = 0; i < 495; i++)
        comment[off++] = 'A';
    /* U+6210 (成) = 0xe6 0x88 0x90 — 3-byte UTF-8 */
    const char *kanji = "\xe6\x88\x90";
    for (int k = 0; k < 3; k++) {
        memcpy(comment + off, kanji, 3);
        off += 3;
    }
    comment[off] = '\0';

    /* Wrap in a Go function so the comment becomes the docstring. */
    char src[800];
    snprintf(src, sizeof(src), "package main\n\n%s\nfunc Compute() {}\n", comment);

    CBMFileResult *r = extract(src, CBM_LANG_GO, "test", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Compute"));

    const char *doc = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "Compute") == 0) {
            doc = r->defs.items[i].docstring;
            break;
        }
    }
    ASSERT_NOT_NULL(doc);

    /* The whole comment, and every byte of it valid UTF-8: no trailing
     * incomplete multi-byte sequence. */
    ASSERT_STR_EQ(doc, comment);
    size_t len = strlen(doc);
    const unsigned char *u = (const unsigned char *)doc;
    size_t i = 0;
    while (i < len) {
        unsigned char c = u[i];
        int seq_len;
        if (c < 0x80)
            seq_len = 1;
        else if ((c & 0xE0) == 0xC0)
            seq_len = 2;
        else if ((c & 0xF0) == 0xE0)
            seq_len = 3;
        else if ((c & 0xF8) == 0xF0)
            seq_len = 4;
        else
            FAIL("invalid UTF-8 lead byte");
        ASSERT_TRUE(i + (size_t)seq_len <= len);
        for (int j = 1; j < seq_len; j++)
            ASSERT_TRUE((u[i + (size_t)j] & 0xC0) == 0x80);
        i += (size_t)seq_len;
    }

    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Doc comments: the whole comment run above a definition, above its
 * attributes / export / declaration wrapper, never a detached or
 * banner-only run, and never cut at 500 bytes.
 * ═══════════════════════════════════════════════════════════════════ */

/* The def with this label and name, or NULL. */
static const CBMDefinition *doc_def(CBMFileResult *r, const char *label, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (d->label && d->name && strcmp(d->label, label) == 0 && strcmp(d->name, name) == 0) {
            return d;
        }
    }
    return NULL;
}

TEST(doc_go_comment_group_without_directives) {
    CBMFileResult *r = extract("package knob\n\n"
                               "// Turn rotates the knob by one step.\n"
                               "// It is safe for concurrent use.\n"
                               "//go:noinline\n"
                               "func Turn() {}\n",
                               CBM_LANG_GO, "t", "knob.go");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Function", "Turn");
    ASSERT_NOT_NULL(d);
    /* go/ast CommentGroup.Text: the whole group, the //go: directive dropped. */
    ASSERT_STR_EQ(d->docstring, "// Turn rotates the knob by one step.\n"
                                "// It is safe for concurrent use.");
    cbm_free_result(r);
    PASS();
}

TEST(doc_go_struct_field) {
    CBMFileResult *r = extract("package knob\n\n"
                               "// Knob is a rotary control.\n"
                               "type Knob struct {\n"
                               "\t// Steps counts the turns so far.\n"
                               "\tSteps int\n"
                               "}\n",
                               CBM_LANG_GO, "t", "knob.go");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *knob = doc_def(r, "Struct", "Knob");
    ASSERT_NOT_NULL(knob);
    ASSERT_STR_EQ(knob->docstring, "// Knob is a rotary control.");
    const CBMDefinition *steps = doc_def(r, "Field", "Steps");
    ASSERT_NOT_NULL(steps);
    ASSERT_STR_EQ(steps->docstring, "// Steps counts the turns so far.");
    cbm_free_result(r);
    PASS();
}

TEST(doc_go_detached_comment_is_not_doc) {
    /* go/doc: a comment group separated by a blank line documents nothing. */
    CBMFileResult *r = extract("package knob\n\n"
                               "// Section: helpers.\n"
                               "\n"
                               "func Reset() {}\n",
                               CBM_LANG_GO, "t", "knob.go");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Function", "Reset");
    ASSERT_NOT_NULL(d);
    ASSERT_NULL(d->docstring);
    cbm_free_result(r);
    PASS();
}

TEST(doc_python_comment_run_and_detached) {
    CBMFileResult *r = extract("# Turns the knob.\n"
                               "# One step per call.\n"
                               "def turn():\n"
                               "    pass\n"
                               "\n"
                               "# Section: helpers.\n"
                               "\n"
                               "def reset():\n"
                               "    pass\n",
                               CBM_LANG_PYTHON, "t", "knob.py");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *turn = doc_def(r, "Function", "turn");
    ASSERT_NOT_NULL(turn);
    ASSERT_STR_EQ(turn->docstring, "# Turns the knob.\n# One step per call.");
    const CBMDefinition *reset = doc_def(r, "Function", "reset");
    ASSERT_NOT_NULL(reset);
    ASSERT_NULL(reset->docstring);
    cbm_free_result(r);
    PASS();
}

TEST(doc_rust_attribute_impl_method_and_inner_doc) {
    CBMFileResult *r = extract("//! The knob crate.\n"
                               "\n"
                               "/// Adds two steps.\n"
                               "/// Wraps on overflow.\n"
                               "#[inline]\n"
                               "pub fn add(a: u8, b: u8) -> u8 { a.wrapping_add(b) }\n"
                               "\n"
                               "pub struct Knob;\n"
                               "\n"
                               "impl Knob {\n"
                               "    /// Turns the knob once.\n"
                               "    pub fn turn(&self) {}\n"
                               "}\n",
                               CBM_LANG_RUST, "t", "lib.rs");
    ASSERT_NOT_NULL(r);
    /* The doc sits above the attribute; a run is joined line by line. */
    const CBMDefinition *add = doc_def(r, "Function", "add");
    ASSERT_NOT_NULL(add);
    ASSERT_STR_EQ(add->docstring, "/// Adds two steps.\n/// Wraps on overflow.");
    /* impl methods get their doc too; a single comment keeps its bytes. */
    const CBMDefinition *turn = doc_def(r, "Method", "turn");
    ASSERT_NOT_NULL(turn);
    ASSERT_STR_EQ(turn->docstring, "/// Turns the knob once.\n");
    /* The //! inner doc documents the crate (the File node), not the struct. */
    const CBMDefinition *knob = doc_def(r, "Struct", "Knob");
    ASSERT_NOT_NULL(knob);
    ASSERT_NULL(knob->docstring);
    cbm_free_result(r);
    PASS();
}

TEST(doc_ts_export_and_arrow_wrapper) {
    CBMFileResult *r = extract("/** Exported helper. */\n"
                               "export function helper(): number {\n"
                               "    return 1;\n"
                               "}\n"
                               "\n"
                               "/** Arrow helper. */\n"
                               "export const arrow = (): number => 2;\n",
                               CBM_LANG_TYPESCRIPT, "t", "knob.ts");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *helper = doc_def(r, "Function", "helper");
    ASSERT_NOT_NULL(helper);
    ASSERT_STR_EQ(helper->docstring, "/** Exported helper. */");
    const CBMDefinition *arrow = doc_def(r, "Function", "arrow");
    ASSERT_NOT_NULL(arrow);
    ASSERT_STR_EQ(arrow->docstring, "/** Arrow helper. */");
    cbm_free_result(r);
    PASS();
}

TEST(doc_csharp_xml_doc_run_and_top_level_function) {
    CBMFileResult *r = extract("/// Adds one.\n"
                               "static int AddOne(int x) => x + 1;\n"
                               "\n"
                               "namespace Knobs {\n"
                               "    public class Knob {\n"
                               "        /// <summary>\n"
                               "        /// Turns the knob.\n"
                               "        /// </summary>\n"
                               "        public void Turn() {}\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_CSHARP, "t", "Knob.cs");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *turn = doc_def(r, "Method", "Turn");
    ASSERT_NOT_NULL(turn);
    ASSERT_STR_EQ(turn->docstring, "/// <summary>\n/// Turns the knob.\n/// </summary>");
    const CBMDefinition *add = doc_def(r, "Function", "AddOne");
    ASSERT_NOT_NULL(add);
    ASSERT_STR_EQ(add->docstring, "/// Adds one.");
    cbm_free_result(r);
    PASS();
}

TEST(doc_java_javadoc_over_line_comment_and_field) {
    CBMFileResult *r = extract("class Knob {\n"
                               "    /** Turns taken so far. */\n"
                               "    private int steps;\n"
                               "\n"
                               "    /** Turns the knob. */\n"
                               "    // NOSONAR\n"
                               "    void turn() {}\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "Knob.java");
    ASSERT_NOT_NULL(r);
    /* A plain comment between the Javadoc and the method does not replace it. */
    const CBMDefinition *turn = doc_def(r, "Method", "turn");
    ASSERT_NOT_NULL(turn);
    ASSERT_STR_EQ(turn->docstring, "/** Turns the knob. */");
    const CBMDefinition *steps = doc_def(r, "Field", "steps");
    ASSERT_NOT_NULL(steps);
    ASSERT_STR_EQ(steps->docstring, "/** Turns taken so far. */");
    cbm_free_result(r);
    PASS();
}

TEST(doc_kotlin_kdoc_folded_after_imports) {
    /* tree-sitter-kotlin folds this KDoc into the node before the class, so it
     * is no sibling of it. */
    CBMFileResult *r = extract("package knobs\n"
                               "\n"
                               "import knobs.core.Step\n"
                               "import knobs.core.Turn\n"
                               "\n"
                               "/** Base class of every knob. */\n"
                               "abstract class BaseKnob(step: Step) : Turn(step)\n",
                               CBM_LANG_KOTLIN, "t", "BaseKnob.kt");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Class", "BaseKnob");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->docstring, "/** Base class of every knob. */");
    cbm_free_result(r);
    PASS();
}

TEST(doc_c_typedef_struct) {
    CBMFileResult *r = extract("/* A file event. */\n"
                               "typedef struct aeFileEvent {\n"
                               "    int mask;\n"
                               "} aeFileEvent;\n",
                               CBM_LANG_C, "t", "ae.h");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Class", "aeFileEvent");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->docstring, "/* A file event. */");
    cbm_free_result(r);
    PASS();
}

TEST(doc_perl_pod_section_by_sub_name) {
    CBMFileResult *r = extract("package Knob;\n"
                               "\n"
                               "sub turn { return 1; }\n"
                               "\n"
                               "1;\n"
                               "__END__\n"
                               "\n"
                               "=head1 METHODS\n"
                               "\n"
                               "=head2 turn\n"
                               "\n"
                               "Turns the knob once.\n"
                               "\n"
                               "=cut\n",
                               CBM_LANG_PERL, "t", "Knob.pm");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Function", "turn");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->docstring, "=head2 turn\n\nTurns the knob once.");
    cbm_free_result(r);
    PASS();
}

/* A Perl file's module doc (its File node's docstring) is the POD that no
 * sub's doc holds: each run as it stands, joined by a blank line, so that a
 * reference is read once. */
TEST(doc_perl_module_doc_is_the_pod_no_sub_holds) {
    CBMFileResult *r = extract("package Knob;\n"
                               "\n"
                               "=head1 NAME\n"
                               "\n"
                               "Knob - see L<Dial>.\n"
                               "\n"
                               "=cut\n"
                               "\n"
                               "sub turn { return 1; }\n"
                               "\n"
                               "1;\n"
                               "__END__\n"
                               "\n"
                               "=head1 METHODS\n"
                               "\n"
                               "The knob's methods.\n"
                               "\n"
                               "=head2 turn\n"
                               "\n"
                               "Turns the knob once.\n"
                               "\n"
                               "=head2 spin\n"
                               "\n"
                               "Not a sub here.\n"
                               "\n"
                               "=cut\n",
                               CBM_LANG_PERL, "t", "Knob.pm");
    ASSERT_NOT_NULL(r);
    ASSERT_STR_EQ(r->module_doc, "=head1 NAME\n\nKnob - see L<Dial>.\n\n=cut\n\n"
                                 "=head1 METHODS\n\nThe knob's methods.\n\n"
                                 "=head2 spin\n\nNot a sub here.\n\n=cut");
    const CBMDefinition *d = doc_def(r, "Function", "turn");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->docstring, "=head2 turn\n\nTurns the knob once.");
    cbm_free_result(r);

    /* all of the POD is a sub's: no module doc */
    r = extract("package Knob;\n"
                "sub turn { return 1; }\n"
                "1;\n"
                "__END__\n"
                "\n"
                "=head2 turn\n"
                "\n"
                "Turns.\n"
                "\n"
                "=cut\n",
                CBM_LANG_PERL, "t", "Knob.pm");
    ASSERT_NOT_NULL(r);
    ASSERT_NULL(r->module_doc);
    cbm_free_result(r);
    PASS();
}

TEST(doc_long_comment_kept_whole) {
    /* One 12-line block comment well past the old 500-byte cut, kept byte for
     * byte. */
    char src[4096];
    char want[2048];
    int w = snprintf(want, sizeof(want), "/*");
    for (int i = 0; i < 12; i++) {
        w += snprintf(want + w, sizeof(want) - (size_t)w,
                      "\n * Line %02d of a long doc that keeps going past the cut.", i);
    }
    snprintf(want + w, sizeof(want) - (size_t)w, "\n */");
    snprintf(src, sizeof(src), "package knob\n\n%s\nfunc Long() {}\n", want);
    ASSERT_GT((int)strlen(want), 500);

    CBMFileResult *r = extract(src, CBM_LANG_GO, "t", "knob.go");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = doc_def(r, "Function", "Long");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->docstring, want);
    cbm_free_result(r);
    PASS();
}

TEST(doc_divider_only_run_is_not_doc) {
    CBMFileResult *r = extract("/*****************************/\n"
                               "void knob(void) {}\n"
                               "\n"
                               "// \xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\n"
                               "void dial(void) {}\n"
                               "\n"
                               "/* Resets the dial. */\n"
                               "void reset(void) {}\n",
                               CBM_LANG_C, "t", "knob.c");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *knob = doc_def(r, "Function", "knob");
    ASSERT_NOT_NULL(knob);
    ASSERT_NULL(knob->docstring);
    const CBMDefinition *dial = doc_def(r, "Function", "dial"); /* a box-drawing banner */
    ASSERT_NOT_NULL(dial);
    ASSERT_NULL(dial->docstring);
    const CBMDefinition *reset = doc_def(r, "Function", "reset");
    ASSERT_NOT_NULL(reset);
    ASSERT_STR_EQ(reset->docstring, "/* Resets the dial. */");
    cbm_free_result(r);
    PASS();
}

/* Reproduce-first (ms-typescript reallyLargeFile.ts, 2026-07-07): a file
 * whose root node has hundreds of thousands of FLAT SIBLINGS (580k ////
 * comment lines in the 3.5 MB fourslash fixture) hung extraction for over
 * 15 minutes: walk_defs pushed children via index-based ts_node_child(i),
 * which is O(i) per call in tree-sitter — O(n^2) per wide node (~1.7e11
 * iterator steps on the real file; 100% of stack samples inside
 * ts_node_child_iterator_next). The supervisor then killed the silent
 * worker as a hang and, via the stale extraction marker, quarantined
 * INNOCENT files on every retry.
 *
 * This fixture is an 80k-sibling flat file: quadratic child access needs
 * minutes under ASan; the linear TSTreeCursor collection finishes in
 * milliseconds. The 30 s bound has ~100x headroom over the fixed cost —
 * RED on index-based child pushes, GREEN on the cursor walk. The def-count
 * guard keeps the test honest: extraction must actually process the whole
 * breadth, not skip it. */
/* Extract a wide-flat comment-sibling fixture of n lines (the exact shape of
 * ms-typescript's reallyLargeFile.ts: hundreds of thousands of flat comment
 * children under the root, plus sparse real defs so the breadth check cannot
 * pass vacuously). Returns elapsed milliseconds; stores the def count. */
static long extract_wide_flat_ms(int n, int *out_defs) {
    const size_t cap = (size_t)n * 24 + (size_t)8192; /* "// wide filler N\n" <= 24 chars */
    char *src = malloc(cap);
    if (!src) {
        return -1;
    }
    size_t off = 0;
    /* CONSTANT def count (10), independent of n: defs that scale WITH n make
     * the fixture superlinear through the separate per-def sibling-scan cost
     * (O(defs x siblings)) — on windows-CLANG64 ASan that pushed the ratio
     * of LINEAR walk code to 43x. Ten spread-out defs keep the breadth check
     * honest while the sibling-scan term stays 10 x n = linear. */
    const int def_stride = n / 10;
    for (int i = 0; i < n; i++) {
        off += (size_t)snprintf(src + off, cap - off, "// wide filler %d\n", i);
        if (i % def_stride == 0) {
            off += (size_t)snprintf(src + off, cap - off, "var wide_a%d = %d;\n", i, i);
        }
    }
    struct timespec a;
    struct timespec b;
    cbm_clock_gettime(CLOCK_MONOTONIC, &a);
    CBMFileResult *r =
        cbm_extract_file(src, (int)off, CBM_LANG_JAVASCRIPT, "proj", "wide.js", 0, NULL, NULL);
    cbm_clock_gettime(CLOCK_MONOTONIC, &b);
    free(src);
    if (!r) {
        return -1;
    }
    *out_defs = r->defs.count;
    cbm_free_result(r);
    return (b.tv_sec - a.tv_sec) * 1000L + (b.tv_nsec - a.tv_nsec) / 1000000L;
}

/* Best-of-N. Timing noise only ever ADDS time, so the minimum of a few runs is
 * the cheapest good estimate of the noise-free cost. A single sample at each
 * size made the RATIO carry the noise of BOTH measurements: on a loaded Windows
 * VM this read 184ms -> 9387ms (51x) for code that measures ~20x unloaded, and
 * tripped a bound calibrated for exactly that linear case.
 *
 * Deliberately NOT solved by raising WF_RATIO_MAX: the bound sits where it does
 * because linear (~20x) and quadratic (~128x) are each >=2x away from it, so
 * inflating it moves the test toward the very signal it exists to catch. This
 * keeps the threshold and removes the variance instead. */
static long extract_wide_flat_ms_best_of(int n, int reps, int *out_defs) {
    long best = -1;
    for (int i = 0; i < reps; i++) {
        int defs = 0;
        long ms = extract_wide_flat_ms(n, &defs);
        if (ms < 0) {
            return ms;
        }
        if (best < 0 || ms < best) {
            best = ms;
            *out_defs = defs;
        }
    }
    return best;
}

TEST(extract_wide_flat_file_is_linear) {
    /* SCALING-RATIO guard: assert the COMPLEXITY CLASS, not a wall-clock
     * bound. Index-based ts_node_child(i) child loops are O(i) per call —
     * quadratic per wide node — and hung a 580k-sibling file for hours
     * (ms-typescript reallyLargeFile.ts). An absolute time bound conflates
     * machine speed with complexity: the gcc-13-ARM ASan CI leg runs this
     * extraction ~200x slower than clang at the SAME (measured perfectly
     * linear: 27.1s/54.2s/108.3s for 50k/100k/200k) complexity, and flunked
     * a 30s bound on linear code. Growing the input 4x must grow the time
     * ~4x when linear and ~16x when quadratic; the 10x bound splits those
     * decisively on every toolchain. The 120ms floor keeps clock noise from
     * mattering on fast machines. */
    /* Growth and bound CALIBRATED FROM MEASUREMENT, not models. The ASan
     * test build carries a large LINEAR per-line baseline (~31us/line on
     * clang-macOS, ~540us/line on gcc-13-ARM) that dilutes small-growth
     * ratios: at 8x growth the measured quadratic ratio was 22.4 — a 24x
     * bound false-passed the known-quadratic pre-merge walk. At 20x growth
     * the measured ratios are ~20x for linear code (both toolchains) and
     * ~128x for the quadratic walk (clang-macOS) — bound 40 sits >=2x from
     * both. The 120ms floor keeps clock noise irrelevant on fast hosts. */
    enum { WF_SMALL = 20 * 1000, WF_BIG = 400 * 1000, WF_RATIO_MAX = 40, WF_FLOOR_MS = 120 };
    int defs_small = 0;
    int defs_big = 0;
    /* Small is cheap, so sample it more; big dominates runtime, so twice is the
     * affordable compromise that still discards one unlucky sample. */
    long t_small = extract_wide_flat_ms_best_of(WF_SMALL, 3, &defs_small);
    long t_big = extract_wide_flat_ms_best_of(WF_BIG, 2, &defs_big);
    ASSERT_GTE(t_small, 0);
    ASSERT_GTE(t_big, 0);
    /* Anti-vacuous guard: the breadth was actually walked at both sizes. */
    ASSERT_GTE(defs_small, 8);
    ASSERT_GTE(defs_big, 8);
    fprintf(stderr, "  [wide-flat] t(%d)=%ldms t(%d)=%ldms\n", WF_SMALL, t_small, WF_BIG, t_big);
    long base = t_small > WF_FLOOR_MS ? t_small : WF_FLOOR_MS;
    if (t_big > WF_RATIO_MAX * base) {
        char msg[160];
        snprintf(msg, sizeof(msg),
                 "wide-flat scaling 20x input: %ldms -> %ldms (> %dx base %ldms) — "
                 "quadratic child access",
                 t_small, t_big, WF_RATIO_MAX, base);
        FAIL(msg);
    }
    PASS();
}

#if defined(CBM_CALL_REFERENCE_LOOKUP_TEST_API) && CBM_CALL_REFERENCE_LOOKUP_TEST_API
/* A flat block of value-reference statements exercises occurrence-role
 * classification for every identifier. The old parent/child field lookup
 * restarts at the block's first child for each statement, so 8x more source
 * produces about 64x more lookup work. Count work instead of wall time: this
 * RED is deterministic, sanitizer-independent, and finishes quickly even on
 * the known-quadratic implementation. */
static uint64_t extract_wide_reference_field_work(int statement_count, int *out_usages,
                                                  uint64_t *out_slow_parent_fallbacks) {
    static const char prefix[] = "function target() {}\nfunction wide() {\n";
    static const char statement[] = "  target;\n";
    static const char suffix[] = "}\n";
    size_t capacity = sizeof(prefix) + (size_t)statement_count * sizeof(statement) + sizeof(suffix);
    char *source = malloc(capacity);
    if (!source) {
        return UINT64_MAX;
    }
    size_t offset = 0;
    memcpy(source + offset, prefix, sizeof(prefix) - 1U);
    offset += sizeof(prefix) - 1U;
    for (int i = 0; i < statement_count; i++) {
        memcpy(source + offset, statement, sizeof(statement) - 1U);
        offset += sizeof(statement) - 1U;
    }
    memcpy(source + offset, suffix, sizeof(suffix));
    offset += sizeof(suffix) - 1U;

    cbm_usage_field_lookup_test_reset();
    CBMFileResult *result = cbm_extract_file(source, (int)offset, CBM_LANG_JAVASCRIPT, "proj",
                                             "wide-references.js", 0, NULL, NULL);
    free(source);
    if (!result) {
        return UINT64_MAX;
    }
    int usages = 0;
    for (int i = 0; i < result->usages.count; i++) {
        if (result->usages.items[i].ref_name &&
            strcmp(result->usages.items[i].ref_name, "target") == 0) {
            usages++;
        }
    }
    uint64_t work = cbm_usage_field_lookup_test_work();
    *out_slow_parent_fallbacks = cbm_usage_slow_parent_fallback_test_count();
    cbm_free_result(result);
    *out_usages = usages;
    return work;
}

TEST(extract_wide_flat_reference_fields_are_linear) {
    enum { SMALL = 128, BIG = 1024, INPUT_GROWTH = 8, WORK_RATIO_MAX = 12 };
    int small_usages = 0;
    int big_usages = 0;
    uint64_t small_slow_parent_fallbacks = 0;
    uint64_t big_slow_parent_fallbacks = 0;
    uint64_t small_work =
        extract_wide_reference_field_work(SMALL, &small_usages, &small_slow_parent_fallbacks);
    uint64_t big_work =
        extract_wide_reference_field_work(BIG, &big_usages, &big_slow_parent_fallbacks);
    ASSERT_TRUE(small_work != UINT64_MAX);
    ASSERT_TRUE(big_work != UINT64_MAX);
    ASSERT_EQ(small_usages, SMALL);
    ASSERT_EQ(big_usages, BIG);
    ASSERT_EQ(small_slow_parent_fallbacks, 0);
    ASSERT_EQ(big_slow_parent_fallbacks, 0);
    ASSERT_GTE(small_work, (uint64_t)SMALL);
    fprintf(stderr, "  [wide-reference-fields] work(%d)=%llu work(%d)=%llu input_growth=%dx\n",
            SMALL, (unsigned long long)small_work, BIG, (unsigned long long)big_work, INPUT_GROWTH);
    uint64_t maximum = small_work * WORK_RATIO_MAX + 256U;
    if (big_work > maximum) {
        char message[192];
        snprintf(message, sizeof(message),
                 "wide-reference field lookup grew from %llu to %llu for %dx input "
                 "(maximum %dx + 256) -- quadratic sibling scan",
                 (unsigned long long)small_work, (unsigned long long)big_work, INPUT_GROWTH,
                 WORK_RATIO_MAX);
        FAIL(message);
    }
    PASS();
}

/* The same guard for C#, whose callable-value site walk was the last one still
 * climbing with ts_node_parent instead of the walk cursor. tree-sitter answers
 * ts_node_parent by descending from the ROOT, so every step costs O(depth) and
 * a deep file pays it per identifier. The .NET JIT tests are exactly that —
 * single expressions megabytes deep — and they cost 18-48 us per node, which is
 * why they were the only files a CPU-time budget ever cut off, and why the C#
 * graph differed between two runs on one machine (2026-09-19). The budget is
 * gone; this keeps the reason it was needed from coming back. */
static uint64_t extract_csharp_argument_value_work(int statement_count, int *out_usages,
                                                   uint64_t *out_slow_parent_fallbacks) {
    static const char prefix[] = "class C {\n"
                                 "  static void Sink(object o) {}\n"
                                 "  static void Target() {}\n"
                                 "  static void Wide() {\n";
    /* Parenthesised on purpose: a bare `Sink(Target)` needs no climb at all, so
     * it cannot tell the cursor walk from the root-descending one and the test
     * would pass either way. The wrapper makes the site walk take a step. */
    static const char statement[] = "    Sink((Target));\n";
    static const char suffix[] = "  }\n}\n";
    size_t capacity = sizeof(prefix) + (size_t)statement_count * sizeof(statement) + sizeof(suffix);
    char *source = malloc(capacity);
    if (!source) {
        return UINT64_MAX;
    }
    size_t offset = 0;
    memcpy(source + offset, prefix, sizeof(prefix) - 1U);
    offset += sizeof(prefix) - 1U;
    for (int i = 0; i < statement_count; i++) {
        memcpy(source + offset, statement, sizeof(statement) - 1U);
        offset += sizeof(statement) - 1U;
    }
    memcpy(source + offset, suffix, sizeof(suffix));
    offset += sizeof(suffix) - 1U;

    cbm_usage_field_lookup_test_reset();
    CBMFileResult *result =
        cbm_extract_file(source, (int)offset, CBM_LANG_CSHARP, "proj", "Wide.cs", 0, NULL, NULL);
    free(source);
    if (!result) {
        return UINT64_MAX;
    }
    int usages = 0;
    for (int i = 0; i < result->usages.count; i++) {
        if (result->usages.items[i].ref_name &&
            strcmp(result->usages.items[i].ref_name, "Target") == 0) {
            usages++;
        }
    }
    uint64_t work = cbm_usage_field_lookup_test_work();
    *out_slow_parent_fallbacks = cbm_usage_slow_parent_fallback_test_count();
    cbm_free_result(result);
    *out_usages = usages;
    return work;
}

TEST(extract_csharp_argument_values_use_the_walk_cursor) {
    enum { SMALL = 128, BIG = 1024, INPUT_GROWTH = 8, WORK_RATIO_MAX = 12 };
    int small_usages = 0;
    int big_usages = 0;
    uint64_t small_slow_parent_fallbacks = 0;
    uint64_t big_slow_parent_fallbacks = 0;
    uint64_t small_work =
        extract_csharp_argument_value_work(SMALL, &small_usages, &small_slow_parent_fallbacks);
    uint64_t big_work =
        extract_csharp_argument_value_work(BIG, &big_usages, &big_slow_parent_fallbacks);
    ASSERT_TRUE(small_work != UINT64_MAX);
    ASSERT_TRUE(big_work != UINT64_MAX);
    /* Anti-vacuous: the occurrences really were classified, so a zero fallback
     * count means "took the cursor", not "never looked". */
    ASSERT_EQ(small_usages, SMALL);
    ASSERT_EQ(big_usages, BIG);
    /* The assertion this test exists for: not one occurrence fell back to the
     * root-descending parent lookup. */
    ASSERT_EQ(small_slow_parent_fallbacks, 0);
    ASSERT_EQ(big_slow_parent_fallbacks, 0);
    fprintf(stderr, "  [csharp-argument-values] work(%d)=%llu work(%d)=%llu input_growth=%dx\n",
            SMALL, (unsigned long long)small_work, BIG, (unsigned long long)big_work, INPUT_GROWTH);
    uint64_t maximum = small_work * WORK_RATIO_MAX + 256U;
    if (big_work > maximum) {
        char message[192];
        snprintf(message, sizeof(message),
                 "csharp argument-value lookup grew from %llu to %llu for %dx input "
                 "(maximum %dx + 256) -- the site walk is not linear",
                 (unsigned long long)small_work, (unsigned long long)big_work, INPUT_GROWTH,
                 WORK_RATIO_MAX);
        FAIL(message);
    }
    PASS();
}

/* #2176: a binary Godot `.res` resource (4.7 MB) never finished indexing. It
 * parses as ReScript into an error-heavy tree whose root has ~170k children
 * per MB, and the ReScript `let` binding check climbed from every named leaf
 * with ts_node_parent — a descent from the root that scans the children at
 * every level, so O(root children) per leaf and quadratic per file (1 MB spent
 * 46 s in the unified walk). Valid ReScript with many top-level statements has
 * the same flat root, so plain text drives it too. The walk now climbs its own
 * cursor. The counter records every root-descending hop that check makes; the
 * assertion is that the walk makes none, at any size. */
static int extract_rescript_let_leaf_fallbacks(int statement_count, int *out_usages,
                                               uint64_t *out_slow_parent_fallbacks) {
    static const char prefix[] = "let target = 1\n";
    static const char statement[] = "let v = target\n";
    size_t capacity = sizeof(prefix) + (size_t)statement_count * sizeof(statement);
    char *source = malloc(capacity);
    if (!source) {
        return -1;
    }
    size_t offset = 0;
    memcpy(source + offset, prefix, sizeof(prefix) - 1U);
    offset += sizeof(prefix) - 1U;
    for (int i = 0; i < statement_count; i++) {
        memcpy(source + offset, statement, sizeof(statement) - 1U);
        offset += sizeof(statement) - 1U;
    }
    source[offset] = '\0';

    cbm_usage_field_lookup_test_reset();
    CBMFileResult *result =
        cbm_extract_file(source, (int)offset, CBM_LANG_RESCRIPT, "proj", "Flat.res", 0, NULL, NULL);
    free(source);
    if (!result) {
        return -1;
    }
    int usages = 0;
    for (int i = 0; i < result->usages.count; i++) {
        if (result->usages.items[i].ref_name &&
            strcmp(result->usages.items[i].ref_name, "target") == 0) {
            usages++;
        }
    }
    *out_slow_parent_fallbacks = cbm_usage_slow_parent_fallback_test_count();
    cbm_free_result(result);
    *out_usages = usages;
    return 0;
}

TEST(extract_rescript_let_bindings_use_the_walk_cursor) {
    enum { SMALL = 128, BIG = 1024 };
    int small_usages = 0;
    int big_usages = 0;
    uint64_t small_fallbacks = 0;
    uint64_t big_fallbacks = 0;
    ASSERT_EQ(extract_rescript_let_leaf_fallbacks(SMALL, &small_usages, &small_fallbacks), 0);
    ASSERT_EQ(extract_rescript_let_leaf_fallbacks(BIG, &big_usages, &big_fallbacks), 0);
    fprintf(stderr, "  [rescript-let-bindings] fallbacks(%d)=%llu fallbacks(%d)=%llu\n", SMALL,
            (unsigned long long)small_fallbacks, BIG, (unsigned long long)big_fallbacks);
    /* Anti-vacuous: every leaf really was classified (each `target` read is a
     * usage, each `v` a binding), so zero fallbacks means "took the cursor",
     * not "never looked". */
    ASSERT_EQ(small_usages, SMALL);
    ASSERT_EQ(big_usages, BIG);
    ASSERT_EQ(small_fallbacks, 0);
    ASSERT_EQ(big_fallbacks, 0);
    PASS();
}

/* Every Python usage asks whether it is a global/nonlocal name and whether it
 * sits in a parameter default. Both climbed with ts_node_parent, which
 * descends from the ROOT: O(d^2) for a usage d deep, so one deep expression
 * went cubic (2.2 s / 17 s / >90 s at 500/1000/2000 terms). Count every such
 * root-descending step at N and 2N terms. */
TEST(extract_python_deep_default_parent_climbs_are_linear) {
    enum { SMALL = 200 };
    uint64_t slow_parents[2];
    for (int round = 0; round < 2; round++) {
        /* def f(x=x + x + ... + x): return x -- a binary_operator chain. */
        int terms = SMALL << round;
        size_t capacity = 32U + (size_t)terms * 4U;
        char *source = malloc(capacity);
        ASSERT_NOT_NULL(source);
        int length = snprintf(source, capacity, "def f(x=x");
        for (int i = 1; i < terms; i++) {
            length += snprintf(source + length, capacity - (size_t)length, " + x");
        }
        length += snprintf(source + length, capacity - (size_t)length, "):\n    return x\n");
        cbm_usage_field_lookup_test_reset();
        CBMFileResult *result =
            cbm_extract_file(source, length, CBM_LANG_PYTHON, "proj", "deep.py", 0, NULL, NULL);
        free(source);
        ASSERT_NOT_NULL(result);
        slow_parents[round] = cbm_usage_slow_parent_fallback_test_count();
        /* Anti-vacuous: every default x climbed its chain to the parameter and
         * reads the enclosing namespace; only `return x` is shadowed by it. */
        int defaults = 0;
        for (int i = 0; i < result->usages.count; i++) {
            const CBMUsage *usage = &result->usages.items[i];
            defaults += usage->ref_name && strcmp(usage->ref_name, "x") == 0 &&
                        !usage->semantic_reference_local_shadow;
        }
        cbm_free_result(result);
        ASSERT_EQ(defaults, terms);
    }
    fprintf(stderr, "  [python-deep-default] slow_parents(%d)=%llu slow_parents(%d)=%llu\n", SMALL,
            (unsigned long long)slow_parents[0], 2 * SMALL, (unsigned long long)slow_parents[1]);
    /* Twice the terms may cost about twice the steps; the cubic climb took 4x. */
    ASSERT_LTE(slow_parents[1], slow_parents[0] * 3U + 64U);
    PASS();
}
#endif

/* ===================================================================
 * Group H3: ObjectScript return type extraction
 * =================================================================== */

TEST(objectscript_udl_method_return_type) {
    CBMFileResult *r = extract("Class MyApp.Factory Extends %RegisteredObject\n"
                               "{\n"
                               "Method GetAdapter() As EnsLib.SQL.OutboundAdapter\n"
                               "{\n"
                               "    Quit ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Factory.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    bool found_rt = false;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "GetAdapter") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].return_type);
            ASSERT(strstr(r->defs.items[i].return_type, "EnsLib.SQL.OutboundAdapter") != NULL);
            found_rt = true;
        }
    }
    ASSERT(found_rt);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_scalar_return_type_not_resolved) {
    CBMFileResult *r = extract("Class MyApp.Counter Extends %RegisteredObject\n"
                               "{\n"
                               "Method GetName() As %String\n"
                               "{\n"
                               "    Quit \"hello\"\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Counter.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "GetName") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].return_type);
            ASSERT(strstr(r->defs.items[i].return_type, "%String") != NULL);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H2: ObjectScript macro expansion
 * =================================================================== */

TEST(objectscript_udl_class) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n{\n}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_methods_after_goto_label) {
    CBMFileResult *r = extract("Class Graph.KG.Test Extends %RegisteredObject\n"
                               "{\n"
                               "ClassMethod First() As %String\n"
                               "{\n"
                               "    If 1 { Goto Done }\n"
                               "Done\n"
                               "    Quit \"x\"\n"
                               "}\n"
                               "ClassMethod Second() As %String\n"
                               "{\n"
                               "    Quit \"y\"\n"
                               "}\n"
                               "ClassMethod Third() As %String\n"
                               "{\n"
                               "    Quit \"z\"\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Test.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Graph.KG.Test"));
    ASSERT(has_def(r, "Method", "First"));
    ASSERT(has_def(r, "Method", "Second"));
    ASSERT(has_def(r, "Method", "Third"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_methods) {
    CBMFileResult *r = extract("Class MyApp.Utils Extends %RegisteredObject\n"
                               "{\n"
                               "ClassMethod Format(pVal As %String) As %String\n"
                               "{\n"
                               "    Quit pVal\n"
                               "}\n"
                               "Method Save() As %Status\n"
                               "{\n"
                               "    Quit ..%Save()\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Utils.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Utils"));
    ASSERT(has_def(r, "Method", "Format"));
    ASSERT(has_def(r, "Method", "Save"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_base_classes) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "MyApp.Patient") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].base_classes);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[0]);
            ASSERT_STR_EQ(r->defs.items[i].base_classes[0], "%Persistent");
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_multiple_bases) {
    CBMFileResult *r = extract("Class MyApp.Dual Extends (MyApp.Base, %RegisteredObject)\n"
                               "{\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Dual.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "MyApp.Dual") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].base_classes);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[0]);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[1]);
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_properties) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "Property Name As %String;\n"
                               "Property DOB As %Date;\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    ASSERT(has_def(r, "Variable", "Name"));
    ASSERT(has_def(r, "Variable", "DOB"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_routine_tags) {
    CBMFileResult *r = extract("UTILS\n"
                               "    Quit\n"
                               "\n"
                               "Format(value,fmt)\n"
                               "    Set result = $ZDate(value, fmt)\n"
                               "    Quit result\n"
                               "\n"
                               "Log(msg)\n"
                               "    Write msg,!\n"
                               "    Quit\n",
                               CBM_LANG_OBJECTSCRIPT_ROUTINE, "t", "Utils.mac");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Format"));
    ASSERT(has_def(r, "Function", "Log"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_query_member) {
    CBMFileResult *r =
        extract("Class MyApp.Repo Extends %Persistent\n"
                "{\n"
                "Query FindAll(name As %String) As %SQLQuery { SELECT * FROM MyApp_Repo }\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "Repo.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Repo"));
    ASSERT(has_def(r, "Method", "FindAll"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_index_member) {
    CBMFileResult *r = extract("Class MyApp.Repo Extends %Persistent\n"
                               "{\n"
                               "Property Name As %String;\n"
                               "Index NameIdx On Name;\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Repo.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Index", "NameIdx"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_xdata_member) {
    CBMFileResult *r = extract("Class MyApp.Service Extends %CSP.REST\n"
                               "{\n"
                               "XData UrlMap { <Routes/> }\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "UrlMap"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_member) {
    CBMFileResult *r = extract("Class MyApp.Log Extends %Persistent\n"
                               "{\n"
                               "Trigger AfterInsert [ Event = INSERT ] { }\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Log.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "AfterInsert"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_body_quit) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "Trigger OnDeleteSQL [ Event = DELETE, Time = AFTER ] {\n"
                               "    Quit\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "OnDeleteSQL"));
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Trigger") == 0 &&
            strcmp(r->defs.items[i].name, "OnDeleteSQL") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT(strstr(r->defs.items[i].docstring, "trigger_body") != NULL);
            ASSERT(strstr(r->defs.items[i].docstring, "Quit") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_body_tokens) {
    CBMFileResult *r = extract("Class MyApp.Order Extends %Persistent\n"
                               "{\n"
                               "Trigger AfterInsert [ Event = INSERT, Time = AFTER ] {\n"
                               "    Set id = ..%Id()\n"
                               "    Do ##class(MyApp.Audit).Log(id)\n"
                               "    Quit\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Order.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "AfterInsert"));
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Trigger") == 0 &&
            strcmp(r->defs.items[i].name, "AfterInsert") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT(strstr(r->defs.items[i].docstring, "trigger_body") != NULL);
            ASSERT_NOT_NULL(r->defs.items[i].body_tokens);
            ASSERT(strstr(r->defs.items[i].body_tokens, "Log") != NULL ||
                   strstr(r->defs.items[i].body_tokens, "Audit") != NULL ||
                   strstr(r->defs.items[i].body_tokens, "id") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_self_call_relative_dot_method) {
    CBMFileResult *r =
        extract("Class HS.Flash.UpdateManager Extends Ens.BusinessProcess\n"
                "{\n"
                "Method MakeMRNUpToDate(pRequest As HS.Message.FlashQueueUpdate) As %Status\n"
                "{\n"
                "    Set tSC = ..processStreamlet(pSession, pTS, tMPIID, tSourceMRN, ii)\n"
                "    Quit tSC\n"
                "}\n"
                "Method processStreamlet(pSession As %Integer) As %Status\n"
                "{\n"
                "    Quit $$$OK\n"
                "}\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "UpdateManager.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "MakeMRNUpToDate"));
    ASSERT(has_call(r, "HS.Flash.UpdateManager.processStreamlet"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_new) {
    CBMFileResult *r = extract("Class MyApp.Caller Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set adapter = ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "    Do adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_parses_items) {
    CBMFileResult *r =
        extract("Class Sample.Production Extends Ens.Production\n"
                "{\n"
                "XData ProductionDefinition\n"
                "{\n"
                "<Production Name=\"Sample.Production\">\n"
                "  <Item Name=\"MyService\" ClassName=\"Sample.Service\" Enabled=\"true\">\n"
                "  </Item>\n"
                "  <Item Name=\"MyOperation\" ClassName=\"Sample.Operation\" Enabled=\"false\">\n"
                "  </Item>\n"
                "</Production>\n"
                "}\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "Production.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_hs_settings) {
    CBMFileResult *r = extract(
        "Class HS.Flash.Production Extends Ens.Production\n"
        "{\n"
        "XData ProductionDefinition\n"
        "{\n"
        "<Production Name=\"HS.Flash.Production\">\n"
        "  <Item Name=\"FHIRService\" ClassName=\"HS.Flash.FHIRService\" Enabled=\"true\">\n"
        "    <Setting Target=\"Host\" Name=\"TargetConfigName\">FHIROps</Setting>\n"
        "    <Setting Target=\"Host\" Name=\"PatientHost\">PatientOps</Setting>\n"
        "    <Setting Target=\"Host\" Name=\"ConformanceOperation\">ConformOps</Setting>\n"
        "  </Item>\n"
        "</Production>\n"
        "}\n"
        "}\n",
        CBM_LANG_OBJECTSCRIPT_UDL, "t", "HSProduction.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_absent_no_error) {
    CBMFileResult *r = extract("Class Sample.NonProduction Extends %Persistent\n"
                               "{\n"
                               "Method DoSomething() As %Status\n"
                               "{\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "NonProduction.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(!has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_param) {
    CBMFileResult *r = extract("Class MyApp.Handler Extends %RegisteredObject\n"
                               "{\n"
                               "Method Process(req As Ens.Request) As %Status\n"
                               "{\n"
                               "    Do req.Send()\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Handler.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Ens.Request.Send"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_property) {
    CBMFileResult *r = extract("Class MyApp.Service Extends Ens.BusinessService\n"
                               "{\n"
                               "Property Adapter As EnsLib.SQL.InboundAdapter;\n"
                               "Method OnProcessInput() As %Status\n"
                               "{\n"
                               "    Do ..Adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.InboundAdapter.ExecuteQuery"));
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H2: ObjectScript macro expansion
 * =================================================================== */

TEST(objectscript_macro_expand_system) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run(sc As %Status) As %Status\n"
                                           "{\n"
                                           "    If $$$ISERR(sc) { Quit sc }\n"
                                           "    Quit $$$OK\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "%SYSTEM.Status.IsError"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group H3: ObjectScript DATA_FLOWS argument extraction
 * ═══════════════════════════════════════════════════════════════════ */

static int find_call_args(const CBMFileResult *r, const char *callee, const char **out_arg0,
                          const char **out_arg1) {
    if (out_arg0)
        *out_arg0 = NULL;
    if (out_arg1)
        *out_arg1 = NULL;
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, callee)) {
            if (out_arg0 && r->calls.items[i].arg_count > 0)
                *out_arg0 = r->calls.items[i].args[0].expr;
            if (out_arg1 && r->calls.items[i].arg_count > 1)
                *out_arg1 = r->calls.items[i].args[1].expr;
            return r->calls.items[i].arg_count;
        }
    }
    return -1;
}

/* tree-sitter lists a comment inside an argument list as a named child; it is
 * not an argument. A Java constructor call whose argument list opened with a
 * slash-star comment handed the comment text to the Route pass as a URL
 * (three Route nodes named by comments on elasticsearch, 2026-09-16). */
TEST(call_args_skip_comments_between_arguments) {
    CBMFileResult *r = extract("class A {\n"
                               "  void f() {\n"
                               "    app.get(/* the orders listing */ \"/orders\", handler);\n"
                               "    new TestCase(\n"
                               "        /*\n"
                               "         * a multi-line note\n"
                               "         */\n"
                               "        \"x\", // trailing\n"
                               "        1);\n"
                               "  }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "A.java");
    ASSERT_NOT_NULL(r);
    const char *arg0 = NULL;
    const char *arg1 = NULL;
    int argc = find_call_args(r, "get", &arg0, &arg1);
    ASSERT_EQ(argc, 2);
    ASSERT_STR_EQ(arg0, "\"/orders\"");
    ASSERT_STR_EQ(arg1, "handler");
    argc = find_call_args(r, "TestCase", &arg0, &arg1);
    ASSERT_EQ(argc, 2);
    ASSERT_STR_EQ(arg0, "\"x\"");
    ASSERT_STR_EQ(arg1, "1");
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_data_flows_class_method_args) {
    CBMFileResult *r = extract("Class MyApp.Caller Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set sql = \"SELECT 1\"\n"
                               "    Do ##class(MyApp.Utils).Transform(sql, \"JSON\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyApp.Utils.Transform"));
    const char *arg0 = NULL;
    const char *arg1 = NULL;
    int argc = find_call_args(r, "MyApp.Utils.Transform", &arg0, &arg1);
    ASSERT(argc == 2);
    ASSERT_NOT_NULL(arg0);
    ASSERT(strstr(arg0, "sql") != NULL);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_macro_expand_local) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMArena arena;
    cbm_arena_init(&arena);
    const char *inc_content = "ROUTINE MyApp.Include [Type=INC]\n"
                              "#define MyCheck(%sc) ##class(MyApp.Utils).Validate(%sc)\n";
    cbm_parse_inc_file(&mt, &arena, inc_content);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run(sc As %Status) As %Status\n"
                                           "{\n"
                                           "    If $$$MyCheck(sc) { Quit $$$OK }\n"
                                           "    Quit $$$OK\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyApp.Utils.Validate"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

TEST(objectscript_macro_constant_no_extra_call) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMArena arena;
    cbm_arena_init(&arena);
    const char *inc_content = "ROUTINE MyApp.Include [Type=INC]\n"
                              "#define MyConst 42\n";
    cbm_parse_inc_file(&mt, &arena, inc_content);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run() As %Integer\n"
                                           "{\n"
                                           "    Set x = $$$MyConst\n"
                                           "    Quit x\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(!has_call(r, "$$$MyConst"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

TEST(objectscript_data_flows_instance_method_args) {
    CBMFileResult *r = extract("Class MyApp.Service Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set adapter = ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "    Do adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery"));
    const char *arg0 = NULL;
    int argc = find_call_args(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery", &arg0, NULL);
    ASSERT(argc == 1);
    ASSERT_NOT_NULL(arg0);
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H4: IRIS Export XML → UDL transcoder
 * =================================================================== */

#define SIMPLE_EXPORT                               \
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"  \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Simple\">\n"                \
    "<Super>%RegisteredObject</Super>\n"            \
    "<Method name=\"Hello\">\n"                     \
    "<ReturnType>%String</ReturnType>\n"            \
    "<Implementation><![CDATA[\n"                   \
    "\tQuit \"hello\"\n"                            \
    "]]></Implementation>\n"                        \
    "</Method>\n"                                   \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_simple_class) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, SIMPLE_EXPORT, (int)strlen(SIMPLE_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT_NOT_NULL(udl[0]);
    ASSERT(strstr(udl[0], "Test.Simple") != NULL);
    ASSERT(strstr(udl[0], "%RegisteredObject") != NULL);
    ASSERT(strstr(udl[0], "Hello") != NULL);
    ASSERT(strstr(udl[0], "Quit \"hello\"") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define CLASSMETHOD_EXPORT                                     \
    "<?xml version=\"1.0\"?>\n"                                \
    "<Export generator=\"Cache\" version=\"25\">\n"            \
    "<Class name=\"Test.CM\">\n"                               \
    "<Method name=\"Run\">\n"                                  \
    "<ClassMethod>1</ClassMethod>\n"                           \
    "<FormalSpec>pArg:%String,pFlag:%Boolean=0</FormalSpec>\n" \
    "<ReturnType>%Status</ReturnType>\n"                       \
    "<Implementation><![CDATA[\n"                              \
    "\tQuit $$$OK\n"                                           \
    "]]></Implementation>\n"                                   \
    "</Method>\n"                                              \
    "</Class>\n"                                               \
    "</Export>\n"

TEST(iris_export_xml_classmethod) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl =
        cbm_iris_export_to_udl(&arena, CLASSMETHOD_EXPORT, (int)strlen(CLASSMETHOD_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT(strstr(udl[0], "ClassMethod") != NULL);
    ASSERT(strstr(udl[0], "pArg") != NULL);
    ASSERT(strstr(udl[0], "pFlag") != NULL);
    ASSERT(strstr(udl[0], "%Status") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define MEMBER_EXPORT                               \
    "<?xml version=\"1.0\"?>\n"                     \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Members\">\n"               \
    "<Property name=\"Name\">\n"                    \
    "<Type>%String</Type>\n"                        \
    "<Parameter name=\"MAXLEN\" value=\"200\"/>\n"  \
    "</Property>\n"                                 \
    "<Parameter name=\"VERSION\">\n"                \
    "<Default>1</Default>\n"                        \
    "</Parameter>\n"                                \
    "<Index name=\"NameIdx\">\n"                    \
    "<Properties>Name</Properties>\n"               \
    "<Unique>1</Unique>\n"                          \
    "</Index>\n"                                    \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_property_parameter_index) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, MEMBER_EXPORT, (int)strlen(MEMBER_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT(strstr(udl[0], "Property Name") != NULL);
    ASSERT(strstr(udl[0], "%String") != NULL);
    ASSERT(strstr(udl[0], "Parameter VERSION") != NULL);
    ASSERT(strstr(udl[0], "Index NameIdx") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define CALLS_EXPORT                                \
    "<?xml version=\"1.0\"?>\n"                     \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Caller\">\n"                \
    "<Super>%RegisteredObject</Super>\n"            \
    "<Method name=\"Run\">\n"                       \
    "<ClassMethod>1</ClassMethod>\n"                \
    "<ReturnType>%Status</ReturnType>\n"            \
    "<Implementation><![CDATA[\n"                   \
    "\tSet obj = ##class(Target.Worker).%New()\n"   \
    "\tDo obj.Execute()\n"                          \
    "\tQuit $$$OK\n"                                \
    "]]></Implementation>\n"                        \
    "</Method>\n"                                   \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_calls_extracted) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, CALLS_EXPORT, (int)strlen(CALLS_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    CBMFileResult *r = cbm_extract_file(udl[0], (int)strlen(udl[0]), CBM_LANG_OBJECTSCRIPT_UDL, "t",
                                        "Caller.cls", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Target.Worker.Execute"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

#define MULTI_EXPORT                                                                          \
    "<?xml version=\"1.0\"?>\n"                                                               \
    "<Export generator=\"Cache\" version=\"25\">\n"                                           \
    "<Class name=\"Test.First\">\n"                                                           \
    "<Method name=\"One\"><Implementation><![CDATA[\tQuit 1\n]]></Implementation></Method>\n" \
    "</Class>\n"                                                                              \
    "<Class name=\"Test.Second\">\n"                                                          \
    "<Method name=\"Two\"><Implementation><![CDATA[\tQuit 2\n]]></Implementation></Method>\n" \
    "</Class>\n"                                                                              \
    "</Export>\n"

TEST(iris_export_xml_multi_class) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, MULTI_EXPORT, (int)strlen(MULTI_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 2);
    ASSERT(strstr(udl[0], "Test.First") != NULL || strstr(udl[1], "Test.First") != NULL);
    ASSERT(strstr(udl[0], "Test.Second") != NULL || strstr(udl[1], "Test.Second") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

/* ── #518 / #519: prose that BM25 can index ────────────────────────
 *
 * A Section carried only its heading and a config Module only its path, so a
 * question asked in words could not reach either. Both now carry the prose in
 * `docstring`, which is what nodes_fts indexes into its `body` column. */

TEST(markdown_section_body_becomes_docstring_issue518) {
    CBMFileResult *r = extract("# Installation\n"
                               "Run the bootstrap script to provision a workstation.\n"
                               "It installs the toolchain and seeds the cache.\n",
                               CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def_by_name(r, "Installation");
    ASSERT_NOT_NULL(d);
    ASSERT_STR_EQ(d->label, "Section");
    ASSERT_NOT_NULL(d->docstring);
    /* The prose — not the heading — is what makes the section findable. */
    ASSERT_NOT_NULL(strstr(d->docstring, "bootstrap script"));
    ASSERT_NOT_NULL(strstr(d->docstring, "seeds the cache"));
    /* Newlines collapse to single spaces so the 500-byte cap buys real words. */
    ASSERT_NULL(strchr(d->docstring, '\n'));
    cbm_free_result(r);
    PASS();
}

TEST(markdown_section_body_stops_at_next_heading_issue518) {
    CBMFileResult *r = extract("# Alpha\n"
                               "alphatext belongs to the first section.\n"
                               "\n"
                               "# Beta\n"
                               "betatext belongs to the second section.\n",
                               CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *alpha = find_def_by_name(r, "Alpha");
    const CBMDefinition *beta = find_def_by_name(r, "Beta");
    ASSERT_NOT_NULL(alpha);
    ASSERT_NOT_NULL(beta);
    ASSERT_NOT_NULL(alpha->docstring);
    ASSERT_NOT_NULL(beta->docstring);
    /* Each section owns ITS body: bleeding across the boundary would make every
     * heading match every word in the file. */
    ASSERT_NOT_NULL(strstr(alpha->docstring, "alphatext"));
    ASSERT_NULL(strstr(alpha->docstring, "betatext"));
    ASSERT_NOT_NULL(strstr(beta->docstring, "betatext"));
    ASSERT_NULL(strstr(beta->docstring, "alphatext"));
    cbm_free_result(r);
    PASS();
}

TEST(markdown_section_body_heading_only_has_no_docstring_issue518) {
    CBMFileResult *r = extract("# Lonely\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def_by_name(r, "Lonely");
    ASSERT_NOT_NULL(d);
    /* An empty body stays NULL rather than "": append_json_string drops empty
     * values, so an empty string would be a difference with no observable
     * meaning — and a docstring key that promises prose it does not have. */
    ASSERT_NULL(d->docstring);
    cbm_free_result(r);
    PASS();
}

TEST(markdown_section_body_capped_utf8_safe_issue518) {
    /* 400 three-byte codepoints (1200 bytes) guarantees the 500-byte cut lands
     * mid-sequence unless the backoff works. */
    char src[4096];
    int pos = snprintf(src, sizeof(src), "# Unicode\n");
    for (int i = 0; i < 400; i++) {
        pos += snprintf(src + pos, sizeof(src) - (size_t)pos, "\xe2\x9c\x93");
    }
    snprintf(src + pos, sizeof(src) - (size_t)pos, "\n");

    CBMFileResult *r = extract(src, CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def_by_name(r, "Unicode");
    ASSERT_NOT_NULL(d);
    ASSERT_NOT_NULL(d->docstring);
    size_t n = strlen(d->docstring);
    ASSERT_LTE((int)n, 500); /* MAX_COMMENT_LEN — fits the 2 KB properties buffer */
    ASSERT_GT((int)n, 0);
    /* Every byte must belong to a COMPLETE sequence: walk the string and check
     * each lead byte is followed by its full continuation run. */
    for (size_t i = 0; i < n;) {
        unsigned char c = (unsigned char)d->docstring[i];
        size_t need;
        if ((c & 0x80) == 0) {
            need = 1;
        } else if ((c & 0xE0) == 0xC0) {
            need = 2;
        } else if ((c & 0xF0) == 0xE0) {
            need = 3;
        } else if ((c & 0xF8) == 0xF0) {
            need = 4;
        } else {
            FAIL("stray UTF-8 continuation byte at a sequence start");
        }
        ASSERT_LTE((int)(i + need), (int)n); /* no truncated tail sequence */
        i += need;
    }
    cbm_free_result(r);
    PASS();
}

TEST(yaml_toplevel_description_promoted_to_module_issue519) {
    CBMFileResult *r = extract("name: my-action\n"
                               "description: Provisions an ephemeral build runner.\n"
                               "runs:\n"
                               "  using: node20\n",
                               CBM_LANG_YAML, "t", "META.yaml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->docstring);
    ASSERT_NOT_NULL(strstr(mod->docstring, "ephemeral build runner"));
    cbm_free_result(r);
    PASS();
}

TEST(yaml_block_scalar_description_promoted_issue519) {
    CBMFileResult *r = extract("name: my-action\n"
                               "description: |\n"
                               "  Provisions an ephemeral build runner\n"
                               "  and tears it down afterwards.\n",
                               CBM_LANG_YAML, "t", "META.yaml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->docstring);
    /* The `|` indicator itself must not survive into the indexed text. */
    ASSERT_NOT_NULL(strstr(mod->docstring, "tears it down"));
    ASSERT_NULL(strchr(mod->docstring, '|'));
    cbm_free_result(r);
    PASS();
}

TEST(yaml_summary_promoted_when_no_description_issue519) {
    CBMFileResult *r = extract("name: thing\n"
                               "summary: Aggregates telemetry from every shard.\n",
                               CBM_LANG_YAML, "t", "META.yaml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->docstring);
    ASSERT_NOT_NULL(strstr(mod->docstring, "every shard"));
    cbm_free_result(r);
    PASS();
}

TEST(json_toplevel_description_promoted_to_module_issue519) {
    CBMFileResult *r = extract("{\n"
                               "  \"name\": \"widget\",\n"
                               "  \"description\": \"Renders dashboards from graph queries.\"\n"
                               "}\n",
                               CBM_LANG_JSON, "t", "package.json");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NOT_NULL(mod->docstring);
    ASSERT_NOT_NULL(strstr(mod->docstring, "Renders dashboards"));
    /* The JSON string quotes are stripped — they are not part of the value. */
    ASSERT_NULL(strchr(mod->docstring, '"'));
    cbm_free_result(r);
    PASS();
}

TEST(config_description_only_at_top_level_issue519) {
    /* A nested `description` describes the nested thing, not the file. */
    CBMFileResult *r = extract("name: chart\n"
                               "values:\n"
                               "  description: nestedonly\n",
                               CBM_LANG_YAML, "t", "META.yaml");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT(mod->docstring == NULL || strstr(mod->docstring, "nestedonly") == NULL);
    cbm_free_result(r);
    PASS();
}

TEST(non_config_language_module_has_no_promoted_description_issue519) {
    /* The promotion is config-only: a Python file's Module node must not pick
     * up a variable that merely happens to be called `description`. */
    CBMFileResult *r =
        extract("description = 'not a config file'\n", CBM_LANG_PYTHON, "t", "conf.py");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *mod = find_module_def(r);
    ASSERT_NOT_NULL(mod);
    ASSERT_NULL(mod->docstring);
    cbm_free_result(r);
    PASS();
}

/* ── Result compaction (cbm_result_compact) ────────────────────────────── */

static const char *COMPACT_PY_SRC = "import os\n"
                                    "BASE = 'api'\n"
                                    "URL = f'{BASE}/users/me'\n"
                                    "def url_candidate():\n"
                                    "    return client(URL)\n"
                                    "from typing import List\n"
                                    "\n"
                                    "@app.route(\"/items\")\n"
                                    "def list_items(limit: int, offset: int = 0) -> List[str]:\n"
                                    "    \"\"\"Return items.\"\"\"\n"
                                    "    rows = fetch(limit, offset=offset)\n"
                                    "    total = len(rows)\n"
                                    "    for r in rows:\n"
                                    "        print(r, total)\n"
                                    "    return rows\n"
                                    "\n"
                                    "class Store(Base):\n"
                                    "    def get(self, key):\n"
                                    "        return self.data.get(key, None)\n"
                                    "\n"
                                    "    def put(self, key, value):\n"
                                    "        self.data[key] = value\n"
                                    "        return fetch(key, value)\n";

static bool cmp_str_eq(const char *a, const char *b) {
    if (!a || !b) {
        return a == b;
    }
    return strcmp(a, b) == 0;
}

static bool cmp_list_eq(const char **a, const char **b) {
    if (!a || !b) {
        return a == b;
    }
    int i = 0;
    for (; a[i] && b[i]; i++) {
        if (strcmp(a[i], b[i]) != 0) {
            return false;
        }
    }
    return a[i] == NULL && b[i] == NULL;
}

static size_t arena_capacity(const CBMArena *a) {
    size_t total = 0;
    for (int i = 0; i < a->nblocks; i++) {
        total += a->block_sizes[i];
    }
    return total;
}

TEST(extract_compact_keeps_every_field_and_shrinks_the_arena) {
    CBMFileResult *r = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "svc.py");
    CBMFileResult *ref = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "svc.py");
    ASSERT_NOT_NULL(r);
    ASSERT_NOT_NULL(ref);
    ASSERT_FALSE(r->has_error);
    ASSERT(r->defs.count >= 4);  /* list_items, Store, get, put (+ module) */
    ASSERT(r->calls.count >= 4); /* fetch x2, len, print, get */
    ASSERT(r->usages.count >= 1);
    ASSERT(r->imports.count >= 2);
    bool saw_args = false;
    for (int i = 0; i < ref->calls.count; i++) {
        saw_args = saw_args || ref->calls.items[i].arg_count > 0;
    }
    ASSERT(saw_args);

    size_t used_before = cbm_arena_total(&r->arena);
    size_t cap_before = arena_capacity(&r->arena);
    cbm_result_compact(r);

    const CBMCall *candidate = find_call_in_func(r, "client", "url_candidate");
    ASSERT_NOT_NULL(candidate);
    ASSERT_GTE(candidate->arg_count, 1);
    ASSERT_STR_EQ(candidate->args[0].value, "api/users/me");
    ASSERT_STR_EQ(candidate->args[0].url_value, "/api/users/me");
    uintptr_t candidate_addr = (uintptr_t)candidate->args[0].url_value;
    uintptr_t arena_addr = (uintptr_t)r->arena.blocks[0];
    ASSERT(candidate_addr >= arena_addr);
    ASSERT(candidate_addr - arena_addr < r->arena.used);

    /* One exact block: capacity == bytes used, no dead headroom. */
    ASSERT_EQ(r->arena.nblocks, 1);
    ASSERT_EQ(arena_capacity(&r->arena), cbm_arena_total(&r->arena));
    ASSERT(cbm_arena_total(&r->arena) < used_before);
    ASSERT(arena_capacity(&r->arena) < cap_before);
    ASSERT_EQ(r->defs.cap, r->defs.count);
    ASSERT_EQ(r->calls.cap, r->calls.count);
    ASSERT_EQ(r->usages.cap, r->usages.count);

    /* Every field survives, by value. */
    ASSERT_EQ(r->defs.count, ref->defs.count);
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *a = &r->defs.items[i];
        const CBMDefinition *b = &ref->defs.items[i];
        ASSERT(cmp_str_eq(a->name, b->name));
        ASSERT(cmp_str_eq(a->qualified_name, b->qualified_name));
        ASSERT(cmp_str_eq(a->label, b->label));
        ASSERT(cmp_str_eq(a->file_path, b->file_path));
        ASSERT(cmp_str_eq(a->signature, b->signature));
        ASSERT(cmp_str_eq(a->return_type, b->return_type));
        ASSERT(cmp_str_eq(a->docstring, b->docstring));
        ASSERT(cmp_str_eq(a->parent_class, b->parent_class));
        ASSERT(cmp_str_eq(a->route_path, b->route_path));
        ASSERT(cmp_str_eq(a->body_tokens, b->body_tokens));
        ASSERT(cmp_str_eq(a->structural_profile, b->structural_profile));
        ASSERT(cmp_list_eq(a->decorators, b->decorators));
        ASSERT(cmp_list_eq(a->base_classes, b->base_classes));
        ASSERT(cmp_list_eq(a->param_names, b->param_names));
        ASSERT(cmp_list_eq(a->param_types, b->param_types));
        ASSERT(cmp_list_eq(a->return_types, b->return_types));
        ASSERT_EQ(a->signature_param_count, b->signature_param_count);
        for (int k = 0; k < a->signature_param_count; k++) {
            ASSERT(cmp_str_eq(a->signature_param_types[k], b->signature_param_types[k]));
        }
        ASSERT_EQ(a->start_line, b->start_line);
        ASSERT_EQ(a->end_line, b->end_line);
        ASSERT_EQ(a->complexity, b->complexity);
        ASSERT_EQ(a->lines, b->lines);
        ASSERT_EQ(a->is_exported, b->is_exported);
        ASSERT_EQ(a->fingerprint_k, b->fingerprint_k);
        if (a->fingerprint_k > 0) {
            ASSERT_NOT_NULL(a->fingerprint);
            ASSERT(memcmp(a->fingerprint, b->fingerprint,
                          (size_t)a->fingerprint_k * sizeof(uint32_t)) == 0);
        }
    }
    ASSERT_EQ(r->calls.count, ref->calls.count);
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *a = &r->calls.items[i];
        const CBMCall *b = &ref->calls.items[i];
        ASSERT(cmp_str_eq(a->callee_name, b->callee_name));
        ASSERT(cmp_str_eq(a->enclosing_func_qn, b->enclosing_func_qn));
        ASSERT(cmp_str_eq(a->first_string_arg, b->first_string_arg));
        ASSERT_EQ(a->arg_count, b->arg_count);
        ASSERT_EQ(a->start_line, b->start_line);
        ASSERT_EQ(a->site_start_byte, b->site_start_byte);
        ASSERT_EQ(a->site_end_byte, b->site_end_byte);
        ASSERT_EQ(a->is_method, b->is_method);
        for (int k = 0; k < a->arg_count; k++) {
            ASSERT(cmp_str_eq(a->args[k].expr, b->args[k].expr));
            ASSERT(cmp_str_eq(a->args[k].value, b->args[k].value));
            ASSERT(cmp_str_eq(a->args[k].url_value, b->args[k].url_value));
            ASSERT(cmp_str_eq(a->args[k].keyword, b->args[k].keyword));
            ASSERT_EQ(a->args[k].index, b->args[k].index);
        }
    }
    ASSERT_EQ(r->usages.count, ref->usages.count);
    for (int i = 0; i < r->usages.count; i++) {
        ASSERT(cmp_str_eq(r->usages.items[i].ref_name, ref->usages.items[i].ref_name));
        ASSERT(cmp_str_eq(r->usages.items[i].enclosing_func_qn,
                          ref->usages.items[i].enclosing_func_qn));
        ASSERT_EQ(r->usages.items[i].kind, ref->usages.items[i].kind);
        ASSERT_EQ(r->usages.items[i].site_start_byte, ref->usages.items[i].site_start_byte);
        ASSERT_EQ(r->usages.items[i].is_member_access, ref->usages.items[i].is_member_access);
    }
    ASSERT_EQ(r->imports.count, ref->imports.count);
    for (int i = 0; i < r->imports.count; i++) {
        ASSERT(cmp_str_eq(r->imports.items[i].local_name, ref->imports.items[i].local_name));
        ASSERT(cmp_str_eq(r->imports.items[i].module_path, ref->imports.items[i].module_path));
    }
    ASSERT_EQ(r->rw.count, ref->rw.count);
    ASSERT_EQ(r->type_refs.count, ref->type_refs.count);
    ASSERT(cmp_str_eq(r->module_qn, ref->module_qn));
    ASSERT(cmp_list_eq(r->exports, ref->exports));

    /* Interned by content: two records with the same enclosing QN share one
     * copy after compaction. */
    bool shared = false;
    for (int i = 0; i < r->calls.count && !shared; i++) {
        for (int j = i + 1; j < r->calls.count && !shared; j++) {
            if (r->calls.items[i].enclosing_func_qn && r->calls.items[j].enclosing_func_qn &&
                strcmp(r->calls.items[i].enclosing_func_qn, r->calls.items[j].enclosing_func_qn) ==
                    0) {
                shared = r->calls.items[i].enclosing_func_qn == r->calls.items[j].enclosing_func_qn;
            }
        }
    }
    ASSERT(shared);

    /* The arena stays usable for the cross-file pass: growth restarts at the
     * small append block, never at twice the compact block. (It restarted at
     * the 64 KB default until 2026-09-17: the cross-file pass appends a few
     * resolved calls, so that block was ~60 KB of untouched memory per
     * appended-to result — 0.5 GB of the worker's peak on the Go corpus.
     * See CBM_ARENA_APPEND_BLOCK.) */
    char *later = cbm_arena_strdup(&r->arena, "appended after compaction");
    ASSERT_NOT_NULL(later);
    ASSERT_EQ(r->arena.nblocks, 2);
    ASSERT_EQ(r->arena.block_sizes[1], CBM_ARENA_APPEND_BLOCK);

    cbm_free_result(r);
    cbm_free_result(ref);
    PASS();
}

TEST(extract_compact_is_idempotent_and_survives_empty_results) {
    CBMFileResult *r = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "svc.py");
    ASSERT_NOT_NULL(r);
    cbm_result_compact(r);
    size_t once = cbm_arena_total(&r->arena);
    int defs = r->defs.count;
    cbm_result_compact(r);
    ASSERT_EQ(cbm_arena_total(&r->arena), once);
    ASSERT_EQ(r->defs.count, defs);
    ASSERT_EQ(r->arena.nblocks, 1);
    cbm_free_result(r);

    CBMFileResult *empty = extract("", CBM_LANG_PYTHON, "t", "empty.py");
    ASSERT_NOT_NULL(empty);
    cbm_result_compact(empty);
    ASSERT_EQ(empty->defs.count + empty->calls.count, empty->defs.count + empty->calls.count);
    ASSERT(empty->arena.nblocks >= 1);
    cbm_free_result(empty);

    cbm_result_compact(NULL); /* no-op */
    PASS();
}

/* ── Result spill (result_spill.c): park -> load is a faithful round trip ── */

TEST(extract_spill_round_trip_keeps_every_field) {
    CBMFileResult *r = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "svc.py");
    CBMFileResult *ref = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "svc.py");
    ASSERT_NOT_NULL(r);
    ASSERT_NOT_NULL(ref);
    cbm_result_compact(r);
    cbm_result_compact(ref);

    char dir[512];
    snprintf(dir, sizeof(dir), "%s/cbm_spill_XXXXXX", cbm_tmpdir());
    ASSERT_NOT_NULL(cbm_mkdtemp(dir));
    cbm_result_spill_t *sp = cbm_result_spill_open(dir, 2, 3);
    ASSERT_NOT_NULL(sp);
    ASSERT_FALSE(cbm_result_spill_has(sp, 1));

    /* A result that is not compacted (two blocks) is refused, untouched. */
    CBMFileResult *raw = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "raw.py");
    ASSERT_NOT_NULL(raw);
    if (raw->arena.nblocks > 1) {
        ASSERT_FALSE(cbm_result_spill_park(sp, 0, 2, raw));
        ASSERT_FALSE(cbm_result_spill_has(sp, 2));
    }
    cbm_free_result(raw);

    /* Park frees the in-memory result; the slot is then on disk. Each
     * precondition is named so a refusal says which one it was. */
    int defs_before = r->defs.count;
    int calls_before = r->calls.count;
    ASSERT_EQ(r->arena.nblocks, 1);
    ASSERT_EQ(r->owned_result_count, 0);
    ASSERT_NOT_NULL(r->cached_tree); /* the extraction helper keeps the tree: park drops it */
    ASSERT_TRUE(cbm_result_spill_park(sp, 1, 1, r));
    r = NULL;
    ASSERT_TRUE(cbm_result_spill_has(sp, 1));
    int peek_defs = -1;
    int peek_impls = -1;
    cbm_result_spill_peek_counts(sp, 1, &peek_defs, &peek_impls);
    ASSERT_EQ(peek_defs, defs_before);
    ASSERT_EQ(peek_impls, 0);

    CBMFileResult *back = cbm_result_spill_load(sp, 1);
    ASSERT_NOT_NULL(back);
    ASSERT_NULL(back->cached_tree);
    ASSERT_EQ(back->arena.nblocks, 1);
    ASSERT_EQ(back->defs.count, defs_before);
    ASSERT_EQ(back->calls.count, calls_before);
    for (int i = 0; i < back->defs.count; i++) {
        const CBMDefinition *a = &back->defs.items[i];
        const CBMDefinition *b = &ref->defs.items[i];
        ASSERT(cmp_str_eq(a->name, b->name));
        ASSERT(cmp_str_eq(a->qualified_name, b->qualified_name));
        ASSERT(cmp_str_eq(a->label, b->label));
        ASSERT(cmp_str_eq(a->file_path, b->file_path));
        ASSERT(cmp_str_eq(a->signature, b->signature));
        ASSERT(cmp_str_eq(a->docstring, b->docstring));
        ASSERT(cmp_list_eq(a->decorators, b->decorators));
        ASSERT(cmp_list_eq(a->param_names, b->param_names));
        ASSERT_EQ(a->start_line, b->start_line);
        ASSERT_EQ(a->fingerprint_k, b->fingerprint_k);
        if (a->fingerprint_k > 0) {
            ASSERT(memcmp(a->fingerprint, b->fingerprint,
                          (size_t)a->fingerprint_k * sizeof(uint32_t)) == 0);
        }
        /* Every pointer now lives in the loaded block, none in the old one. */
        const char *lo = back->arena.blocks[0];
        const char *hi = lo + back->arena.used;
        ASSERT(a->name >= lo && a->name < hi);
        ASSERT(a->qualified_name >= lo && a->qualified_name < hi);
    }
    for (int i = 0; i < back->calls.count; i++) {
        const CBMCall *a = &back->calls.items[i];
        const CBMCall *b = &ref->calls.items[i];
        ASSERT(cmp_str_eq(a->callee_name, b->callee_name));
        ASSERT(cmp_str_eq(a->enclosing_func_qn, b->enclosing_func_qn));
        ASSERT_EQ(a->arg_count, b->arg_count);
        for (int k = 0; k < a->arg_count; k++) {
            ASSERT(cmp_str_eq(a->args[k].expr, b->args[k].expr));
        }
    }
    ASSERT_EQ(back->usages.count, ref->usages.count);
    for (int i = 0; i < back->usages.count; i++) {
        ASSERT(cmp_str_eq(back->usages.items[i].ref_name, ref->usages.items[i].ref_name));
    }
    ASSERT(cmp_str_eq(back->module_qn, ref->module_qn));
    ASSERT(cmp_list_eq(back->exports, ref->exports));

    const CBMCall *candidate = find_call_in_func(back, "client", "url_candidate");
    ASSERT_NOT_NULL(candidate);
    ASSERT_GTE(candidate->arg_count, 1);
    ASSERT_STR_EQ(candidate->args[0].value, "api/users/me");
    ASSERT_STR_EQ(candidate->args[0].url_value, "/api/users/me");
    uintptr_t candidate_addr = (uintptr_t)candidate->args[0].url_value;
    uintptr_t arena_addr = (uintptr_t)back->arena.blocks[0];
    ASSERT(candidate_addr >= arena_addr);
    ASSERT(candidate_addr - arena_addr < back->arena.used);

    /* Loading twice yields two independent copies. */
    CBMFileResult *again = cbm_result_spill_load(sp, 1);
    ASSERT_NOT_NULL(again);
    ASSERT(again->arena.blocks[0] != back->arena.blocks[0]);
    ASSERT_EQ(again->defs.count, defs_before);
    int64_t parked = 0;
    int64_t bytes = 0;
    int64_t loads = 0;
    cbm_result_spill_stats(sp, &parked, &bytes, &loads);
    ASSERT_EQ(parked, 1);
    ASSERT(bytes > 0);
    ASSERT_EQ(loads, 2);

    cbm_free_result(again);
    cbm_free_result(back);
    cbm_free_result(ref);
    cbm_result_spill_close(sp);
    cbm_rmdir(dir);
    PASS();
}

/* The low-disk guard, pinned through the free-space seam rather than the host
 * disk: one byte under the floor refuses (spilling onto a nearly full disk is
 * a worse failure than the memory pressure it relieves), the floor itself
 * opens. The runner pins ample space everywhere else; restored before asserts. */
TEST(extract_spill_refuses_below_the_free_disk_floor) {
    char dir[512];
    snprintf(dir, sizeof(dir), "%s/cbm_spill_XXXXXX", cbm_tmpdir());
    ASSERT_NOT_NULL(cbm_mkdtemp(dir));

    size_t floor_bytes = cbm_result_spill_free_floor_bytes_for_tests();
    size_t saved = cbm_result_spill_pin_free_bytes_for_tests(floor_bytes - 1);
    cbm_result_spill_t *below = cbm_result_spill_open(dir, 1, 1);
    (void)cbm_result_spill_pin_free_bytes_for_tests(floor_bytes);
    cbm_result_spill_t *at = cbm_result_spill_open(dir, 1, 1);
    (void)cbm_result_spill_pin_free_bytes_for_tests(saved);

    bool refused = below == NULL;
    bool opened = at != NULL;
    cbm_result_spill_close(below);
    cbm_result_spill_close(at);
    char spill_sub[600];
    snprintf(spill_sub, sizeof(spill_sub), "%s/spill", dir);
    cbm_rmdir(spill_sub);
    cbm_rmdir(dir);

    ASSERT_EQ(floor_bytes, (size_t)10 * 1024 * 1024 * 1024);
    ASSERT_TRUE(refused);
    ASSERT_TRUE(opened);
    PASS();
}

/* ── A skipped file gets no LSP walk, per-file or cross-file ── */

/* CBM_TEST_LSP_SKIP_ON names the file: the result carries lsp_skipped, the
 * per-file LSP walk did not run (no LSP-resolved calls), and the shared
 * cross-file dispatcher returns without touching it. The unified extractor
 * definitions are still there. Nothing in production sets lsp_skipped from a
 * clock any more — this pins what the flag DOES, which is what the cross-file
 * dispatcher and the per-file walks both have to honour. */
TEST(extract_lsp_skipped_file_gets_no_walk) {
    cbm_setenv("CBM_TEST_LSP_SKIP_ON", "budget_share.py", 1);
    CBMFileResult *skipped = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "budget_share.py");
    cbm_unsetenv("CBM_TEST_LSP_SKIP_ON");
    CBMFileResult *walked = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "walked.py");
    ASSERT_NOT_NULL(skipped);
    ASSERT_NOT_NULL(walked);
    ASSERT_TRUE(skipped->lsp_skipped);
    ASSERT_FALSE(walked->lsp_skipped);
    ASSERT_GT(skipped->defs.count, 0);                      /* the unified extractor still ran */
    ASSERT_TRUE(skipped->defs.count <= walked->defs.count); /* the LSP walk adds its own defs */
    ASSERT_EQ(skipped->resolved_calls.count, 0);

    /* The dispatcher is the one gate for every language and both drivers. */
    int calls_before = skipped->calls.count;
    cbm_pxc_dispatch_file(CBM_LANG_PYTHON, skipped, COMPACT_PY_SRC, (int)strlen(COMPACT_PY_SRC),
                          "budget_share.py", "t", NULL, NULL, NULL, 0, NULL, NULL, 0, NULL, NULL);
    ASSERT_EQ(skipped->calls.count, calls_before);
    ASSERT_EQ(skipped->resolved_calls.count, 0);

    cbm_free_result(skipped);
    cbm_free_result(walked);
    PASS();
}

/* CBM_TEST_WALK_BUDGET_NODES stops the unified walk after that many nodes: the
 * result is walk_truncated, therefore lsp_skipped, and the definitions the walk
 * had not reached are the only loss. There is no budget by default (see
 * CBM_WALK_MAX_NODES_DEFAULT), so this drives the same node counter an operator
 * would set with CBM_WALK_MAX_NODES rather than a mechanism of its own. */
TEST(extract_walk_truncated_when_a_node_budget_is_set) {
    cbm_setenv("CBM_TEST_WALK_BUDGET_NODES", "8", 1);
    CBMFileResult *cut = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "walk_budget.py");
    cbm_unsetenv("CBM_TEST_WALK_BUDGET_NODES");
    CBMFileResult *full = extract(COMPACT_PY_SRC, CBM_LANG_PYTHON, "t", "walk_full.py");
    ASSERT_NOT_NULL(cut);
    ASSERT_NOT_NULL(full);
    ASSERT_TRUE(cut->walk_truncated);
    ASSERT_TRUE(cut->lsp_skipped);
    ASSERT_FALSE(full->walk_truncated);
    ASSERT_TRUE(cut->usages.count <= full->usages.count);
    ASSERT_TRUE(cut->calls.count <= full->calls.count);
    cbm_free_result(cut);
    cbm_free_result(full);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Deep nesting: the syntax-tree walkers must not spend stack per level
 *
 * Extraction runs on pipeline worker threads whose stack is
 * CBM_WORKER_STACK_SIZE (src/pipeline/worker_pool.h), not on the test runner's
 * main thread, whose size depends on the platform and its rlimit. Each probe
 * below therefore runs cbm_extract_file on a thread of exactly that size, so
 * a walker that recurses once per nesting level runs out of stack at the
 * depth it would in the pipeline. On POSIX the thread lives in a forked child
 * and an overflow surfaces as the child's killing signal instead of taking
 * the runner with it (the pattern of tests/test_stack_overflow.c); Windows
 * runs it in-process, where a real overflow is a visible runner abort. A
 * probe returns 0 when every expectation held and prints what did not.
 *
 * DEEP_NEST_LEVELS: a walker frame holds at least its saved frame pointer and
 * return address plus the 32-byte TSNode it passes down (on arm64 a TSNode is
 * passed by reference to a copy in the caller's frame), 48 bytes, so 200,000
 * frames need 9.6 MB — past the 8 MB worker stack even at that floor;
 * measured frames are larger and the sanitizer build adds red zones. The
 * parser is not the limit: tree-sitter keeps the nesting on its heap parse
 * stack and its node and cursor helpers are iterative, so the depth is the
 * walker's problem alone. The fixtures nest parentheses, which copy no text
 * per level (a nested call copies its argument text at every level, which is
 * what makes the stack_overflow_b suite slow).
 * ═══════════════════════════════════════════════════════════════════ */

enum { DEEP_NEST_LEVELS = 200000 };

typedef int (*deep_probe_fn)(void);

typedef struct {
    deep_probe_fn fn;
    int rc;
} deep_probe_job_t;

static void *deep_probe_thread_main(void *arg) {
    deep_probe_job_t *job = (deep_probe_job_t *)arg;
    job->rc = job->fn();
    return NULL;
}

/* 0 when the probe passed, its own code otherwise, 2 if no thread came up. */
static int deep_probe_on_worker_stack(deep_probe_fn fn) {
    deep_probe_job_t job = {fn, 3};
    cbm_thread_t thread;
    if (cbm_thread_create(&thread, CBM_WORKER_STACK_SIZE, deep_probe_thread_main, &job) != 0) {
        return 2;
    }
    (void)cbm_thread_join(&thread);
    return job.rc;
}

/* 1 when the probe passed; otherwise `why` says what happened. */
static int deep_probe_passed(deep_probe_fn fn, char *why, size_t why_len) {
#if defined(_WIN32)
    int rc = deep_probe_on_worker_stack(fn);
    if (rc != 0) {
        snprintf(why, why_len, "probe returned %d", rc);
    }
    return rc == 0;
#else
    fflush(NULL);
    pid_t pid = fork();
    if (pid < 0) {
        snprintf(why, why_len, "fork failed");
        return 0;
    }
    if (pid == 0) {
        int rc = deep_probe_on_worker_stack(fn);
        fflush(NULL);
        _exit(rc);
    }
    int status = 0;
    (void)waitpid(pid, &status, 0);
    if (WIFSIGNALED(status)) {
        snprintf(why, why_len,
                 "extraction killed by signal %d on a worker-sized stack: a walker recursed once "
                 "per nesting level",
                 WTERMSIG(status));
        return 0;
    }
    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
        snprintf(why, why_len, "probe returned %d", WIFEXITED(status) ? WEXITSTATUS(status) : -1);
        return 0;
    }
    return 1;
#endif
}

/* head, `levels` times '(', core, `levels` times ')', tail. *core_at receives
 * the byte offset of core. */
static char *build_nested_source(const char *head, const char *core, const char *tail, int levels,
                                 uint32_t *core_at) {
    size_t head_len = strlen(head);
    size_t core_len = strlen(core);
    size_t tail_len = strlen(tail);
    char *src = malloc(head_len + core_len + tail_len + 2 * (size_t)levels + 1);
    if (!src) {
        return NULL;
    }
    char *w = src;
    memcpy(w, head, head_len);
    w += head_len;
    memset(w, '(', (size_t)levels);
    w += levels;
    *core_at = (uint32_t)(w - src);
    memcpy(w, core, core_len);
    w += core_len;
    memset(w, ')', (size_t)levels);
    w += levels;
    memcpy(w, tail, tail_len + 1);
    return src;
}

/* `$x = ((...((f))...))(...);` — a first-class callable whose callee sits under
 * DEEP_NEST_LEVELS parentheses. PHP, because its first-class callable syntax
 * is the path that hands a parenthesised callee to terminal_callee_leaf
 * (extract_calls.c): the leaf finder steps into one named child per wrapper
 * node that has no terminal field, while every ordinary call path first needs
 * a textual callee name, which the field resolver only yields for identifier
 * and member shapes whose leaf sits one or two levels down (a member chain
 * `a.b.c()` stops at its `property`; nested calls `f(f(f()))` are arguments,
 * visited by the explicit-stack walker). Expected: the exact occurrence the
 * leaf finder names — one CALL_REFERENCE usage of `f` at the byte of the `f`
 * token — in a cleanly parsed file. */
static int deep_callee_chain_probe(void) {
    uint32_t f_at = 0;
    char *src = build_nested_source("<?php\n$x = ", "f", "(...);\n", DEEP_NEST_LEVELS, &f_at);
    if (!src) {
        return 4;
    }
    CBMFileResult *r = extract(src, CBM_LANG_PHP, "t", "deep_callee.php");
    int rc = 0;
    if (!r || r->has_error || r->parse_incomplete) {
        printf("    deep callee: extraction failed or the parse was not clean\n");
        rc = 1;
    } else {
        int references = 0;
        for (int i = 0; i < r->usages.count; i++) {
            const CBMUsage *u = &r->usages.items[i];
            if (u->kind != CBM_USAGE_CALL_REFERENCE || !u->ref_name ||
                strcmp(u->ref_name, "f") != 0) {
                continue;
            }
            references++;
            if (u->site_start_byte != f_at || u->site_end_byte != f_at + 1) {
                printf("    deep callee: reference site %u-%u, expected %u-%u\n",
                       u->site_start_byte, u->site_end_byte, f_at, f_at + 1);
                rc = 1;
            }
        }
        if (references != 1) {
            printf("    deep callee: %d CALL_REFERENCE usages of f, expected 1\n", references);
            rc = 1;
        }
    }
    if (r) {
        cbm_free_result(r);
    }
    free(src);
    return rc;
}

TEST(extract_deep_callee_chain_completes) {
    char why[160];
    if (!deep_probe_passed(deep_callee_chain_probe, why, sizeof(why))) {
        FAIL(why);
    }
    PASS();
}

/* One invalid token at the bottom of DEEP_NEST_LEVELS parentheses. Every
 * enclosing parenthesized_expression then carries ts_node_has_error without
 * being an ERROR node, which is the chain cbm_collect_error_regions (cbm.c)
 * descends: it steps into a child that contains an error and stops at the
 * top-most ERROR or MISSING node. Nested ERROR nodes would not do — the walk
 * never enters an ERROR subtree, so they cost it one level. Expected: one
 * region, on the line of the nest only, with the neighbouring definition
 * intact and the file still usable. */
static int deep_error_regions_probe(void) {
    uint32_t core_at = 0;
    char *src = build_nested_source("def ok():\n    return 1\nx = ", "1 2", "\ny = ok()\n",
                                    DEEP_NEST_LEVELS, &core_at);
    if (!src) {
        return 4;
    }
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "deep_error.py");
    int rc = 0;
    if (!r) {
        printf("    deep error regions: extraction failed\n");
        rc = 1;
    } else {
        if (!r->parse_incomplete || r->error_region_count != 1 || !r->error_ranges ||
            strcmp(r->error_ranges, "3-3") != 0) {
            printf("    deep error regions: incomplete=%d count=%d ranges=%s, expected one "
                   "region 3-3\n",
                   r->parse_incomplete ? 1 : 0, r->error_region_count,
                   r->error_ranges ? r->error_ranges : "(none)");
            rc = 1;
        }
        if (r->parse_unusable) {
            printf("    deep error regions: one line of five must not make the file unusable\n");
            rc = 1;
        }
        if (!has_def(r, "Function", "ok")) {
            printf("    deep error regions: the definition next to the nest was lost\n");
            rc = 1;
        }
        cbm_free_result(r);
    }
    free(src);
    return rc;
}

TEST(extract_deep_error_regions_complete) {
    char why[160];
    if (!deep_probe_passed(deep_error_regions_probe, why, sizeof(why))) {
        FAIL(why);
    }
    PASS();
}

/* `f(cb=((...(obj.handler)...)))`: a labeled argument whose value is a bound
 * method under LABELED_WRAPPERS parentheses. The usage pass classifies
 * `handler` by climbing the wrappers (python_direct_callable_attribute_site, a
 * loop) and then asking is_direct_argument_value, whose one recursive step
 * moved from the value to the labeled argument holding it. The grammar never
 * nests a labeled argument inside another's value, so that step is bounded
 * and no stack depth is at stake; what the test pins is the answer across the
 * conversion of that step to a loop: the usage is a callable-value candidate
 * whose site is the outermost wrapper, and the keyword `cb` is no usage. The
 * bare form pins the site on the attribute itself. */
enum { LABELED_WRAPPERS = 2000 };

static int handler_candidate_site(const CBMFileResult *r, uint32_t expect_start,
                                  uint32_t expect_end, const char *form) {
    int seen = 0;
    int rc = 0;
    for (int i = 0; i < r->usages.count; i++) {
        const CBMUsage *u = &r->usages.items[i];
        if (!u->ref_name) {
            continue;
        }
        if (strcmp(u->ref_name, "cb") == 0) {
            printf("    %s argument: the keyword label became a usage\n", form);
            rc = 1;
        }
        if (strcmp(u->ref_name, "handler") != 0) {
            continue;
        }
        seen++;
        if (!u->may_be_call_reference || u->site_start_byte != expect_start ||
            u->site_end_byte != expect_end) {
            printf("    %s argument: handler candidate=%d site %u-%u, expected candidate site "
                   "%u-%u\n",
                   form, u->may_be_call_reference ? 1 : 0, u->site_start_byte, u->site_end_byte,
                   expect_start, expect_end);
            rc = 1;
        }
    }
    if (seen != 1) {
        printf("    %s argument: %d usages of handler, expected 1\n", form, seen);
        rc = 1;
    }
    return rc;
}

static int deep_argument_nesting_probe(void) {
    const uint32_t attribute_len = (uint32_t)strlen("obj.handler");
    uint32_t core_at = 0;
    char *src = build_nested_source("f(cb=", "obj.handler", ")\n", LABELED_WRAPPERS, &core_at);
    if (!src) {
        return 4;
    }
    int rc = 0;
    CBMFileResult *wrapped = extract(src, CBM_LANG_PYTHON, "t", "deep_arg.py");
    if (!wrapped || wrapped->has_error || wrapped->parse_incomplete) {
        printf("    wrapped argument: extraction failed or the parse was not clean\n");
        rc = 1;
    } else {
        rc |= handler_candidate_site(wrapped, core_at - LABELED_WRAPPERS,
                                     core_at + attribute_len + LABELED_WRAPPERS, "wrapped");
    }
    if (wrapped) {
        cbm_free_result(wrapped);
    }
    free(src);

    CBMFileResult *bare = extract("f(cb=obj.handler)\n", CBM_LANG_PYTHON, "t", "bare_arg.py");
    if (!bare || bare->has_error || bare->parse_incomplete) {
        printf("    bare argument: extraction failed or the parse was not clean\n");
        rc = 1;
    } else {
        rc |= handler_candidate_site(bare, 5, 5 + attribute_len, "bare");
    }
    if (bare) {
        cbm_free_result(bare);
    }
    return rc;
}

TEST(extract_deep_argument_nesting_completes) {
    char why[160];
    if (!deep_probe_passed(deep_argument_nesting_probe, why, sizeof(why))) {
        FAIL(why);
    }
    PASS();
}

/* #1527: the call-context metrics find each call's innermost enclosing
 * Function/Method with a line sweep instead of scanning every def per call.
 * The sweep must give the scan's exact answer -- smallest span, ties to the
 * lowest def index -- on nested, overlapping, same-line, malformed
 * (end < start) and unnamed/non-callable ranges. Fixed-seed generator:
 * deterministic, many shapes. */
static uint32_t enc_rand(uint32_t *state) {
    *state = (*state * 1103515245u) + 12345u;
    return (*state >> 16) & 0x7fffu;
}

TEST(extract_enclosing_sweep_matches_scan_issue1527) {
    static const char *const labels[] = {"Function", "Method", "Class", "Variable"};
    uint32_t seed = 1527;
    for (int round = 0; round < 40; round++) {
        CBMArena a;
        cbm_arena_init(&a);
        CBMFileResult r;
        memset(&r, 0, sizeof(r));
        int ndefs = round == 0 ? 0 : (int)(enc_rand(&seed) % 300);
        int ncalls = (int)(enc_rand(&seed) % 1500) + 1;
        int max_line = (int)(enc_rand(&seed) % 400) + 5;
        for (int i = 0; i < ndefs; i++) {
            CBMDefinition d;
            memset(&d, 0, sizeof(d));
            d.name = (enc_rand(&seed) % 10) == 0 ? NULL : "f";
            d.label = labels[enc_rand(&seed) % 4];
            d.start_line = 1 + (enc_rand(&seed) % (uint32_t)max_line);
            int len = (int)(enc_rand(&seed) % 60) - 3; /* a few malformed end < start */
            d.end_line = (uint32_t)((int)d.start_line + len > 0 ? (int)d.start_line + len : 0);
            cbm_defs_push(&r.defs, &a, d);
        }
        for (int i = 0; i < ncalls; i++) {
            CBMCall c;
            memset(&c, 0, sizeof(c));
            c.callee_name = "g";
            c.start_line = (int)(enc_rand(&seed) % (uint32_t)(max_line + 10)) - 2;
            cbm_calls_push(&r.calls, &a, c);
        }
        ASSERT_EQ(cbm_test_enclosing_sweep_mismatches(&r), 0);
        cbm_arena_destroy(&a);
    }
    PASS();
}

/* Python namespace facts: provenance is ordered, content-only and independently
 * owned. These tests do not enable any reexport resolution. */
static bool py_facts_equal(const CBMPyNamespaceFacts *a, const CBMPyNamespaceFacts *b) {
    if (!cbm_py_namespace_facts_valid(a) || !cbm_py_namespace_facts_valid(b) ||
        a->version != b->version || a->language != b->language || a->status != b->status ||
        a->failure != b->failure || a->count != b->count)
        return false;
    for (int i = 0; i < a->count; i++) {
        const CBMPyNamespaceFact *x = &a->items[i], *y = &b->items[i];
        if (x->kind != y->kind || x->def_kind != y->def_kind ||
            x->sequence_kind != y->sequence_kind || x->reason != y->reason ||
            x->flags != y->flags || x->relative_level != y->relative_level ||
            x->name_count != y->name_count || !cmp_str_eq(x->local_name, y->local_name) ||
            !cmp_str_eq(x->module_name, y->module_name) ||
            !cmp_str_eq(x->member_name, y->member_name))
            return false;
        for (int j = 0; j < x->name_count; j++) {
            if (!cmp_str_eq(x->names[j], y->names[j]))
                return false;
        }
    }
    return true;
}

static bool py_facts_owned_range(const CBMArena *arena, const void *ptr, size_t bytes) {
    if (!ptr)
        return bytes == 0;
    uintptr_t address = (uintptr_t)ptr;
    for (int i = 0; i < arena->nblocks; i++) {
        uintptr_t start = (uintptr_t)arena->blocks[i];
        size_t size = arena->block_sizes[i];
        if (address >= start && bytes <= size && address - start <= size - bytes)
            return true;
    }
    return false;
}

static bool py_facts_owned_string(const CBMArena *arena, const char *str) {
    return !str || (py_facts_owned_range(arena, str, 1) &&
                    py_facts_owned_range(arena, str, strlen(str) + 1));
}

static bool py_facts_owned(const CBMArena *arena, const CBMPyNamespaceFacts *facts) {
    if (!py_facts_owned_range(arena, facts->items, (size_t)facts->count * sizeof(*facts->items)))
        return false;
    for (int i = 0; i < facts->count; i++) {
        const CBMPyNamespaceFact *f = &facts->items[i];
        if (!py_facts_owned_string(arena, f->local_name) ||
            !py_facts_owned_string(arena, f->module_name) ||
            !py_facts_owned_string(arena, f->member_name) ||
            !py_facts_owned_range(arena, f->names, (size_t)f->name_count * sizeof(*f->names)))
            return false;
        for (int j = 0; j < f->name_count; j++) {
            if (!py_facts_owned_string(arena, f->names[j]))
                return false;
        }
    }
    return true;
}

static const char PY_FACTS_ORDERED[] = "def item():\n    return 1\n"
                                       "from first import item\n"
                                       "from second import item as item\n"
                                       "item = unknown\n"
                                       "del item\n"
                                       "import pkg.mod\n"
                                       "import pkg.mod as alias\n"
                                       "from . import child as local\n"
                                       "from ..outer import member\n"
                                       "from one.shared import *\n"
                                       "from two.shared import *\n"
                                       "class Local:\n    pass\n";

TEST(python_namespace_facts_preserve_order_and_import_provenance) {
    CBMFileResult *r = extract(PY_FACTS_ORDERED, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
    bool ok = r && !r->has_error && !r->parse_incomplete &&
              r->py_namespace.status == CBM_PY_NS_COMPLETE && r->py_namespace.count == 12 &&
              cbm_py_namespace_facts_valid(&r->py_namespace) && has_def(r, "Function", "item") &&
              has_def(r, "Class", "Local") && r->module_qn &&
              strcmp(r->module_qn, "t.pkg.__init__") == 0;
    if (ok) {
        const CBMPyNamespaceFact *f = r->py_namespace.items;
        ok = f[0].kind == CBM_PY_NS_OWN_DEF && f[0].def_kind == CBM_PY_NS_DEF_FUNCTION &&
             strcmp(f[0].local_name, "item") == 0 && f[1].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[1].module_name, "first") == 0 && strcmp(f[1].member_name, "item") == 0 &&
             strcmp(f[1].local_name, "item") == 0 && f[2].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[2].module_name, "second") == 0 && strcmp(f[2].local_name, "item") == 0 &&
             f[3].kind == CBM_PY_NS_SHADOW && strcmp(f[3].local_name, "item") == 0 &&
             f[4].kind == CBM_PY_NS_DELETE && strcmp(f[4].local_name, "item") == 0 &&
             f[5].kind == CBM_PY_NS_IMPORT_MODULE && strcmp(f[5].module_name, "pkg.mod") == 0 &&
             strcmp(f[5].local_name, "pkg") == 0 && f[5].flags == CBM_PY_NS_IMPORT_BINDS_ROOT &&
             f[6].kind == CBM_PY_NS_IMPORT_MODULE && strcmp(f[6].module_name, "pkg.mod") == 0 &&
             strcmp(f[6].local_name, "alias") == 0 && f[6].flags == 0 && f[7].relative_level == 1 &&
             strcmp(f[7].module_name, "") == 0 && strcmp(f[7].member_name, "child") == 0 &&
             strcmp(f[7].local_name, "local") == 0 && f[8].relative_level == 2 &&
             strcmp(f[8].module_name, "outer") == 0 && strcmp(f[8].member_name, "member") == 0 &&
             f[9].kind == CBM_PY_NS_IMPORT_STAR && strcmp(f[9].module_name, "one.shared") == 0 &&
             f[10].kind == CBM_PY_NS_IMPORT_STAR && strcmp(f[10].module_name, "two.shared") == 0 &&
             f[11].kind == CBM_PY_NS_OWN_DEF && f[11].def_kind == CBM_PY_NS_DEF_CLASS &&
             strcmp(f[11].local_name, "Local") == 0 && py_facts_owned(&r->arena, &r->py_namespace);
    }
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok);
    PASS();
}

/* The type checker view of `if TYPE_CHECKING:` publishes its consequence (a
 * lazy-module package: the else branch only installs the module). A name an
 * elif/else import binds again is withdrawn by a SHADOW: its runtime source is
 * the alternative. Both streams stay COMPLETE and valid. */
TEST(python_namespace_facts_type_checking_alternatives) {
    CBMFileResult *lazy = extract("from typing import TYPE_CHECKING\n"
                                  "if TYPE_CHECKING:\n    from .lazy_mod import Lazy\n"
                                  "else:\n    import sys\n",
                                  CBM_LANG_PYTHON, "t", "lz/__init__.py");
    CBMFileResult *compat = extract("from typing import TYPE_CHECKING\n"
                                    "if TYPE_CHECKING:\n    from .types_only import Shim\n"
                                    "else:\n    try:\n        from .runtime_impl import Shim\n"
                                    "    except ImportError:\n        Shim = None\n",
                                    CBM_LANG_PYTHON, "t", "cmp/__init__.py");
    bool ok = lazy && compat && lazy->py_namespace.status == CBM_PY_NS_COMPLETE &&
              compat->py_namespace.status == CBM_PY_NS_COMPLETE &&
              cbm_py_namespace_facts_valid(&lazy->py_namespace) &&
              cbm_py_namespace_facts_valid(&compat->py_namespace) &&
              lazy->py_namespace.count == 3 && compat->py_namespace.count == 3;
    if (ok) {
        const CBMPyNamespaceFact *l = lazy->py_namespace.items;
        const CBMPyNamespaceFact *c = compat->py_namespace.items;
        ok = l[1].kind == CBM_PY_NS_IMPORT_NAME && strcmp(l[1].local_name, "Lazy") == 0 &&
             l[2].kind == CBM_PY_NS_SHADOW && strcmp(l[2].local_name, "sys") == 0 &&
             c[1].kind == CBM_PY_NS_IMPORT_NAME && strcmp(c[1].local_name, "Shim") == 0 &&
             c[2].kind == CBM_PY_NS_SHADOW && strcmp(c[2].local_name, "Shim") == 0;
    }
    if (lazy)
        cbm_free_result(lazy);
    if (compat)
        cbm_free_result(compat);
    ASSERT_TRUE(ok);
    PASS();
}

/* A string-literal statement (a module, class or attribute docstring) has no
 * effect, and `from __future__ import x` binds x like any from-import. Neither
 * may withdraw the names bound before it: sqlalchemy's sql/expression.py lost
 * its 149 re-exports to `nullsfirst = nulls_first` followed by a triple-quoted
 * docstring. An f-string with a replacement field can run code
 * (__format__ / __str__) and stays an effect. */
static bool py_facts_any_unknown(const CBMFileResult *r, CBMPyNamespaceUnknownReason reason) {
    for (int i = 0; r && i < r->py_namespace.count; i++) {
        if (r->py_namespace.items[i].kind == CBM_PY_NS_UNKNOWN &&
            r->py_namespace.items[i].reason == reason)
            return true;
    }
    return false;
}

TEST(python_namespace_facts_string_statements_and_future_imports) {
    static const char source[] = "\"\"\"Module docstring.\"\"\"\n"
                                 "from __future__ import annotations\n"
                                 "from __future__ import (division as div, generator_stop)\n"
                                 "from .impl import a\n"
                                 "\"\"\"A triple-quoted string after an import.\"\"\"\n"
                                 "'''Single-quoted triple.'''\n"
                                 "r\"raw \\d\"\n"
                                 "b\"bytes\"\n"
                                 "rb'raw bytes'\n"
                                 "u\"unicode\"\n"
                                 "\"implicit\" 'concatenation'\n"
                                 "f\"no replacement field {{escaped}}\"\n"
                                 "from .impl import b\n"
                                 "class Documented:\n"
                                 "    \"\"\"Class docstring.\"\"\"\n"
                                 "    def method(self):\n"
                                 "        pass\n"
                                 "x = a\n"
                                 "\"\"\"Attribute docstring.\"\"\"\n";
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
    bool ok = r && !r->has_error && r->py_namespace.status == CBM_PY_NS_COMPLETE &&
              cbm_py_namespace_facts_valid(&r->py_namespace) && r->py_namespace.count == 7;
    if (ok) {
        const CBMPyNamespaceFact *f = r->py_namespace.items;
        ok = f[0].kind == CBM_PY_NS_IMPORT_NAME && strcmp(f[0].module_name, "__future__") == 0 &&
             f[0].relative_level == 0 && strcmp(f[0].member_name, "annotations") == 0 &&
             strcmp(f[0].local_name, "annotations") == 0 && f[1].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[1].member_name, "division") == 0 && strcmp(f[1].local_name, "div") == 0 &&
             f[2].kind == CBM_PY_NS_IMPORT_NAME && strcmp(f[2].local_name, "generator_stop") == 0 &&
             f[3].kind == CBM_PY_NS_IMPORT_NAME && strcmp(f[3].local_name, "a") == 0 &&
             f[4].kind == CBM_PY_NS_IMPORT_NAME && strcmp(f[4].local_name, "b") == 0 &&
             f[5].kind == CBM_PY_NS_OWN_DEF && f[5].def_kind == CBM_PY_NS_DEF_CLASS &&
             strcmp(f[5].local_name, "Documented") == 0 && f[6].kind == CBM_PY_NS_SHADOW &&
             strcmp(f[6].local_name, "x") == 0;
    }
    if (!ok && r) {
        for (int i = 0; i < r->py_namespace.count; i++) {
            const CBMPyNamespaceFact *f = &r->py_namespace.items[i];
            printf("  string/future fact %d: kind %d reason %d name %s\n", i, (int)f->kind,
                   (int)f->reason, f->local_name ? f->local_name : "-");
        }
    }
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok); /* RED while a docstring is an effect and __future__ is unsupported */

    /* Controls: each stays a namespace barrier. */
    static const struct {
        const char *name;
        const char *source;
        CBMPyNamespaceUnknownReason reason;
    } barriers[] = {
        {"f-string field", "from .impl import a\nf\"{a}\"\n", CBM_PY_NS_REASON_EFFECT},
        {"concatenated f-string field", "from .impl import a\n\"x\" f\"{a!r}\"\n",
         CBM_PY_NS_REASON_EFFECT},
        {"call", "from .impl import a\nprint(a)\n", CBM_PY_NS_REASON_EFFECT},
        /* Python rejects it, and so does the grammar: the whole file is unknown */
        {"star from __future__", "from .impl import a\nfrom __future__ import *\n",
         CBM_PY_NS_REASON_PARSE},
    };
    for (size_t i = 0; i < sizeof(barriers) / sizeof(barriers[0]); i++) {
        r = extract(barriers[i].source, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
        ok = r && r->py_namespace.status == CBM_PY_NS_COMPLETE &&
             cbm_py_namespace_facts_valid(&r->py_namespace) &&
             py_facts_any_unknown(r, barriers[i].reason);
        if (!ok)
            printf("  control '%s' is no namespace barrier\n", barriers[i].name);
        if (r)
            cbm_free_result(r);
        ASSERT_TRUE(ok);
    }
    PASS();
}

/* A top-level call of a same-module function is a namespace effect, unless the
 * callee provably cannot rebind the caller's names: sqlalchemy's
 * `sql/__init__.py` ends with `__go(locals())`. Every submodule its body
 * imports becomes a package attribute, so those names are shadowed at the
 * call; everything else of the namespace survives. */
static bool py_facts_has_effect(const CBMFileResult *r) {
    for (int i = 0; r && i < r->py_namespace.count; i++) {
        if (r->py_namespace.items[i].kind == CBM_PY_NS_UNKNOWN &&
            r->py_namespace.items[i].reason == CBM_PY_NS_REASON_EFFECT)
            return true;
    }
    return false;
}

static int py_facts_count_kind(const CBMFileResult *r, CBMPyNamespaceFactKind kind) {
    int n = 0;
    for (int i = 0; r && i < r->py_namespace.count; i++)
        n += r->py_namespace.items[i].kind == kind;
    return n;
}

static bool py_facts_valid_complete(const CBMFileResult *r) {
    return r && !r->has_error && r->py_namespace.status == CBM_PY_NS_COMPLETE &&
           cbm_py_namespace_facts_valid(&r->py_namespace);
}

TEST(python_namespace_facts_init_call_allowlist) {
    static const char go[] = "from typing import TYPE_CHECKING, Any\n"
                             "from .impl import base\n"
                             "from .elements import cast\n"
                             "def __go(lcls: Any) -> None:\n"
                             "    from .. import util as _sa_util\n"
                             "    from . import base\n"
                             "    from . import coercions, elements as _el\n"
                             "    if not TYPE_CHECKING:\n"
                             "        base.coercions = _el.coercions = coercions\n"
                             "    from .annotation import _prepare_annotations\n"
                             "    _prepare_annotations(cast, cast)\n"
                             "    _sa_util.preloaded.import_prefix(\"sqlalchemy.sql\")\n"
                             "\n"
                             "__go(locals())\n";
    CBMFileResult *r = extract(go, CBM_LANG_PYTHON, "t", "sql/__init__.py");
    bool ok = py_facts_valid_complete(r) && !py_facts_has_effect(r) && r->py_namespace.count == 9;
    if (ok) {
        const CBMPyNamespaceFact *f = r->py_namespace.items;
        static const char *const shadowed[] = {"base", "coercions", "elements", "annotation"};
        ok = f[2].kind == CBM_PY_NS_IMPORT_NAME && strcmp(f[2].local_name, "base") == 0 &&
             f[4].kind == CBM_PY_NS_OWN_DEF && strcmp(f[4].local_name, "__go") == 0;
        for (int i = 0; ok && i < 4; i++) {
            ok = f[5 + i].kind == CBM_PY_NS_SHADOW && f[5 + i].local_name &&
                 strcmp(f[5 + i].local_name, shadowed[i]) == 0;
        }
    }
    if (!ok && r) {
        for (int i = 0; i < r->py_namespace.count; i++) {
            const CBMPyNamespaceFact *f = &r->py_namespace.items[i];
            printf("  __go fact %d: kind %d reason %d name %s\n", i, (int)f->kind, (int)f->reason,
                   f->local_name ? f->local_name : "-");
        }
    }
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok); /* RED while every top-level call withdraws the namespace */

    /* A plain module is no package: the body's imports set attributes of its
     * parent package, never of the module itself. */
    r = extract("def __go(lcls):\n    from . import base\n\n__go(locals())\n", CBM_LANG_PYTHON, "t",
                "sql/mod.py");
    ok = py_facts_valid_complete(r) && !py_facts_has_effect(r) &&
         py_facts_count_kind(r, CBM_PY_NS_SHADOW) == 0;
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok);

    /* Each of these can rebind a name of the caller's namespace (or is not
     * provably a same-module function): the call stays a whole-namespace
     * effect. */
    static const char *const effects[][2] = {
        {"param", "def __go(lcls):\n    lcls['base'] = 1\n\n__go(locals())\n"},
        {"global", "def __go(lcls):\n    global base\n    base = 1\n\n__go(locals())\n"},
        {"nested global", "def __go(lcls):\n    def inner():\n        global base\n"
                          "        base = 1\n    inner()\n\n__go(locals())\n"},
        {"globals()", "def __go(lcls):\n    globals()['base'] = 1\n\n__go(locals())\n"},
        {"sys.modules", "def __go(lcls):\n    import sys\n    sys.modules[__name__].base = 1\n"
                        "\n__go(locals())\n"},
        {"imported callee", "from .setup import __go\n__go(locals())\n"},
        {"own package name", "def __go(lcls):\n    from .. import sql\n    sql.base = 1\n"
                             "\n__go(locals())\n"},
        {"same-module helper", "def helper():\n    pass\n\ndef __go(lcls):\n    helper()\n"
                               "\n__go(locals())\n"},
        {"rebound callee", "def __go(lcls):\n    pass\n\n__go = other\n__go(locals())\n"},
        {"call before def", "__go(locals())\n\ndef __go(lcls):\n    pass\n"},
        {"argument effect", "def __go(lcls):\n    pass\n\n__go(make())\n"},
        {"rebound locals", "def locals():\n    return {}\n\ndef __go(lcls):\n    pass\n"
                           "\n__go(locals())\n"},
    };
    for (size_t i = 0; i < sizeof(effects) / sizeof(effects[0]); i++) {
        char src[512];
        snprintf(src, sizeof(src), "from .impl import base\n%s", effects[i][1]);
        r = extract(src, CBM_LANG_PYTHON, "t", "sql/__init__.py");
        ok = py_facts_valid_complete(r) && py_facts_has_effect(r);
        if (!ok)
            printf("  control '%s' is no namespace effect\n", effects[i][0]);
        if (r)
            cbm_free_result(r);
        ASSERT_TRUE(ok);
    }
    PASS();
}

TEST(python_namespace_facts_distinguish_all_operations_and_unknowns) {
    static const char source[] = "__all__ = ['old']; __all__ = []\n"
                                 "__all__ = dynamic\n"
                                 "__all__ = ('new', '_private', 'a,b', '')\n"
                                 "__all__ += ('new',)\n"
                                 "__all__ -= []\n"
                                 "del __all__\n";
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "main.py");
    CBMFileResult *empty = extract("# no bindings\n", CBM_LANG_PYTHON, "t", "empty.py");
    bool ok = r && empty && !r->has_error && !r->parse_incomplete && !empty->has_error &&
              r->py_namespace.status == CBM_PY_NS_COMPLETE && r->py_namespace.count == 7 &&
              empty->py_namespace.status == CBM_PY_NS_COMPLETE && empty->py_namespace.count == 0 &&
              cbm_py_namespace_facts_valid(&r->py_namespace);
    if (ok) {
        const CBMPyNamespaceFact *f = r->py_namespace.items;
        ok = f[0].kind == CBM_PY_NS_ALL_SET && f[0].name_count == 1 &&
             strcmp(f[0].names[0], "old") == 0 && f[1].kind == CBM_PY_NS_ALL_SET &&
             f[1].name_count == 0 && f[1].names == NULL &&
             f[1].sequence_kind == CBM_PY_NS_SEQUENCE_LIST && f[2].kind == CBM_PY_NS_ALL_UNKNOWN &&
             f[3].kind == CBM_PY_NS_ALL_SET && f[3].sequence_kind == CBM_PY_NS_SEQUENCE_TUPLE &&
             f[3].name_count == 4 && strcmp(f[3].names[0], "new") == 0 &&
             strcmp(f[3].names[1], "_private") == 0 && strcmp(f[3].names[2], "a,b") == 0 &&
             strcmp(f[3].names[3], "") == 0 && f[4].kind == CBM_PY_NS_ALL_APPEND &&
             f[4].name_count == 1 && strcmp(f[4].names[0], "new") == 0 &&
             f[5].kind == CBM_PY_NS_ALL_UNKNOWN && f[6].kind == CBM_PY_NS_ALL_DELETE;
    }
    if (r)
        cbm_free_result(r);
    if (empty)
        cbm_free_result(empty);
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_unknown_effects_and_body_stability) {
    static const char one[] = "from pkg import Item\ndef f():\n    return 1\n";
    static const char two[] =
        "from pkg import Item\ndef f():\n    from elsewhere import Other\n    return Other()\n";
    CBMFileResult *a = extract(one, CBM_LANG_PYTHON, "t", "main.py");
    CBMFileResult *b = extract(two, CBM_LANG_PYTHON, "t", "main.py");
    bool ok = a && b && !a->has_error && !b->has_error && !a->parse_incomplete &&
              !b->parse_incomplete && a->py_namespace.count == 2 &&
              py_facts_equal(&a->py_namespace, &b->py_namespace);
    if (a)
        cbm_free_result(a);
    if (b)
        cbm_free_result(b);
    static const char unknown[] = "from pkg import Item\n"
                                  "if enabled:\n    from other import Item\n"
                                  "@deco\ndef wrapped():\n    pass\n"
                                  "class Derived(Base):\n    pass\n"
                                  "Item = factory()\n";
    a = extract(unknown, CBM_LANG_PYTHON, "t", "main.py");
    ok = a && !a->has_error && !a->parse_incomplete && a->py_namespace.count == 8 && ok;
    if (a && a->py_namespace.count == 8) {
        const CBMPyNamespaceFact *f = a->py_namespace.items;
        ok = f[0].kind == CBM_PY_NS_IMPORT_NAME && f[1].kind == CBM_PY_NS_UNKNOWN &&
             f[1].reason == CBM_PY_NS_REASON_COMPOUND && f[2].kind == CBM_PY_NS_UNKNOWN &&
             f[3].kind == CBM_PY_NS_SHADOW && f[3].reason == CBM_PY_NS_REASON_DECORATED &&
             strcmp(f[3].local_name, "wrapped") == 0 && f[4].kind == CBM_PY_NS_UNKNOWN &&
             f[5].kind == CBM_PY_NS_SHADOW && f[5].reason == CBM_PY_NS_REASON_UNPROVEN_CLASS &&
             f[6].kind == CBM_PY_NS_UNKNOWN && f[7].kind == CBM_PY_NS_SHADOW && ok;
    }
    if (a)
        cbm_free_result(a);
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_parse_errors_are_complete_unknown) {
    const char *source = "from pkg import Before\ndef broken(:\n";
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "main.py");
    bool ok = r && r->parse_incomplete && r->py_namespace.status == CBM_PY_NS_COMPLETE &&
              r->py_namespace.count == 1 && r->py_namespace.items[0].kind == CBM_PY_NS_UNKNOWN &&
              r->py_namespace.items[0].reason == CBM_PY_NS_REASON_PARSE &&
              cbm_py_namespace_facts_valid(&r->py_namespace);
    if (r)
        cbm_free_result(r);
    CBMFileResult fallback = {0};
    cbm_arena_init(&fallback.arena);
    CBMExtractCtx ctx = {.arena = &fallback.arena,
                         .result = &fallback,
                         .source = "",
                         .source_len = 0,
                         .language = CBM_LANG_PYTHON};
    ok = cbm_extract_python_namespace_facts(&ctx) == CBM_PY_NS_COMPLETE &&
         fallback.py_namespace.count == 1 &&
         fallback.py_namespace.items[0].reason == CBM_PY_NS_REASON_PARSE && ok;
    cbm_arena_destroy(&fallback.arena);
    r = extract("const x = 1;\n", CBM_LANG_JAVASCRIPT, "t", "__init__.js");
    ok = r && !r->has_error && r->py_namespace.status == CBM_PY_NS_NOT_APPLICABLE &&
         r->py_namespace.language == CBM_LANG_JAVASCRIPT && r->py_namespace.count == 0 && ok;
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_capture_and_copy_fail_atomically) {
    static const char source[] = "from .pkg import Item as Local\n__all__ = ['Local', '']\n";
    bool ok = true, capture_complete = false, copy_complete = false;
    int capture_failures = 0, copy_failures = 0;
    for (int limit = 0; limit < 64 && !capture_complete; limit++) {
        cbm_py_namespace_test_capture_fail_after(limit);
        CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
        cbm_py_namespace_test_capture_fail_after(-1);
        if (!r) {
            ok = false;
            break;
        }
        const CBMPyNamespaceFacts *f = &r->py_namespace;
        capture_complete = f->status == CBM_PY_NS_COMPLETE;
        if (capture_complete) {
            ok = f->count == 2 && cbm_py_namespace_facts_valid(f) && ok;
        } else {
            capture_failures++;
            ok = f->status == CBM_PY_NS_INCOMPLETE && f->failure == CBM_PY_NS_FAILURE_ALLOCATION &&
                 !f->items && f->count == 0 && f->cap == 0 && cbm_py_namespace_facts_valid(f) && ok;
        }
        cbm_free_result(r);
    }
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
    CBMArena reference_arena;
    cbm_arena_init(&reference_arena);
    CBMPyNamespaceFacts original = {0};
    ok = r && cbm_py_namespace_facts_copy(&reference_arena, &r->py_namespace, &original) && ok;
    for (int limit = 0; r && limit < 64 && !copy_complete; limit++) {
        CBMArena arena;
        cbm_arena_init(&arena);
        CBMPyNamespaceFacts copy = {0};
        cbm_py_namespace_test_copy_fail_after(limit);
        copy_complete = cbm_py_namespace_facts_copy(&arena, &r->py_namespace, &copy);
        cbm_py_namespace_test_copy_fail_after(-1);
        if (copy_complete) {
            ok = py_facts_equal(&copy, &r->py_namespace) && py_facts_owned(&arena, &copy) && ok;
        } else {
            copy_failures++;
            ok = copy.status == CBM_PY_NS_INCOMPLETE &&
                 copy.failure == CBM_PY_NS_FAILURE_ALLOCATION && !copy.items && copy.count == 0 &&
                 copy.cap == 0 && ok;
        }
        ok = py_facts_equal(&r->py_namespace, &original) && ok;
        cbm_arena_destroy(&arena);
    }
    /* Rebuilding into an existing result must replace old complete facts on
     * failure; do not leave a stale successful manifest attached. */
    if (r) {
        CBMExtractCtx ctx = {.arena = &r->arena,
                             .result = r,
                             .source = source,
                             .source_len = (int)strlen(source),
                             .language = CBM_LANG_PYTHON};
        cbm_py_namespace_test_capture_fail_after(0);
        CBMPyNamespaceStatus status = cbm_extract_python_namespace_facts(&ctx);
        cbm_py_namespace_test_capture_fail_after(-1);
        ok = status == CBM_PY_NS_INCOMPLETE && !r->py_namespace.items &&
             r->py_namespace.count == 0 && ok;
        cbm_free_result(r);
    }
    cbm_arena_destroy(&reference_arena);
    ASSERT_TRUE(ok);
    ASSERT_TRUE(capture_complete);
    ASSERT_TRUE(copy_complete);
    ASSERT_GT(capture_failures, 2);
    ASSERT_GT(copy_failures, 2);
    PASS();
}

TEST(python_namespace_facts_validation_rejects_partial_and_unknown_schema) {
    CBMPyNamespaceFacts zero = {0};
    bool ok = cbm_py_namespace_facts_valid(&zero) && zero.status == CBM_PY_NS_NOT_CAPTURED;
    CBMPyNamespaceFact event = {.kind = CBM_PY_NS_ALL_SET,
                                .sequence_kind = CBM_PY_NS_SEQUENCE_LIST};
    CBMPyNamespaceFacts facts = {.version = CBM_PY_NAMESPACE_FACTS_VERSION,
                                 .language = CBM_LANG_PYTHON,
                                 .status = CBM_PY_NS_COMPLETE,
                                 .items = &event,
                                 .count = 1,
                                 .cap = 1};
    ok = cbm_py_namespace_facts_valid(&facts) && ok;
    for (int variant = 0; variant < 8; variant++) {
        CBMPyNamespaceFact bad_event = event;
        CBMPyNamespaceFacts bad = facts;
        bad.items = &bad_event;
        if (variant == 0)
            bad.version++;
        if (variant == 1)
            bad.cap = 0;
        if (variant == 2)
            bad.count = -1;
        if (variant == 3)
            bad_event.kind = (CBMPyNamespaceFactKind)999;
        if (variant == 4)
            bad_event.name_count = 1;
        if (variant == 5)
            bad_event.flags = UINT32_MAX;
        if (variant == 6)
            bad.language = CBM_LANG_JAVA;
        if (variant == 7)
            bad.status = CBM_PY_NS_INCOMPLETE;
        CBMArena arena;
        cbm_arena_init(&arena);
        CBMPyNamespaceFacts copy = {0};
        ok = !cbm_py_namespace_facts_valid(&bad) &&
             !cbm_py_namespace_facts_copy(&arena, &bad, &copy) &&
             copy.status == CBM_PY_NS_INCOMPLETE && copy.count == 0 && !copy.items && ok;
        cbm_arena_destroy(&arena);
    }
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_compact_spill_and_copy_keep_owned_payload) {
    char source[] = "from . import Thing as Local\n"
                    "__all__ = ['Local', '', 'a,b', '_private']\n"
                    "if enabled:\n    Local = dynamic\n"
                    "__all__ = []\n";
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "pkg/__init__.py");
    CBMArena retained;
    cbm_arena_init(&retained);
    CBMPyNamespaceFacts expected = {0};
    bool ok = r && !r->has_error && !r->parse_incomplete && r->py_namespace.count == 4 &&
              cbm_py_namespace_facts_copy(&retained, &r->py_namespace, &expected);
    memset(source, 'x', strlen(source)); /* facts cannot borrow the caller's input */
    char dir[512];
    int n = snprintf(dir, sizeof(dir), "%s/cbm_py_facts_XXXXXX", cbm_tmpdir());
    bool made = n > 0 && (size_t)n < sizeof(dir) && cbm_mkdtemp(dir);
    size_t saved = cbm_result_spill_pin_free_bytes_for_tests(SIZE_MAX);
    cbm_result_spill_t *spill = made ? cbm_result_spill_open(dir, 1, 1) : NULL;
    cbm_result_spill_pin_free_bytes_for_tests(saved);
    ok = spill && ok;
    if (r && spill && ok) {
        cbm_result_compact(r);
        cbm_result_compact(r);
        ok = r->arena.nblocks == 1 && r->py_namespace.cap == r->py_namespace.count &&
             py_facts_equal(&r->py_namespace, &expected) &&
             py_facts_owned(&r->arena, &r->py_namespace);
        if (ok && cbm_result_spill_park(spill, 0, 0, r)) {
            r = NULL;
            CBMFileResult header = {0};
            ok = cbm_result_spill_peek_header(spill, 0, &header) &&
                 header.py_namespace.status == CBM_PY_NS_COMPLETE && header.py_namespace.count == 4;
            for (int round = 0; round < 2; round++) {
                CBMFileResult *loaded = cbm_result_spill_load(spill, 0);
                ok = loaded && loaded->cached_tree == NULL &&
                     py_facts_owned(&loaded->arena, &loaded->py_namespace) &&
                     py_facts_equal(&loaded->py_namespace, &expected) && ok;
                if (loaded)
                    cbm_free_result(loaded);
            }
        } else {
            ok = false;
        }
    }
    if (r)
        cbm_free_result(r);
    cbm_result_spill_close(spill);
    if (made) {
        char subdir[1024];
        snprintf(subdir, sizeof(subdir), "%s/spill", dir);
        cbm_rmdir(subdir);
        cbm_rmdir(dir);
    }
    /* Original result/source tree and both reloads are gone; the independent
     * copied payload still owns the relative empty module and literal strings. */
    ok = py_facts_owned(&retained, &expected) && cbm_py_namespace_facts_valid(&expected) &&
         expected.count == 4 && expected.items[0].relative_level == 1 &&
         strcmp(expected.items[0].module_name, "") == 0 && expected.items[1].name_count == 4 &&
         strcmp(expected.items[1].names[2], "a,b") == 0 && ok;
    cbm_arena_destroy(&retained);
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_unavailable_and_empty_survive_spill) {
    CBMPyNamespaceFacts states[] = {
        {0},
        {.version = CBM_PY_NAMESPACE_FACTS_VERSION,
         .language = CBM_LANG_PYTHON,
         .status = CBM_PY_NS_COMPLETE},
        {.version = CBM_PY_NAMESPACE_FACTS_VERSION,
         .language = CBM_LANG_PYTHON,
         .status = CBM_PY_NS_INCOMPLETE,
         .failure = CBM_PY_NS_FAILURE_ALLOCATION},
        {.version = CBM_PY_NAMESPACE_FACTS_VERSION,
         .language = CBM_LANG_JAVASCRIPT,
         .status = CBM_PY_NS_NOT_APPLICABLE},
    };
    char dir[512];
    int n = snprintf(dir, sizeof(dir), "%s/cbm_py_fact_states_XXXXXX", cbm_tmpdir());
    bool made = n > 0 && (size_t)n < sizeof(dir) && cbm_mkdtemp(dir);
    size_t saved = cbm_result_spill_pin_free_bytes_for_tests(SIZE_MAX);
    cbm_result_spill_t *spill = made ? cbm_result_spill_open(dir, 1, 4) : NULL;
    cbm_result_spill_pin_free_bytes_for_tests(saved);
    bool ok = spill != NULL;
    for (int i = 0; spill && i < 4; i++) {
        CBMFileResult *r = cbm_result_alloc();
        if (!r) {
            ok = false;
            break;
        }
        cbm_arena_init(&r->arena);
        r->module_qn = cbm_arena_strdup(&r->arena, "t.metadata");
        r->py_namespace = states[i];
        cbm_result_compact(r);
        cbm_result_compact(r);
        bool ready =
            r->module_qn && r->arena.nblocks == 1 && py_facts_equal(&r->py_namespace, &states[i]);
        if (!ready || !cbm_result_spill_park(spill, 0, i, r)) {
            ok = false;
            cbm_free_result(r);
            continue;
        }
        CBMFileResult header = {0};
        ok = cbm_result_spill_peek_header(spill, i, &header) &&
             header.py_namespace.status == states[i].status && header.py_namespace.count == 0 && ok;
        for (int round = 0; round < 2; round++) {
            CBMFileResult *loaded = cbm_result_spill_load(spill, i);
            ok = loaded && py_facts_equal(&loaded->py_namespace, &states[i]) &&
                 py_facts_owned(&loaded->arena, &loaded->py_namespace) && ok;
            if (loaded)
                cbm_free_result(loaded);
        }
    }
    cbm_result_spill_close(spill);
    if (made) {
        char subdir[1024];
        snprintf(subdir, sizeof(subdir), "%s/spill", dir);
        cbm_rmdir(subdir);
        cbm_rmdir(dir);
    }
    ASSERT_TRUE(ok);
    PASS();
}

TEST(python_namespace_facts_multiple_bindings_and_unsupported_effects) {
    static const char source[] = "import alpha, beta.mod as Beta\n"
                                 "from pkg import (One, Two as Local)\n"
                                 "from pkg import later\n"
                                 "def later():\n    pass\n"
                                 "from pkg import __all__\n"
                                 "def __all__():\n    pass\n"
                                 "values = {obj: 1}\n"
                                 "class HasDescriptor:\n    field = descriptor\n"
                                 "__all__ = ['escaped\\n']\n";
    CBMFileResult *r = extract(source, CBM_LANG_PYTHON, "t", "main.py");
    bool ok = r && !r->has_error && !r->parse_incomplete &&
              r->py_namespace.status == CBM_PY_NS_COMPLETE && r->py_namespace.count == 13 &&
              cbm_py_namespace_facts_valid(&r->py_namespace) && has_def(r, "Function", "later") &&
              has_def(r, "Class", "HasDescriptor");
    if (ok) {
        const CBMPyNamespaceFact *f = r->py_namespace.items;
        ok = f[0].kind == CBM_PY_NS_IMPORT_MODULE && strcmp(f[0].local_name, "alpha") == 0 &&
             f[1].kind == CBM_PY_NS_IMPORT_MODULE && strcmp(f[1].local_name, "Beta") == 0 &&
             strcmp(f[1].module_name, "beta.mod") == 0 && f[2].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[2].member_name, "One") == 0 && f[3].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[3].member_name, "Two") == 0 && strcmp(f[3].local_name, "Local") == 0 &&
             f[4].kind == CBM_PY_NS_IMPORT_NAME && f[5].kind == CBM_PY_NS_OWN_DEF &&
             strcmp(f[5].local_name, "later") == 0 && f[6].kind == CBM_PY_NS_IMPORT_NAME &&
             strcmp(f[6].local_name, "__all__") == 0 && f[7].kind == CBM_PY_NS_OWN_DEF &&
             strcmp(f[7].local_name, "__all__") == 0 && f[8].kind == CBM_PY_NS_UNKNOWN &&
             f[9].kind == CBM_PY_NS_SHADOW && strcmp(f[9].local_name, "values") == 0 &&
             f[10].kind == CBM_PY_NS_UNKNOWN && f[11].kind == CBM_PY_NS_SHADOW &&
             f[11].reason == CBM_PY_NS_REASON_UNPROVEN_CLASS &&
             /* a string with an escape evaluates nothing: no effect, but no
              * literal export name either */
             f[12].kind == CBM_PY_NS_ALL_UNKNOWN;
    }
    if (r)
        cbm_free_result(r);
    ASSERT_TRUE(ok);
    PASS();
}

#ifdef _WIN32
/* The supervisor sets this path through cbm_setenv. Exercise the actual
 * journal writer, which must read it as UTF-8 before calling cbm_fopen. */
TEST(extraction_marker_round_trips_non_ascii_environment_path) {
    char dir[512] = "/tmp/cbm-marker-XXXXXX";
    ASSERT_NOT_NULL(cbm_mkdtemp(dir));
    char marker[640];
    snprintf(marker, sizeof(marker), "%s/marker-\xce\x94-\xe4\xb8\x81.log", dir);
    char saved[4096];
    const char *previous = cbm_safe_getenv("CBM_INDEX_MARKER_FILE", saved, sizeof(saved), NULL);
    ASSERT_EQ(cbm_setenv("CBM_INDEX_MARKER_FILE", marker, 1), 0);
    cbm_index_mark_start("synthetic.cpp");
    cbm_index_mark_done("synthetic.cpp");
    if (previous) {
        (void)cbm_setenv("CBM_INDEX_MARKER_FILE", saved, 1);
    } else {
        (void)cbm_unsetenv("CBM_INDEX_MARKER_FILE");
    }
    FILE *file = cbm_fopen(marker, "rb");
    char contents[128] = {0};
    if (file) {
        (void)fread(contents, 1, sizeof(contents) - 1, file);
        (void)fclose(file);
    }
    (void)cbm_unlink(marker);
    (void)cbm_rmdir(dir);
    ASSERT_NOT_NULL(file);
    ASSERT_STR_EQ(contents, "S synthetic.cpp\nD synthetic.cpp\n");
    PASS();
}
#endif

SUITE(extraction) {
#ifdef _WIN32
    RUN_TEST(extraction_marker_round_trips_non_ascii_environment_path);
#endif
    RUN_TEST(extract_compact_keeps_every_field_and_shrinks_the_arena);
    RUN_TEST(extract_compact_is_idempotent_and_survives_empty_results);
    RUN_TEST(extract_spill_round_trip_keeps_every_field);
    RUN_TEST(extract_spill_refuses_below_the_free_disk_floor);
    RUN_TEST(extract_lsp_skipped_file_gets_no_walk);
    RUN_TEST(extract_walk_truncated_when_a_node_budget_is_set);
    /* Initialize extraction library */
    cbm_init();

    RUN_TEST(python_namespace_facts_preserve_order_and_import_provenance);
    RUN_TEST(python_namespace_facts_distinguish_all_operations_and_unknowns);
    RUN_TEST(python_namespace_facts_unknown_effects_and_body_stability);
    RUN_TEST(python_namespace_facts_parse_errors_are_complete_unknown);
    RUN_TEST(python_namespace_facts_type_checking_alternatives);
    RUN_TEST(python_namespace_facts_string_statements_and_future_imports);
    RUN_TEST(python_namespace_facts_init_call_allowlist);
    RUN_TEST(python_namespace_facts_capture_and_copy_fail_atomically);
    RUN_TEST(python_namespace_facts_validation_rejects_partial_and_unknown_schema);
    RUN_TEST(python_namespace_facts_compact_spill_and_copy_keep_owned_payload);
    RUN_TEST(python_namespace_facts_unavailable_and_empty_survive_spill);
    RUN_TEST(python_namespace_facts_multiple_bindings_and_unsupported_effects);

    /* Wide-flat-file linearity (ms-typescript hang) */
    RUN_TEST(extract_wide_flat_file_is_linear);
#if defined(CBM_CALL_REFERENCE_LOOKUP_TEST_API) && CBM_CALL_REFERENCE_LOOKUP_TEST_API
    RUN_TEST(extract_wide_flat_reference_fields_are_linear);
    RUN_TEST(extract_csharp_argument_values_use_the_walk_cursor);
    RUN_TEST(extract_rescript_let_bindings_use_the_walk_cursor);
    RUN_TEST(extract_python_deep_default_parent_climbs_are_linear);
#endif

    /* Perl call-graph noise (#459 follow-up) */
    RUN_TEST(extract_perl_config_string_not_a_callee);
    RUN_TEST(extract_perl_builtin_call_is_function_not_method);
    RUN_TEST(extract_perl_method_call_flags_is_method);
    RUN_TEST(extract_rust_generic_impl_call_scope_matches_def);
    RUN_TEST(extract_flag_exempt_method_call_not_flagged_is_method);
    RUN_TEST(extract_python_member_call_flags_is_method);
    RUN_TEST(extract_python_bare_call_flags_locally_bound_callee);
    RUN_TEST(extract_python_bare_call_flag_is_depth_independent);
    RUN_TEST(extract_go_selector_call_flags_is_method);
    RUN_TEST(extract_go_method_receiver_qualified_qn);
    RUN_TEST(extract_templ_method_qn_matches_call_scope);
    RUN_TEST(extract_go_multiple_init_disambiguated);
    RUN_TEST(extract_ts_member_call_flags_is_method);
    RUN_TEST(extract_ts_this_super_receiver_not_flagged);
    RUN_TEST(extract_js_member_call_flags_is_method);

    /* InterSystems ObjectScript (UDL / routine / Export XML). */
    RUN_TEST(objectscript_udl_class);
    RUN_TEST(objectscript_udl_methods_after_goto_label);
    RUN_TEST(objectscript_udl_methods);
    RUN_TEST(objectscript_udl_base_classes);
    RUN_TEST(objectscript_udl_multiple_bases);
    RUN_TEST(objectscript_udl_properties);
    RUN_TEST(objectscript_routine_tags);
    RUN_TEST(objectscript_udl_query_member);
    RUN_TEST(objectscript_udl_index_member);
    RUN_TEST(objectscript_udl_xdata_member);
    RUN_TEST(objectscript_udl_trigger_member);
    RUN_TEST(objectscript_udl_trigger_body_quit);
    RUN_TEST(objectscript_udl_trigger_body_tokens);
    RUN_TEST(objectscript_udl_ensemble_production_def_parses_items);
    RUN_TEST(objectscript_udl_ensemble_production_def_hs_settings);
    RUN_TEST(objectscript_udl_ensemble_production_def_absent_no_error);
    RUN_TEST(objectscript_udl_self_call_relative_dot_method);
    RUN_TEST(objectscript_udl_calls_typed_new);
    RUN_TEST(objectscript_udl_calls_typed_param);
    RUN_TEST(objectscript_udl_calls_typed_property);
    RUN_TEST(objectscript_macro_expand_system);
    RUN_TEST(objectscript_macro_expand_local);
    RUN_TEST(objectscript_macro_constant_no_extra_call);
    RUN_TEST(objectscript_udl_method_return_type);
    RUN_TEST(objectscript_udl_scalar_return_type_not_resolved);
    RUN_TEST(call_args_skip_comments_between_arguments);
    RUN_TEST(objectscript_data_flows_class_method_args);
    RUN_TEST(objectscript_data_flows_instance_method_args);
    RUN_TEST(iris_export_xml_simple_class);
    RUN_TEST(iris_export_xml_classmethod);
    RUN_TEST(iris_export_xml_property_parameter_index);
    RUN_TEST(iris_export_xml_calls_extracted);
    RUN_TEST(iris_export_xml_multi_class);

    /* R box-module imports + member calls */
    RUN_TEST(extract_r_box_use_imports_issue218);
    RUN_TEST(extract_r_dollar_call_issue219);
    RUN_TEST(extract_ts_factory_object_methods_issue341);
    RUN_TEST(traversal_stack_not_in_result_arena_issue2010);
    RUN_TEST(extract_c_macro_hidden_call_survives_preprocessed_pass_issue2010);
    RUN_TEST(extract_c_macros_issue375);
    RUN_TEST(extract_cpp_inc_linkage_and_callback);
    RUN_TEST(extract_cpp_macros_issue375);
    RUN_TEST(extract_cpp_functionlike_macro_type_arg_no_false_parse_partial_issue1071);
    RUN_TEST(extract_cpp_real_in_body_error_still_flagged_issue1071);
    RUN_TEST(macro_check_reads_no_source_for_regions_outside_functions_issue1735);
    RUN_TEST(macro_check_locates_lines_with_one_table_issue1735);
    RUN_TEST(extract_gdscript_issue186);
    RUN_TEST(extract_powershell_issue35);
    RUN_TEST(extract_luau_issue39);
    RUN_TEST(extract_qml_issue42);
    RUN_TEST(extract_cfscript_issue38);
    RUN_TEST(extract_cfml_tag_issue38);
    RUN_TEST(extract_cfml_embedded_cfscript_defs);
    RUN_TEST(extract_helm_templates_issue338);
    RUN_TEST(extract_helm_values_toplevel_issue338);

    /* OOP */
    RUN_TEST(java_class);
    RUN_TEST(java_method);
    RUN_TEST(class_field_is_one_field_not_also_a_variable);
    RUN_TEST(field_named_like_method_is_fenced);
    RUN_TEST(java_interface);
    RUN_TEST(java_interface_no_duplicate_function_issue1234);
    RUN_TEST(java_enum_dedup_preserves_calls_issue1234);
    RUN_TEST(java_class_extends_and_implements);
    RUN_TEST(python_class_base_extracted_bare);
    RUN_TEST(php_class);
    RUN_TEST(php_function);
    RUN_TEST(php_inline_html_tail_reaches_graph_issue2000);
    RUN_TEST(php_inline_html_template_shapes_issue2000);
    RUN_TEST(php_inline_html_close_tag_in_literals_issue2000);
    RUN_TEST(php_inline_html_markup_never_reaches_graph_issue2000);
    RUN_TEST(php_inline_html_mask_copies_only_on_write_issue2000);
    RUN_TEST(php_inline_html_trailing_close_tag_crlf_issue2000);
    RUN_TEST(ruby_class);
    RUN_TEST(ruby_module);
    RUN_TEST(ruby_constructor_callee_is_constant_path);
    RUN_TEST(csharp_class);
    RUN_TEST(csharp_interface);
    RUN_TEST(csharp_extension_block_members);
    RUN_TEST(csharp_constructor_of_type_named_extension);
    RUN_TEST(csharp_constructor_of_escaped_type_named_extension);
    RUN_TEST(csharp_extension_block_conditional_members);
    RUN_TEST(swift_class);
    RUN_TEST(swift_protocol);
    RUN_TEST(kotlin_function);
    RUN_TEST(kotlin_class);
    RUN_TEST(scala_function);
    RUN_TEST(scala_class);
    RUN_TEST(dart_class);
    RUN_TEST(dart_extension_members);
    RUN_TEST(groovy_class);

    /* Systems */
    RUN_TEST(rust_function);
    RUN_TEST(rust_struct);
    RUN_TEST(go_function);
    RUN_TEST(go_struct);
    RUN_TEST(go_interface);
    RUN_TEST(zig_function);
    RUN_TEST(c_function);
    RUN_TEST(c_function_return_type_preserves_pointer_and_qualifier);
    RUN_TEST(c_function_return_type_plain_unchanged);
    RUN_TEST(c_struct);
    RUN_TEST(extract_c_anonymous_typedef_aggregate_is_named_by_its_typedef);
    RUN_TEST(extract_c_anonymous_typedef_aggregate_is_one_def);
    RUN_TEST(extract_c_function_pointer_member_is_a_field);
    RUN_TEST(extract_c_member_declarators_name_and_type);
    RUN_TEST(cpp_class);
    RUN_TEST(cpp_method_return_type_preserves_pointer_and_qualifier);

    /* Scripting */
    RUN_TEST(python_function);
    RUN_TEST(python_class);
    RUN_TEST(python_annotated_instance_fields_exported_issue1277);
    RUN_TEST(python_type_checking_imports_flagged_issue1277);
    RUN_TEST(python_type_checking_rebound_in_else_unrecorded_issue1277);
    RUN_TEST(js_function);
    RUN_TEST(js_class);
    RUN_TEST(ts_function);
    RUN_TEST(ts_class);
    RUN_TEST(body_tokens_type_identifier);
    RUN_TEST(lua_function);
    RUN_TEST(bash_function);
    RUN_TEST(perl_function);
    RUN_TEST(r_function);

    /* Functional */
    RUN_TEST(elixir_function);
    RUN_TEST(elixir_def_head_is_covers_the_head_and_every_guard_above_it);
    RUN_TEST(extract_elixir_guarded_def_head);
    RUN_TEST(extract_elixir_clauses_fold_only_when_adjacent_in_one_module);
    RUN_TEST(extract_elixir_nested_module_clauses_do_not_fold);
    RUN_TEST(extract_elixir_folded_clause_is_exported_is_the_or);
    RUN_TEST(extract_elixir_guarded_clause_head_is_not_a_self_call);
    RUN_TEST(extract_elixir_declaration_head_mints_no_reference_of_any_kind);
    RUN_TEST(extract_elixir_real_recursion_survives_head_suppression);
    RUN_TEST(extract_elixir_typespec_attribute_is_not_code);
    RUN_TEST(elixir_call_string_argument);
    RUN_TEST(extract_elixir_guarded_def_head_scope);
    RUN_TEST(extract_elixir_guarded_def_head_guard_usages);
    RUN_TEST(elixir_channels_pubsub_and_handle_in);
    RUN_TEST(elixir_complexity_and_fingerprint);
    RUN_TEST(elixir_folded_clause_metrics_cover_every_clause);
    RUN_TEST(elixir_complexity_wide_body_exceeds_old_stack_cap);
    RUN_TEST(haskell_function);
    RUN_TEST(haskell_infix_definition_name);
    RUN_TEST(ocaml_function);
    RUN_TEST(erlang_function);

    /* Markup/Config */
    RUN_TEST(yaml_variables);
    RUN_TEST(hcl_blocks);
    RUN_TEST(sql_create_table);
    RUN_TEST(dockerfile_stages);

    /* Scientific */
    RUN_TEST(matlab_function);
    RUN_TEST(lean_function);
    RUN_TEST(form_procedure);
    RUN_TEST(plsql_package_and_call);
    RUN_TEST(plsql_standalone_function);
    RUN_TEST(plsql_create_type_as_object_limitation);
    RUN_TEST(chialisp_puzzle_defs_and_labels);
    RUN_TEST(chialisp_comment_line_endings);
    RUN_TEST(chialisp_library_defs_and_quoted_data);
    RUN_TEST(chialisp_export_names_do_not_duplicate_defs);
    RUN_TEST(chialisp_comment_before_def_head_keeps_the_name);
    RUN_TEST(chialisp_dialect_sigil_is_not_a_file_import);
    RUN_TEST(wolfram_function);
    RUN_TEST(magma_function);

    /* v0.5 expansion */
    RUN_TEST(fsharp_function);
    RUN_TEST(julia_function);
    RUN_TEST(elm_function);
    RUN_TEST(nix_function);
    RUN_TEST(nix_defs_in_let_rooted_file);
    RUN_TEST(nix_defs_in_attrset_rooted_file);
    RUN_TEST(nix_defs_in_nested_let);
    RUN_TEST(nix_defs_survive_function_header_let);
    RUN_TEST(nix_defs_survive_function_header_attrset);
    RUN_TEST(nix_defs_survive_curried_header);
    RUN_TEST(nix_attrset_scope_disambiguates_leaf_names);
    RUN_TEST(nix_dotted_attrpath_qualifies_like_nested);
    RUN_TEST(nix_quoted_attr_name_strips_quotes);
    RUN_TEST(nix_interpolated_attr_mints_no_def);
    RUN_TEST(nix_module_level_bindings_mint_variables);
    RUN_TEST(nix_nested_bindings_are_not_module_level);
    RUN_TEST(nix_lambda_binding_is_function_not_variable);
    RUN_TEST(nix_curried_lambda_mints_one_def);
    RUN_TEST(fortran_function);

    /* OOP/Systems variants */
    RUN_TEST(swift_struct);
    RUN_TEST(swift_simple_call);
    RUN_TEST(swift_method_call);
    RUN_TEST(swift_constructor_call);
    RUN_TEST(swift_chained_call);
    RUN_TEST(swift_force_unwrap_scanner_shift);
    RUN_TEST(swift_init_struct_issue2379);
    RUN_TEST(swift_init_class_designated_issue2379);
    RUN_TEST(swift_init_convenience_delegates_issue2379);
    RUN_TEST(swift_init_overloads_share_one_node_issue2379);
    RUN_TEST(swift_init_failable_enum_issue2379);
    RUN_TEST(swift_init_extension_issue2379);
    RUN_TEST(swift_method_still_attributed_issue2379);
    RUN_TEST(swift_deinit_issue2379);
    RUN_TEST(swift_super_init_names_superclass_issue2379);
    RUN_TEST(swift_super_init_without_superclass_no_call_issue2379);
    RUN_TEST(swift_initializer_calls_flagged_issue2379);
    RUN_TEST(swift_init_reference_is_not_a_usage_issue2379);
    RUN_TEST(swift_call_string_arg_issue1892);
    RUN_TEST(swift_nested_url_constructor_issue1892);
    RUN_TEST(swift_nested_url_no_bang_issue1892);
    RUN_TEST(swift_non_url_constructor_untouched_issue1892);
    RUN_TEST(swift_labeled_call_string_arg_issue1892);
    RUN_TEST(objc_interface);
    RUN_TEST(objc_implementation);
    RUN_TEST(dart_top_level_function);
    RUN_TEST(rust_enum);
    RUN_TEST(zig_struct);
    RUN_TEST(cpp_function);
    RUN_TEST(cpp_gtest_same_name_collision_issue1266);
    RUN_TEST(cpp_gtest_f_unique_name_issue1266);
    RUN_TEST(cpp_out_of_line_method_issue428);
    RUN_TEST(cobol_paragraph);
    RUN_TEST(verilog_module);
    RUN_TEST(cuda_kernel);
    RUN_TEST(python_decorator);
    RUN_TEST(ts_interface);
    RUN_TEST(tsx_component);
    RUN_TEST(lua_table_method);
    RUN_TEST(emacs_lisp_defun);
    RUN_TEST(emacs_lisp_defvar);
    RUN_TEST(haskell_data_type);
    RUN_TEST(clojure_function);

    /* Config/Markup */
    RUN_TEST(html_elements);
    RUN_TEST(sql_function);
    RUN_TEST(sql_ddl_node_labels);
    RUN_TEST(sql_view_lineage_usages);
    RUN_TEST(sql_schema_qualified_name);
    RUN_TEST(dbt_model_and_ref_lineage);
    RUN_TEST(dbt_source_and_two_arg_ref);
    RUN_TEST(dbt_ignores_non_dbt_jinja);
    RUN_TEST(dbt_plain_sql_untouched);
    RUN_TEST(meson_project);
    RUN_TEST(css_rules);
    RUN_TEST(scss_rules);
    RUN_TEST(toml_basic);
    RUN_TEST(cmake_function);
    RUN_TEST(json_object);
    RUN_TEST(protobuf_message);
    RUN_TEST(graphql_type);
    RUN_TEST(svelte_component);
    RUN_TEST(vue_component);
    RUN_TEST(glsl_shader);
    RUN_TEST(vimscript_function);

    /* Scientific extended */
    RUN_TEST(matlab_parse);
    RUN_TEST(matlab_call);
    RUN_TEST(lean_parse);
    RUN_TEST(lean_call);
    RUN_TEST(lean_type_annotation_not_call);
    RUN_TEST(form_parse);
    RUN_TEST(form_call);
    RUN_TEST(magma_procedure);
    RUN_TEST(magma_parse);
    RUN_TEST(magma_import);
    RUN_TEST(magma_call);
    RUN_TEST(magma_disambiguation);
    RUN_TEST(wolfram_function_extended);
    RUN_TEST(wolfram_call);
    RUN_TEST(wolfram_caller_attribution);
    RUN_TEST(c_caller_attribution);
    RUN_TEST(cpp_out_of_line_method_caller_attribution);
    RUN_TEST(cpp_out_of_line_ctor_dtor_caller_attribution);
    RUN_TEST(wolfram_parse);
    RUN_TEST(wolfram_import);
    RUN_TEST(wolfram_nested_def);

    /* cbm_test.go ports */
    RUN_TEST(python_docstring);
    RUN_TEST(go_function_extraction);
    RUN_TEST(js_arrow_function);

    /* language_failures_test.go ports */
    RUN_TEST(commonlisp_defun);
    RUN_TEST(commonlisp_multiple_functions);
    RUN_TEST(commonlisp_defmacro);
    RUN_TEST(defs_push_cuts_multiline_names_and_rejects_js_literal_names);
    RUN_TEST(makefile_rule_as_function);
    RUN_TEST(makefile_multiple_targets);
    RUN_TEST(makefile_variable_extraction);
    RUN_TEST(vimscript_function_extraction);
    RUN_TEST(vimscript_function_without_bang);
    RUN_TEST(julia_function_extraction);
    RUN_TEST(julia_function_with_args);

    /* Cross-cutting */
    RUN_TEST(python_calls);
    RUN_TEST(python_iris_classMethodValue);
    RUN_TEST(python_iris_cls_receiver_is_class_aware);
    RUN_TEST(python_iris_invokeClassMethod);
    RUN_TEST(go_calls);
    RUN_TEST(python_imports);
    RUN_TEST(python_package_relative_import_paths);
    RUN_TEST(js_imports);
    RUN_TEST(go_imports);
    RUN_TEST(go_cgo_pseudo_import_dropped);
    RUN_TEST(bash_imports_are_sourced_files_only);
    RUN_TEST(extract_go_struct_fields_have_nodes);
    RUN_TEST(java_imports);
    RUN_TEST(rust_imports);
    RUN_TEST(c_imports);
    RUN_TEST(c_imports_inside_preprocessor_blocks);
    RUN_TEST(ruby_imports);
    RUN_TEST(lua_imports);
    RUN_TEST(import_stress_go);
    RUN_TEST(svelte_imports_basic);
    RUN_TEST(svelte_imports_no_script);
    RUN_TEST(vue_imports_basic);
    RUN_TEST(vue_embedded_structure_issue1410);
    RUN_TEST(vue_embedded_structure_negative_controls_issue1410);
    RUN_TEST(embedded_structure_sibling_hosts_issue1807);
    RUN_TEST(embedded_structure_inert_blocks_issue1807);
    RUN_TEST(svelte_embedded_structure_both_blocks_issue1807);
    RUN_TEST(html_embedded_structure_issue1807);
    RUN_TEST(astro_embedded_structure_issue1807);
    RUN_TEST(html_imports_basic);

    /* config_extraction_test.go ports */
    RUN_TEST(toml_basic_table_and_pair);
    RUN_TEST(toml_nested_table);
    RUN_TEST(toml_table_array_element);
    RUN_TEST(toml_dotted_key);
    RUN_TEST(toml_quoted_key);
    RUN_TEST(toml_empty_table);
    RUN_TEST(toml_comments_only);
    RUN_TEST(toml_boolean_and_integer_values);
    RUN_TEST(ini_basic_section_and_setting);
    RUN_TEST(ini_multiple_sections);
    RUN_TEST(ini_global_keys);
    RUN_TEST(ini_comments);
    RUN_TEST(json_basic_pair);
    RUN_TEST(json_nested_object);
    RUN_TEST(json_empty_object);
    RUN_TEST(json_boolean_null_values);
    RUN_TEST(json_package_json_deps);
    RUN_TEST(xml_basic_element);
    RUN_TEST(xml_self_closing_tag);
    RUN_TEST(xml_empty_document);
    RUN_TEST(xml_multiple_children);
    RUN_TEST(markdown_atx_headings);
    RUN_TEST(markdown_setext_headings);
    RUN_TEST(markdown_heading_content);
    RUN_TEST(markdown_no_headings);

    /* __init__.py / index.ts Module QN collision regression */
    RUN_TEST(python_init_module_qn_not_collide_with_folder);
    RUN_TEST(python_init_nested_module_qn);
    RUN_TEST(extract_python_nested_def_qualified_by_enclosing_def_issue1548);
    RUN_TEST(extract_python_nested_def_calls_attributed_to_it_issue1548);
    RUN_TEST(extract_python_decorated_nested_route_handler_issue1548);
    RUN_TEST(extract_python_nested_class_issue1548);
    RUN_TEST(extract_python_nested_def_named_like_its_method_issue1548);
    RUN_TEST(extract_python_lambda_and_comprehension_stay_in_enclosing_def_issue1548);
    RUN_TEST(extract_python_nested_def_env_access_attributed_to_it_issue1548);
    RUN_TEST(js_index_module_qn_not_collide_with_folder);
    RUN_TEST(python_regular_module_qn_unchanged);
    RUN_TEST(extract_java_method_annotations_issue382);
    RUN_TEST(extract_python_mock_patch_is_not_route);
    RUN_TEST(extract_python_bare_decorator_route_rules);
    RUN_TEST(solidity_modifier_decorator);
    RUN_TEST(arkts_component_struct);
    RUN_TEST(arkts_exported_struct_decorators);
    RUN_TEST(arkts_member_decorators);
    RUN_TEST(arkts_no_phantom_builtin_defs);
    RUN_TEST(arkts_builder_extend_styles);
    RUN_TEST(arkts_lazy_import);
    RUN_TEST(arkts_ts_compat);
    RUN_TEST(extract_java_jaxrs_path_composition_issue1005);
    RUN_TEST(extract_java_jaxrs_relative_path_templates);
    RUN_TEST(extract_java_jaxrs_empty_path_means_class_path);
    RUN_TEST(extract_java_spring_relative_string_not_route_path);
    RUN_TEST(extract_ts_nestjs_controller_routes_issue1428);
    RUN_TEST(extract_nextjs_route_metadata_contract_issue759);
    RUN_TEST(extract_nextjs_rejects_nonroutes_issue759);
    RUN_TEST(extract_blazor_page_directive_routes_component);
    RUN_TEST(extract_blazor_component_without_page_has_no_route);
    RUN_TEST(extract_razor_page_directive_routes_cshtml_view);
    RUN_TEST(extract_razor_layout_without_page_has_no_route);
    RUN_TEST(extract_ts_template_string_url_issue1006);
    RUN_TEST(extract_ts_config_object_url_issue2235);
    RUN_TEST(extract_go_binary_concat_url_issue1249);
    RUN_TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249);
    RUN_TEST(extract_go_servemux_method_pattern_handler_issue2537);
    RUN_TEST(extract_ts_template_base_url_issue2291);
    RUN_TEST(extract_ts_template_base_url_no_literal_path_issue2291);
    RUN_TEST(extract_py_concat_const_url_issue706);
    RUN_TEST(extract_py_url_fold_no_fabrication_issue706);
    RUN_TEST(extract_py_prefixed_string_url_issue523);
    RUN_TEST(extract_py_prefixed_string_url_controls_issue523);
    RUN_TEST(extract_ts_const_template_url_issue1147);
    RUN_TEST(extract_ts_url_fold_no_fabrication_issue1147);
    RUN_TEST(extract_ts_folded_topics_keep_raw_identity);
    RUN_TEST(extract_py_folded_topic_keywords_keep_raw_identity);
    RUN_TEST(extract_ts_folded_config_url_and_exclusions);
    RUN_TEST(extract_ts_url_builder_issue1009);
    RUN_TEST(extract_ts_await_generic_call_issue2210);
    RUN_TEST(extract_ts_route_handler_after_named_middleware);
    RUN_TEST(extract_ts_route_handler_after_inline_middleware);
    RUN_TEST(extract_ts_url_builder_composed_issue1009);
    RUN_TEST(extract_c_url_builder_gated_issue1009);
    RUN_TEST(extract_ts_url_builder_mixed_returns_issue1009);
    RUN_TEST(extract_ts_url_builder_ambiguous_issue1009);
    RUN_TEST(extract_ts_url_builder_reference_issue1009);
    RUN_TEST(extract_ts_url_builder_non_url_issue1009);
    RUN_TEST(extract_java_no_double_class_qn);
    RUN_TEST(extract_go_no_filename_in_module_qn);
    RUN_TEST(extract_large_ts_has_functions_issue213);

    /* Per-function complexity metrics (Tier A) */
    RUN_TEST(complexity_nested_loops_depth);
    RUN_TEST(complexity_loop_with_branch);
    RUN_TEST(complexity_flat_no_loops);
    RUN_TEST(complexity_linear_scan_in_loop);
    RUN_TEST(complexity_recursion_in_loop_unguarded);
    RUN_TEST(complexity_guarded_recursion);
    RUN_TEST(complexity_super_only_not_recursive);
    RUN_TEST(complexity_same_name_other_receiver_not_recursive);
    RUN_TEST(complexity_self_receiver_still_recursive);
    RUN_TEST(complexity_chained_receiver_not_self);
    RUN_TEST(complexity_go_method_receiver_self_recursion);
    RUN_TEST(complexity_delegation_receivers_not_recursive_issue876);
    RUN_TEST(complexity_access_depth_and_params);
    RUN_TEST(walk_defs_wide_file_extracts_every_definition);
    RUN_TEST(complexity_wide_body_exceeds_old_stack_cap);
    RUN_TEST(count_branching_wide_body_exceeds_old_stack_cap);
    RUN_TEST(body_tokens_wide_body_samples_from_the_start);
    RUN_TEST(yaml_key_paths_wide_mapping_exceed_old_stack_cap);
    RUN_TEST(yaml_infra_bindings_wide_sequence_exceed_old_stack_cap);
    RUN_TEST(extract_c_ifdef_split_brace_fn_recovered_issue961);
    RUN_TEST(extract_cpp_preproc_signature_gap_issue946);
    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_template_specialization_preprocessed_qn_single_spelling);
    RUN_TEST(extract_c_misnested_raw_struct_replaced_by_flat_copy);
    RUN_TEST(extract_cpp_preprocessed_rescue_skips_raw_def_on_same_line);
    RUN_TEST(extract_cpp_rescue_keeps_expanded_class_when_raw_qn_is_taken);
    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_macro_prefixed_function_names_c1);
    RUN_TEST(extract_cpp_macro_prefixed_lsp_caller_c1);
    RUN_TEST(extract_c_macro_prefixed_function_name_c1);
    RUN_TEST(extract_c_tag_reference_is_not_a_definition_c1);
    RUN_TEST(extract_c_struct_head_in_error_region_recovered_c1);
    RUN_TEST(extract_c_keyword_is_never_a_function_name_c1);
    RUN_TEST(extract_c_function_lost_to_split_branches_restored_c1);
    RUN_TEST(extract_c_typedef_names_are_definitions_c1);
    RUN_TEST(extract_c_macro_qn_is_fenced_c1);
    RUN_TEST(extract_c_enumerators_are_flat_c1);
    RUN_TEST(extract_cpp_enum_scoping_c1);
    RUN_TEST(extract_c_enum_inside_struct_is_file_scope_c1);
    RUN_TEST(extract_cpp_enum_inside_class_keeps_class_scope_c1);
    RUN_TEST(extract_c_enum_macro_wrapped_list_c1);
    RUN_TEST(extract_c_variants_lists_same_file_duplicates_c1);
    RUN_TEST(extract_variants_only_in_c_preprocessor_languages_c1);
    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(extract_cpp_macro_wrapped_declarator_names_def_issue946);
    RUN_TEST(extract_c_macro_wrapped_declarator_controls_issue946);
    RUN_TEST(extract_c_fname_macro_definitions_stay_distinct_issue1957);
    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);
    RUN_TEST(extract_python_method_test_dir_marks_is_test_issue1294);
    RUN_TEST(docstring_utf8_truncation_boundary_issue1017);
    RUN_TEST(doc_go_comment_group_without_directives);
    RUN_TEST(doc_go_struct_field);
    RUN_TEST(doc_go_detached_comment_is_not_doc);
    RUN_TEST(doc_python_comment_run_and_detached);
    RUN_TEST(doc_rust_attribute_impl_method_and_inner_doc);
    RUN_TEST(doc_ts_export_and_arrow_wrapper);
    RUN_TEST(doc_csharp_xml_doc_run_and_top_level_function);
    RUN_TEST(doc_java_javadoc_over_line_comment_and_field);
    RUN_TEST(doc_kotlin_kdoc_folded_after_imports);
    RUN_TEST(doc_c_typedef_struct);
    RUN_TEST(doc_perl_pod_section_by_sub_name);
    RUN_TEST(doc_perl_module_doc_is_the_pod_no_sub_holds);
    RUN_TEST(doc_long_comment_kept_whole);
    RUN_TEST(doc_divider_only_run_is_not_doc);
    RUN_TEST(extract_ts_decorators_survive_interleaved_comment);

    /* #518/#519 — prose carried into docstring so nodes_fts can index it */
    RUN_TEST(markdown_section_body_becomes_docstring_issue518);
    RUN_TEST(markdown_section_body_stops_at_next_heading_issue518);
    RUN_TEST(markdown_section_body_heading_only_has_no_docstring_issue518);
    RUN_TEST(markdown_section_body_capped_utf8_safe_issue518);
    RUN_TEST(yaml_toplevel_description_promoted_to_module_issue519);
    RUN_TEST(yaml_block_scalar_description_promoted_issue519);
    RUN_TEST(yaml_summary_promoted_when_no_description_issue519);
    RUN_TEST(json_toplevel_description_promoted_to_module_issue519);
    RUN_TEST(config_description_only_at_top_level_issue519);
    RUN_TEST(non_config_language_module_has_no_promoted_description_issue519);
    RUN_TEST(extract_enclosing_sweep_matches_scan_issue1527);

    /* Syntax-tree walkers spend no stack per nesting level */
    RUN_TEST(extract_deep_callee_chain_completes);
    RUN_TEST(extract_deep_error_regions_complete);
    RUN_TEST(extract_deep_argument_nesting_completes);

    cbm_shutdown();
}