Function process_node

internal/cbm/lsp/ts_lsp.c:3268–3632

}

static void process_node(TSLSPContext *ctx, TSNode node) {
    if (!ctx || ts_node_is_null(node))
        return;
    const char *kind = ts_node_type(node);

    /* A nested statement block owns `let`/`const` declarations. Function-body
     * blocks are intentionally unwrapped by process_function_body(), so this
     * branch applies only to nested lexical blocks and cannot hide parameters. */
    if (strcmp(kind, "statement_block") == 0) {
        CBMScope *saved = ctx->current_scope;
        ctx->current_scope = cbm_scope_push(ctx->arena, saved);
        TSTreeCursor cursor = ts_tree_cursor_new(node);
        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));
        }
        ts_tree_cursor_delete(&cursor);
        ctx->current_scope = saved;
        return;
    }

    // Scope-affecting statements bind first, then we recurse.
    ts_process_statement(ctx, node);

    if (strcmp(kind, "call_expression") == 0) {
        resolve_call_at(ctx, node);
        resolve_value_references_at(ctx, node);

        // Contextual callback typing: when an arg is an arrow_function and the
        // corresponding param of the called function is itself a FUNC, propagate the
        // expected callback param types into the arrow's body before walking it.
        // Handle arg processing manually for this path to avoid double-walking via
        // default recurse below.
        do {
            TSNode fn_node =
                ts_node_child_by_field_name(node, "function", TS_LSP_FIELD_LEN("function"));
            if (ts_node_is_null(fn_node))
                break;
            TSNode args =
                ts_node_child_by_field_name(node, "arguments", TS_LSP_FIELD_LEN("arguments"));
            if (ts_node_is_null(args))
                break;
            const CBMType *fn_type = ts_signature_for_call(ctx, fn_node, args);
            if (!fn_type || fn_type->kind != CBM_TYPE_FUNC)
                break;
            if (!fn_type->data.func.param_types)
                break;

            // Process the function child for nested call resolution.
            process_node(ctx, fn_node);

            // param_types is NULL-terminated (no count field). Measure its
            // length so we never index past the terminator: a call may pass
            // more args than the function declares params (e.g. excess/variadic
            // args), and the extra args simply have no expected type. Indexing
            // param_types[i] by the raw arg count read out of bounds → garbage
            // CBMType* → crash on expected->kind.