Function flatten_trait_into_class

internal/cbm/lsp/php_lsp.c:3673–3746

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;

    /* A trait cannot meaningfully flatten into itself. PHP itself rejects
     * `trait T { use T; }` ("Trait T cannot use itself"), and an aliased
     * `use X as Y; use Y;` can resolve back onto the enclosing trait by short
     * name. Without this guard the loop below copies the trait's own methods
     * back onto it with receiver_type == canonical_trait_qn; because each copy
     * then re-matches the loop's filter while cbm_registry_add_func() keeps
     * growing reg->func_count, the iteration never terminates — it arena-
     * allocates a fresh method every pass until the process exhausts all
     * memory (observed: 40 GB+, freezing the host). See regression test
     * phplsp_trait_self_use_terminates. */
    if (strcmp(class_qn, canonical_trait_qn) == 0)
        return;

    /* 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.
     *
     * Snapshot the count before iterating: cbm_registry_add_func() below
     * appends to reg->funcs, so the loop must never visit entries it adds
     * during iteration (a mutate-while-iterating hazard). */
    const int func_count_before = reg->func_count;
    for (int i = 0; i < func_count_before; 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) {