Function eval_conditional

internal/cbm/lsp/ts_lsp.c:1173–1216

Evaluate a CBM_TYPE_CONDITIONAL `T extends U ? X : Y`. With distribution: when T is a UNION, evaluate per member and union the results. Uses the partial relater for the extends check.

// a UNION, evaluate per member and union the results. Uses the partial relater for
// the extends check.
static const CBMType *eval_conditional(TSLSPContext *ctx, const CBMType *t, int depth) {
    if (!t || t->kind != CBM_TYPE_CONDITIONAL || depth > 16)
        return t;
    const CBMType *check = t->data.conditional.check;
    const CBMType *extends = t->data.conditional.extends;
    const CBMType *tb = t->data.conditional.true_branch;
    const CBMType *fb = t->data.conditional.false_branch;
    if (!check || !extends)
        return t;

    // Distribution: when check is a UNION, evaluate per member and union results.
    if (check->kind == CBM_TYPE_UNION && check->data.union_type.members &&
        check->data.union_type.count > 0) {
        const CBMType **results = (const CBMType **)cbm_arena_alloc(
            ctx->arena, (size_t)(check->data.union_type.count + 1) * sizeof(const CBMType *));
        if (!results)
            return t;
        int n = 0;
        for (int i = 0; i < check->data.union_type.count; i++) {
            const CBMType *member = check->data.union_type.members[i];
            const CBMType *sub = cbm_type_conditional(ctx->arena, member, extends, tb, fb);
            results[n++] = eval_conditional(ctx, sub, depth + 1);
        }
        results[n] = NULL;
        if (n == 1)
            return results[0];
        return cbm_type_union(ctx->arena, results, n);
    }

    // `infer X` in extends pattern: pattern-match check against extends, capturing
    // bindings, then substitute them in the true_branch.
    if (contains_infer(extends, 0)) {
        TSInferBinding binds[TS_INFER_MAX] = {{0}};
        int bind_count = 0;
        if (match_with_infer(ctx, check, extends, binds, &bind_count, 0)) {
            return subst_infer_bindings(ctx, tb, binds, bind_count, 0);
        }
        return fb;
    }

    // Non-distributive: single resolution.
    bool yes = ts_is_assignable(ctx, check, extends);
    return yes ? tb : fb;
}

// Resolve a CBMType against the registry's alias chain when it's a NAMED type that's a
// pure alias (`type Foo = Bar`). Also evaluates inline conditional types.