Function kt_process_lambda

internal/cbm/lsp/kotlin_lsp.c:2919–2973

}

static void kt_process_lambda(KotlinLSPContext *ctx, TSNode lambda, const CBMType *receiver_type) {
    /* lambda_literal: '{' lambda_parameters? '->' statements '}'
     * If no parameters, `it` is bound to the receiver. */
    if (ts_node_is_null(lambda)) {
        return;
    }
    ctx->current_scope = cbm_scope_push(ctx->arena, ctx->current_scope);
    const CBMType *prev_it = ctx->it_type;
    /* DSL receiver: when the callee's lambda parameter has a function-with-
     * receiver type (`Foo.() -> Unit`), the lambda's `this` is Foo and bare
     * calls inside resolve against Foo's members. The dsl_this_type is
     * passed via receiver_type when the caller can determine it. */
    const CBMType *prev_this = ctx->this_type;
    if (receiver_type && !cbm_type_is_unknown(receiver_type)) {
        ctx->this_type = receiver_type;
    }
    TSNode params = kt_child_kind(lambda, "lambda_parameters");
    if (ts_node_is_null(params)) {
        if (receiver_type && !cbm_type_is_unknown(receiver_type)) {
            ctx->it_type = receiver_type;
        }
    } else {
        uint32_t pnc = ts_node_named_child_count(params);
        for (uint32_t i = 0; i < pnc; i++) {
            TSNode pn = ts_node_named_child(params, i);
            TSNode id = kt_name_child(pn);
            if (ts_node_is_null(id)) {
                id = kt_child_kind_named(pn, "simple_identifier");
            }
            if (!ts_node_is_null(id)) {
                char *name = kt_node_text(ctx, id);
                if (name) {
                    /* Type annotation? */
                    TSNode tn = kt_child_kind(pn, "type");
                    const CBMType *t =
                        ts_node_is_null(tn) ? cbm_type_unknown() : kotlin_parse_type_node(ctx, tn);
                    cbm_scope_bind(ctx->current_scope, cbm_arena_strdup(ctx->arena, name), t);
                }
            }
        }
    }
    /* Walk lambda body */
    uint32_t nc = ts_node_named_child_count(lambda);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_named_child(lambda, i);
        const char *k = ts_node_type(c);
        if (strcmp(k, "lambda_parameters") == 0) {
            continue;
        }
        kt_process_statement(ctx, c);
    }
    ctx->it_type = prev_it;
    ctx->this_type = prev_this;
    ctx->current_scope = cbm_scope_pop(ctx->current_scope);
}

static void kt_process_call_with_lambda(KotlinLSPContext *ctx, TSNode call_node) {
    /* If call has trailing lambda, propagate the receiver type as `it`.