Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

fix(php): index trait methods by receiver while flattening (#1265)

Martin Vogel9adada0185f8
diff --git a/internal/cbm/lsp/php_lsp.c b/internal/cbm/lsp/php_lsp.c
index 571b1493b..e26dc5c20 100644
--- a/internal/cbm/lsp/php_lsp.c
+++ b/internal/cbm/lsp/php_lsp.c
@@ -19,7 +19,9 @@
#include "php_lsp.h"
#include "lsp_node_iter.h"
+#include "lsp_work.h"
#include "../helpers.h"
+#include "../../../src/foundation/hash_table.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
@@ -3745,6 +3747,126 @@ static void apply_phpdoc_class_tags(PHPLSPContext *ctx, CBMTypeRegistry *reg, co
* - handle `as` aliasing: register method under the alias name too
* - skip insteadof (rare in practice; full support deferred)
*/
+/* The registry indices of each receiver's methods, in registration order.
+ * Flattening a trait used to visit EVERY registered function to find the
+ * trait's own, so a file whose classes use traits paid O(uses x functions),
+ * and the functions grow with every class flattened before: quadratic in the
+ * trait-using classes of one file (#1265). The registry is append-only, so
+ * the index catches up incrementally (indexed_upto) and never misses a
+ * function registered between two flattens. */
+typedef struct {
+ int *items;
+ int count;
+ int cap;
+} php_func_ids_t;
+
+struct php_trait_index {
+ CBMHashTable *by_receiver; /* receiver_type (borrowed) -> php_func_ids_t* */
+ int indexed_upto; /* reg->funcs[0, indexed_upto) are indexed */
+ bool failed; /* allocation failed: callers use the full scan */
+};
+
+static bool php_func_ids_push(CBMArena *arena, php_func_ids_t *ids, int func_index) {
+ if (ids->count == ids->cap) {
+ int cap = ids->cap ? ids->cap * 2 : 4;
+ int *items = (int *)cbm_arena_alloc(arena, (size_t)cap * sizeof(*items));
+ if (!items) {
+ return false;
+ }
+ if (ids->count > 0) {
+ memcpy(items, ids->items, (size_t)ids->count * sizeof(*items));
+ }
+ ids->items = items;
+ ids->cap = cap;
+ }
+ ids->items[ids->count++] = func_index;
+ return true;
+}
+
+/* Index every function registered since the last call. Returns false (and
+ * marks the index failed for good) on an allocation failure. */
+static bool php_trait_index_sync(PHPLSPContext *ctx, struct php_trait_index *ix,
+ const CBMTypeRegistry *reg) {
+ if (ix->failed) {
+ return false;
+ }
+ if (!ix->by_receiver) {
+ ix->by_receiver = cbm_ht_create(0);
+ if (!ix->by_receiver) {
+ ix->failed = true;
+ return false;
+ }
+ }
+ for (; ix->indexed_upto < reg->func_count; ix->indexed_upto++) {
+ CBM_LSP_WORK(1);
+ const char *receiver = reg->funcs[ix->indexed_upto].receiver_type;
+ if (!receiver) {
+ continue;
+ }
+ php_func_ids_t *ids = (php_func_ids_t *)cbm_ht_get(ix->by_receiver, receiver);
+ if (!ids) {
+ ids = (php_func_ids_t *)cbm_arena_alloc(ctx->arena, sizeof(*ids));
+ if (!ids) {
+ ix->failed = true;
+ return false;
+ }
+ memset(ids, 0, sizeof(*ids));
+ cbm_ht_set(ix->by_receiver, receiver, ids);
+ }
+ if (!php_func_ids_push(ctx->arena, ids, ix->indexed_upto)) {
+ ix->failed = true;
+ return false;
+ }
+ }
+ return true;
+}
+
+static void php_trait_index_free(struct php_trait_index *ix) {
+ if (ix->by_receiver) {
+ cbm_ht_free(ix->by_receiver);
+ ix->by_receiver = NULL;
+ }
+}
+
+/* Copy one method `src` of the trait into class_qn (see
+ * flatten_trait_into_class). Reads src before registering, because
+ * cbm_registry_add_func may move reg->funcs. */
+static void flatten_trait_method(PHPLSPContext *ctx, CBMTypeRegistry *reg, const char *class_qn,
+ const char *canonical_trait_qn, const CBMRegisteredFunc *src,
+ const char *alias_for_method, const char *only_method_name) {
+ if (only_method_name && src->short_name && strcmp(src->short_name, only_method_name) != 0) {
+ return;
+ }
+ const char *new_short = alias_for_method ? alias_for_method : src->short_name;
+ if (!new_short)
+ return;
+ 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_replace_returns(ctx->arena, src->signature, rets);
+ }
+ }
+ }
+ rf.signature = new_sig;
+ cbm_registry_add_func(reg, rf);
+}
+
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) {
@@ -3780,43 +3902,36 @@ static void flatten_trait_into_class(PHPLSPContext *ctx, CBMTypeRegistry *reg, c
* 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;
+ struct php_trait_index *ix = ctx->trait_index;
+ if (ix && php_trait_index_sync(ctx, ix, reg)) {
+ /* Only the trait's own methods, in registration order; the ids are
+ * ascending, so the snapshot bound ends the walk. No sync runs inside
+ * the loop, so the list cannot change under it. */
+ const php_func_ids_t *ids =
+ (const php_func_ids_t *)cbm_ht_get(ix->by_receiver, canonical_trait_qn);
+ for (int j = 0; ids && j < ids->count && ids->items[j] < func_count_before; j++) {
+ CBM_LSP_WORK(1);
+ if (CBM_LSP_WORK_CEILING_HIT()) {
+ break; /* test seam only (#765, #1265): see lsp_work.h */
+ }
+ flatten_trait_method(ctx, reg, class_qn, canonical_trait_qn, &reg->funcs[ids->items[j]],
+ alias_for_method, only_method_name);
+ }
+ return;
+ }
+ /* No index (no owning pass, or it could not allocate): the full scan,
+ * which yields the same methods in the same order. */
for (int i = 0; i < func_count_before; i++) {
+ CBM_LSP_WORK(1);
+ if (CBM_LSP_WORK_CEILING_HIT()) {
+ break; /* test seam only (#765, #1265): see lsp_work.h */
+ }
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_replace_returns(ctx->arena, src->signature, rets);
- }
- }
- }
- rf.signature = new_sig;
- cbm_registry_add_func(reg, rf);
+ flatten_trait_method(ctx, reg, class_qn, canonical_trait_qn, src, alias_for_method,
+ only_method_name);
}
}
@@ -4217,6 +4332,9 @@ static void php_lsp_collect_class_fields(PHPLSPContext *ctx, CBMTypeRegistry *re
* Pass 2: classes and enums (which may `use Trait;` and need the
* trait's signatures already patched).
*/
+ struct php_trait_index trait_index = {0};
+ struct php_trait_index *outer_index = ctx->trait_index;
+ ctx->trait_index = &trait_index;
for (int pass = 0; pass < 2; pass++) {
TSNode stack[256];
int top = 0;
@@ -4241,6 +4359,8 @@ static void php_lsp_collect_class_fields(PHPLSPContext *ctx, CBMTypeRegistry *re
}
}
}
+ php_trait_index_free(&trait_index);
+ ctx->trait_index = outer_index;
}
void cbm_php_refine_lsp_registry(PHPLSPContext *ctx, CBMTypeRegistry *reg, TSNode root) {
diff --git a/internal/cbm/lsp/php_lsp.h b/internal/cbm/lsp/php_lsp.h
index 3843822a3..a6ba1cd01 100644
--- a/internal/cbm/lsp/php_lsp.h
+++ b/internal/cbm/lsp/php_lsp.h
@@ -71,6 +71,11 @@ typedef struct {
* Zero via memset. */
int walk_depth;
+ /* Receiver -> registered-method index used while traits are flattened
+ * (php_lsp.c, php_trait_index_t). Owned by the class-field pass, NULL
+ * outside it. Zero via memset. */
+ struct php_trait_index *trait_index;
+
/* Debug mode (CBM_LSP_DEBUG env). */
bool debug;
} PHPLSPContext;
diff --git a/tests/test_php_lsp.c b/tests/test_php_lsp.c
index 344bedf39..04ff1001d 100644
--- a/tests/test_php_lsp.c
+++ b/tests/test_php_lsp.c
@@ -653,6 +653,125 @@ static uint64_t phplsp_counted_work(const char *src, int *ceiling_hit, CBMFileRe
return work;
}
+/* Every reported collision shape, in one file: #765's aliased import that
+ * shares the trait's name, the v0.9.0 variant where the alias TARGET's short
+ * name equals the local trait (owen-it/laravel-auditing wrapper), #951's
+ * class named like its aliased trait, a self-using trait and a mutual pair. A
+ * model using the wrapper trait still sees the flattened method. */
+TEST(phplsp_trait_collision_shapes_bounded_work_issue765) {
+ const char *src = "<?php\n"
+ "namespace App\\Models\\Traits;\n"
+ "\n"
+ "use OwenIt\\Auditing\\Auditable as AuditableBase;\n"
+ "use App\\Functions\\Delivery as Delivery_Trait;\n"
+ "\n"
+ "trait Auditable {\n"
+ " use AuditableBase;\n"
+ " public function auditTag(): string { $x = 'a'; return $x; }\n"
+ "}\n"
+ "trait Selfish {\n"
+ " use Selfish;\n"
+ " public function me(): int { return 1; }\n"
+ "}\n"
+ "trait Ping {\n"
+ " use Pong;\n"
+ " public function ping(): int { return 1; }\n"
+ "}\n"
+ "trait Pong {\n"
+ " use Ping;\n"
+ " public function pong(): int { return 2; }\n"
+ "}\n"
+ "class Delivery {\n"
+ " use Delivery_Trait;\n"
+ " public function run(): void { }\n"
+ "}\n"
+ "class User {\n"
+ " use Auditable, Ping;\n"
+ " public function label(): string { return $this->auditTag(); }\n"
+ " public function both(): int { return $this->ping() + $this->pong(); }\n"
+ "}\n";
+ int hit = 0;
+ CBMFileResult *r = NULL;
+ uint64_t work = phplsp_counted_work(src, &hit, &r);
+ printf(" collision shapes: work=%llu\n", (unsigned long long)work);
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(hit);
+ /* The flattened trait method is still found through the using class. */
+ ASSERT(find_resolved(r, "label", "auditTag") >= 0);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* n classes in one file, each composing the same two traits, and one probe
+ * class calling a flattened method through $this. */
+static char *phplsp_trait_users_source(int n) {
+ size_t sz = (size_t)n * 256 + 1024;
+ char *src = malloc(sz);
+ if (!src) {
+ return NULL;
+ }
+ size_t pos = (size_t)snprintf(src, sz,
+ "<?php\nnamespace App\\Bulk;\n\n"
+ "trait Stamps {\n"
+ " public function stamp(): int { return 1; }\n"
+ " public function touch(): int { return 2; }\n"
+ " public function fresh(): int { return 3; }\n"
+ "}\n"
+ "trait Flags {\n"
+ " use Stamps;\n"
+ " public function flag(): int { return 4; }\n"
+ "}\n");
+ for (int i = 0; i < n; i++) {
+ pos += (size_t)snprintf(src + pos, sz - pos,
+ "class M%d {\n"
+ " use Flags;\n"
+ " public function own%d(): int { return %d; }\n"
+ "}\n",
+ i, i, i);
+ }
+ /* One call through a flattened method, so the lookup cost stays constant
+ * and the gate measures flattening (F12: the single-file registry is not
+ * finalized, so every lookup is a linear scan; that is its own defect). */
+ snprintf(src + pos, sz - pos,
+ "class Probe {\n"
+ " use Flags;\n"
+ " public function probe(): int { return $this->stamp(); }\n"
+ "}\n");
+ return src;
+}
+
+/* Deterministic complexity gate: twice the trait-using classes must cost about
+ * twice the counted work. Each flatten visits the registry; if that visit grows
+ * with the classes already flattened, the ratio drifts toward 4 (main before the
+ * per-trait method index: 3.22 at 150 -> 300). Both sizes stay below the 256
+ * top-level declarations the class-field walk visits (#2388), so every class
+ * is flattened. */
+TEST(phplsp_trait_flatten_work_is_linear_issue1265) {
+ enum { N1 = 100, N2 = 200 };
+ char *s1 = phplsp_trait_users_source(N1);
+ char *s2 = phplsp_trait_users_source(N2);
+ ASSERT_NOT_NULL(s1);
+ ASSERT_NOT_NULL(s2);
+ int hit1 = 0;
+ int hit2 = 0;
+ CBMFileResult *r2 = NULL;
+ uint64_t w1 = phplsp_counted_work(s1, &hit1, NULL);
+ uint64_t w2 = phplsp_counted_work(s2, &hit2, &r2);
+ free(s1);
+ free(s2);
+ printf(" trait users %d -> %d: work %llu -> %llu (ratio %.2f)\n", N1, N2,
+ (unsigned long long)w1, (unsigned long long)w2, w1 ? (double)w2 / (double)w1 : 0.0);
+ ASSERT_NOT_NULL(r2);
+ ASSERT_FALSE(hit1);
+ ASSERT_FALSE(hit2);
+ ASSERT(w1 > 0);
+ /* The flattened method still resolves through the probe class. */
+ ASSERT(find_resolved(r2, "Probe.probe", "stamp") >= 0);
+ cbm_free_result(r2);
+ ASSERT(w2 * 10 <= w1 * 25); /* ratio <= 2.5 */
+ PASS();
+}
+
/* F12: the single-file PHP LSP (cbm_run_php_lsp) never indexed its registry,
* so every type and method lookup was a linear scan over the stdlib plus every
* definition of the file. Each class here looks up the previous class and its
@@ -5747,6 +5866,8 @@ SUITE(php_lsp) {
RUN_TEST(phplsp_trait_self_use_terminates);
RUN_TEST(phplsp_trait_aliased_import_name_collision_terminates);
RUN_TEST(phplsp_class_aliased_trait_name_collision_terminates);
+ RUN_TEST(phplsp_trait_collision_shapes_bounded_work_issue765);
+ RUN_TEST(phplsp_trait_flatten_work_is_linear_issue1265);
RUN_TEST(phplsp_single_file_lookup_work_is_linear_f12);
RUN_TEST(phplsp_match_result_type);
RUN_TEST(phplsp_ternary_result_type);