Function flatten_trait_into_class

internal/cbm/lsp/php_lsp.c:3451–3506

Flatten the methods of a trait into the using class's method table. * * Tree-sitter-php emits `use Trait1, Trait2;` inside a class body as a * `use_declaration` (distinct from the namespace-level * namespace_use_declaration). The optional conflict resolution block * uses `use_instead_of_clause` (for `Trait1::foo insteadof Trait2`) and * `use_as_clause` (for `Trait2::foo as fooAlt`). * * Ph

 *   - skip insteadof (rare in practice; full support deferred)
 */
static void flatten_trait_into_class(PHPLSPContext *ctx, CBMTypeRegistry *reg, const char *class_qn,
                                     const char *trait_qn, const char *alias_for_method,
                                     const char *only_method_name) {
    if (!class_qn || !trait_qn)
        return;
    /* Resolve trait through alias-style lookup if needed. */
    const CBMRegisteredType *t = cbm_registry_lookup_type(reg, trait_qn);
    if (!t)
        t = lookup_type_with_project(ctx, trait_qn);
    const char *canonical_trait_qn = t ? t->qualified_name : trait_qn;

    /* Iterate registry funcs whose receiver_type is the trait.
     *
     * Self-substitution: when the trait's method has a return type that
     * names the trait itself (e.g. `tap(): self` registered as
     * NAMED(trait_qn)), rewrite it to NAMED(using_class_qn) so chains
     * like `$c->tap()->classMethod()` resolve correctly. */
    for (int i = 0; i < reg->func_count; i++) {
        const CBMRegisteredFunc *src = &reg->funcs[i];
        if (!src->receiver_type || strcmp(src->receiver_type, canonical_trait_qn) != 0) {
            continue;
        }
        if (only_method_name && src->short_name && strcmp(src->short_name, only_method_name) != 0) {
            continue;
        }
        const char *new_short = alias_for_method ? alias_for_method : src->short_name;
        if (!new_short)
            continue;
        CBMRegisteredFunc rf;
        memset(&rf, 0, sizeof(rf));
        rf.qualified_name = cbm_arena_sprintf(ctx->arena, "%s.%s", class_qn, new_short);
        rf.short_name = cbm_arena_strdup(ctx->arena, new_short);
        rf.receiver_type = class_qn;
        rf.min_params = src->min_params;

        /* Self-substitute the return type: any NAMED(trait_qn) in the
         * signature's return becomes NAMED(class_qn). */
        const CBMType *new_sig = src->signature;
        if (src->signature && src->signature->kind == CBM_TYPE_FUNC &&
            src->signature->data.func.return_types) {
            const CBMType *ret0 = src->signature->data.func.return_types[0];
            if (ret0 && ret0->kind == CBM_TYPE_NAMED && ret0->data.named.qualified_name &&
                strcmp(ret0->data.named.qualified_name, canonical_trait_qn) == 0) {
                const CBMType **rets =
                    (const CBMType **)cbm_arena_alloc(ctx->arena, 2 * sizeof(*rets));
                if (rets) {
                    rets[0] = cbm_type_named(ctx->arena, class_qn);
                    rets[1] = NULL;
                    new_sig = cbm_type_func(ctx->arena, NULL, NULL, rets);
                }
            }
        }
        rf.signature = new_sig;
        cbm_registry_add_func(reg, rf);
    }
}

static void process_trait_use(PHPLSPContext *ctx, CBMTypeRegistry *reg, const char *class_qn,