Function process_function_body

internal/cbm/lsp/ts_lsp.c:3057–3125

}

static void process_function_body(TSLSPContext *ctx, TSNode func_node, const char *func_qn,
                                  const char *class_qn) {
    if (ts_node_is_null(func_node))
        return;
    CBMScope *saved_scope = ctx->current_scope;
    const char *saved_func = ctx->enclosing_func_qn;
    const char *saved_class = ctx->enclosing_class_qn;

    ctx->current_scope = cbm_scope_push(ctx->arena, saved_scope);
    ctx->enclosing_func_qn = func_qn;
    ctx->enclosing_class_qn = class_qn ? class_qn : saved_class;

    if (class_qn) {
        // Bind `this` to the class type for member resolution within methods.
        cbm_scope_bind(ctx->current_scope, "this", cbm_type_named(ctx->arena, class_qn));
    }

    TSNode params =
        ts_node_child_by_field_name(func_node, "parameters", TS_LSP_FIELD_LEN("parameters"));
    if (!ts_node_is_null(params)) {
        uint32_t nc = ts_node_named_child_count(params);
        for (uint32_t i = 0; i < nc; i++)
            bind_parameter(ctx, ts_node_named_child(params, i));

        // JSDoc / signature-derived param-type fallback: if bind_parameter left a
        // param bound to UNKNOWN (no inline TS annotation), use the registered func's
        // signature param_types[i] (which apply_jsdoc_signatures may have populated).
        if (func_qn) {
            const CBMRegisteredFunc *rf = cbm_registry_lookup_func(ctx->registry, func_qn);
            if (rf && rf->signature && rf->signature->kind == CBM_TYPE_FUNC &&
                rf->signature->data.func.param_names && rf->signature->data.func.param_types) {
                for (int i = 0; rf->signature->data.func.param_names[i] &&
                                rf->signature->data.func.param_types[i];
                     i++) {
                    const char *pname = rf->signature->data.func.param_names[i];
                    const CBMType *ptype = rf->signature->data.func.param_types[i];
                    if (cbm_type_is_unknown(ptype))
                        continue;
                    const CBMType *existing = cbm_scope_lookup(ctx->current_scope, pname);
                    if (existing && !cbm_type_is_unknown(existing))
                        continue;
                    cbm_scope_bind(ctx->current_scope, pname, ptype);
                }
            }
        }
    }

    TSNode body = ts_node_child_by_field_name(func_node, "body", TS_LSP_FIELD_LEN("body"));
    if (!ts_node_is_null(body)) {
        // statement_block: walk every child statement. Expression body (concise
        // arrow): walk the expression directly — process_node on that handles
        // call_expression resolution.
        if (strcmp(ts_node_type(body), "statement_block") == 0) {
            TSTreeCursor cursor = ts_tree_cursor_new(body);
            if (ts_tree_cursor_goto_first_child(&cursor)) {
                do {
                    process_node(ctx, ts_tree_cursor_current_node(&cursor));
                } while (ts_tree_cursor_goto_next_sibling(&cursor));