Function cbm_ast_profile_compute

src/semantic/ast_profile.c:243–317

}

bool cbm_ast_profile_compute(TSNode func_body, const char *source, const char **param_names,
                             int param_count, cbm_ast_profile_t *out) {
    if (ts_node_is_null(func_body)) {
        return false;
    }

    memset(out, 0, sizeof(*out));
    out->param_count = (uint16_t)param_count;

    uint32_t op_set[HALSTEAD_SET_SIZE];
    uint32_t operand_set[HALSTEAD_SET_SIZE];
    memset(op_set, 0, sizeof(op_set));
    memset(operand_set, 0, sizeof(operand_set));

    int total_depth = 0;
    int node_count = 0;
    bool in_return = false;
    bool in_condition = false;

    profile_frame_t stack[WALK_STACK_CAP];
    int top = 0;
    stack[top++] = (profile_frame_t){func_body, 0};

    while (top > 0) {
        profile_frame_t frame = stack[--top];
        TSNode node = frame.node;
        int depth = frame.depth;
        uint32_t child_count = ts_node_child_count(node);
        const char *kind = ts_node_type(node);

        if (!ts_node_is_named(node) && child_count == 0) {
            /* Anonymous leaf (punctuation, keywords) — skip. */
            goto push_children;
        }

        node_count++;
        total_depth += depth;

        if ((uint16_t)depth > out->max_nesting_depth) {
            out->max_nesting_depth = (uint16_t)depth;
        }

        accumulate_control_flow(kind, out, &in_return);
        accumulate_expressions(kind, out);
        accumulate_halstead(kind, child_count, op_set, operand_set, out);
        accumulate_data_flow(node, kind, child_count, source, param_names, param_count, in_return,
                             in_condition, out);

        /* Track context for data flow: are we inside a condition? */
        if (is_control_if(kind) || is_control_while(kind)) {
            in_condition = true;
        }

    push_children:
        /* Reset context flags when leaving return/condition scope */
        if (is_return(kind)) {
            in_return = false;
        }