Function extract_func_def

internal/cbm/extract_defs.c:3556–3783

}

static void extract_func_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec) {
    CBMArena *a = ctx->arena;

    TSNode name_node = cbm_resolve_func_name(node, ctx->language);
    if (ts_node_is_null(name_node)) {
        return;
    }

    char *name = cbm_func_name_node_text(a, name_node, ctx->source, ctx->language);
    if (!name || !name[0] || strcmp(name, "function") == 0) {
        return;
    }

    // Makefile special targets (.PHONY, .DEFAULT, .SUFFIXES, …) are directives,
    // not build-rule defs. Their leading '.' would also make cbm_fqn_compute
    // emit a "..PHONY" segment (a "double dot") and thus a malformed QN. Skip
    // any dot-prefixed Make target.
    if (ctx->language == CBM_LANG_MAKEFILE && name[0] == '.') {
        return;
    }

    /* C++/CUDA: GoogleTest macros (TEST, TEST_F, TEST_P, ...) parse as
     * function definitions whose name resolves to the bare macro identifier.
     * Multiple test cases per file collide on qualified name; derive a unique
     * name from the macro arguments so each gets its own graph node (#1266). */
    bool is_gtest = false;
    if ((ctx->language == CBM_LANG_CPP || ctx->language == CBM_LANG_CUDA) &&
        is_cpp_test_macro(name)) {
        char *gtest_name = resolve_cpp_test_macro_name(a, name, node, ctx->source);
        if (gtest_name) {
            name = gtest_name;
            is_gtest = true;
        }
    }

    /* Nix `"${foo}" = x: …`: an interpolated attrpath segment has no statically
     * knowable name. Minting it would produce a def literally named `"${foo}"`
     * that nothing can ever look up or resolve a call against. An absent node is
     * the honest answer — same reasoning as the Makefile guard above. */
    if (ctx->language == CBM_LANG_NIX && cbm_nix_attr_is_interpolated(name_node)) {
        return;
    }

    TSNode func_node = unwrap_template_inner(node, ctx->language);

    CBMDefinition def;
    memset(&def, 0, sizeof(def));

    def.name = name;
    /* Nix: a binding's name is a path. The leaf is the name; the leading segments
     * are scope, so `a.b.fn = …` gets the same QN as `a = { b = { fn = …; }; }`.
     * Without this every binding whose path shares a leaf name collapsed onto one
     * node, silently discarding the later definition and its CALLS edges. */
    const char *qn_name = name;
    if (ctx->language == CBM_LANG_NIX) {
        qn_name = cbm_nix_qn_name(a, node, ctx->source, name);
    }
    /* Java/Go derive the module from the containing directory (package), so the