Function compute_func_qn

internal/cbm/extract_unified.c:697–887

Compute function QN for scope tracking (mirrors cbm_enclosing_func_qn logic).

// Compute function QN for scope tracking (mirrors cbm_enclosing_func_qn logic).
static const char *compute_func_qn(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec,
                                   WalkState *state) {
    (void)spec;
    if (ctx->language == CBM_LANG_WOLFRAM) {
        return compute_wolfram_func_qn(ctx, node);
    }
    if (ctx->language == CBM_LANG_OBJECTSCRIPT_UDL) {
        return objectscript_get_method_qn(ctx, node, state->enclosing_class_qn);
    }
    if (ctx->language == CBM_LANG_OBJECTSCRIPT_ROUTINE) {
        const char *kind = ts_node_type(node);
        TSNode tag = {0};
        if (strcmp(kind, "procedure") == 0) {
            tag = cbm_find_child_by_kind(node, "tag");
        } else if (strcmp(kind, "tag") == 0) {
            /* The enclosing procedure owns the full callable range and already
             * pushed this QN. Do not create a nested label-only function scope. */
            TSNode parent = ts_node_parent(node);
            if (ts_node_is_null(parent) || strcmp(ts_node_type(parent), "procedure") != 0) {
                tag = node;
            }
        }
        if (!ts_node_is_null(tag)) {
            char *name = cbm_node_text(ctx->arena, tag, ctx->source);
            if (name && name[0]) {
                return cbm_fqn_compute(ctx->arena, ctx->project, ctx->rel_path, name);
            }
        }
        return NULL;
    }

    /* CFML tag dialect: <cffunction name="foo"> is a cf_function_tag whose name
     * lives in a cf_attribute, not a `name` field — gate here where ctx->source
     * is available to read the attribute. Other CFML func nodes (embedded
     * CFScript function_declaration/_expression) fall through to the shared
     * resolver below. */
    if (ctx->language == CBM_LANG_CFML && strcmp(ts_node_type(node), "cf_function_tag") == 0) {
        return compute_cfml_func_qn(ctx, node);
    }

    /* Go templates: {{ define "x" }} is a define_action whose name is a quoted
     * string literal — strip the quotes here (the shared resolver has no source). */
    if (ctx->language == CBM_LANG_GOTEMPLATE) {
        return compute_gotemplate_func_qn(ctx, node);
    }

    /* Lisp family (Clojure/Scheme/Racket): the def node is a list/list_lit, a
     * very general kind that also matches plain call forms. The shared resolver
     * has no source pointer to read the head symbol, so the def-vs-call gate
     * lives here (we have ctx->source). Non-def lists return NULL → no scope
     * pushed → the in-body call sources to the enclosing def, not the Module. */
    if (ctx->language == CBM_LANG_CLOJURE || ctx->language == CBM_LANG_SCHEME ||
        ctx->language == CBM_LANG_RACKET) {
        return compute_lisp_func_qn(ctx, node);
    }

    /* Elixir: def/defp/defmacro are `call` nodes (so is every in-body call).
     * Gate on the def-macro target text so only definitions push a scope. */