Function kt_process_function_body

internal/cbm/lsp/kotlin_lsp.c:3276–3387

/* ── top-level walking ────────────────────────────────────────────── */

static void kt_process_function_body(KotlinLSPContext *ctx, TSNode func_node, const char *func_qn,
                                     const char *receiver_class_qn) {
    const char *prev_func = ctx->enclosing_func_qn;
    const char *prev_class = ctx->enclosing_class_qn;
    const CBMType *prev_this = ctx->this_type;
    const CBMType *prev_super = ctx->super_type;
    const char *prev_super_qn = ctx->enclosing_super_qn;

    ctx->enclosing_func_qn = func_qn;
    const CBMRegisteredType *receiver_rt = NULL;
    if (receiver_class_qn) {
        ctx->this_type = cbm_type_named(ctx->arena, receiver_class_qn);
        receiver_rt = cbm_registry_lookup_type(ctx->registry, receiver_class_qn);
        if (receiver_rt && receiver_rt->embedded_types && receiver_rt->embedded_types[0]) {
            ctx->enclosing_super_qn = receiver_rt->embedded_types[0];
            ctx->super_type = cbm_type_named(ctx->arena, receiver_rt->embedded_types[0]);
        }
    }

    ctx->current_scope = cbm_scope_push(ctx->arena, ctx->current_scope);
    kt_bind_function_params(ctx, func_node);

    /* Bind class fields (primary-constructor val/var properties) into the
     * method scope so bare references like `name.uppercase()` inside a
     * method body resolve to the field's type. */
    if (receiver_rt && receiver_rt->field_names && receiver_rt->field_types) {
        for (int i = 0; receiver_rt->field_names[i]; i++) {
            cbm_scope_bind(ctx->current_scope,
                           cbm_arena_strdup(ctx->arena, receiver_rt->field_names[i]),
                           receiver_rt->field_types[i]);
        }
    }

    TSNode body = kt_field_named(func_node, "body");
    if (ts_node_is_null(body)) {
        body = kt_child_kind(func_node, "function_body");
    }
    if (ts_node_is_null(body)) {
        body = kt_child_kind(func_node, "block");
    }
    /* Fallback: some grammar variants emit the single-expression body
     * directly as a child of function_declaration without wrapping it in
     * `function_body`. Scan the named children for the last node that
     * looks like an expression or statement (i.e. not modifiers, name,
     * type parameters, or value parameters). */
    if (ts_node_is_null(body)) {
        uint32_t nc = ts_node_named_child_count(func_node);
        for (uint32_t i = nc; i > 0; i--) {
            TSNode c = ts_node_named_child(func_node, i - 1);
            if (ts_node_is_null(c)) {
                continue;
            }
            const char *k = ts_node_type(c);
            if (strcmp(k, "modifiers") == 0 || strcmp(k, "identifier") == 0 ||
                strcmp(k, "simple_identifier") == 0 ||
                strcmp(k, "function_value_parameters") == 0 || strcmp(k, "type_parameters") == 0 ||
                strcmp(k, "type_constraints") == 0 || strcmp(k, "annotation") == 0) {
                continue;