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.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
fix(python): retain typed fields across file boundaries
Martin Vogel519c765e1fd6
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.cindex 082bca1d6..4d01d0c69 100644--- a/internal/cbm/cbm.c+++ b/internal/cbm/cbm.c@@ -243,6 +243,11 @@ void cbm_typeassign_push(CBMTypeAssignArray *arr, CBMArena *a, CBMTypeAssign ta)arr->items[arr->count++] = ta;}+void cbm_fieldtype_push(CBMFieldTypeArray *arr, CBMArena *a, CBMFieldType ft) {+ GROW_ARRAY(arr, a);+ arr->items[arr->count++] = ft;+}+void cbm_stringref_push(CBMStringRefArray *arr, CBMArena *a, CBMStringRef sr) {GROW_ARRAY(arr, a);arr->items[arr->count++] = sr;diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.hindex fb5e446a5..7563fa6b5 100644--- a/internal/cbm/cbm.h+++ b/internal/cbm/cbm.h@@ -405,6 +405,17 @@ typedef struct {CBMChannelDirection direction;} CBMChannel;+/* Python: one annotated instance field of a class -- `x: T` or `x: T = v` in+ * the class body, `self.x: T = v` in __init__, or `self.x = p` where `p` is an+ * annotated __init__ parameter. Not a graph node: it only carries the field's+ * declared type to the cross-file LSP, so `obj.x.m()` on a class imported+ * from another file can be typed (#1277). */+typedef struct {+ const char *class_qn; // QN of the owning class+ const char *field_name; // attribute name+ const char *type_text; // raw annotation text, resolved later per file+} CBMFieldType;+// Rust: impl Trait for Structtypedef struct {const char *trait_name; // trait name (raw text)@@ -518,6 +529,12 @@ typedef struct {int cap;} CBMChannelArray;+typedef struct {+ CBMFieldType *items;+ int count;+ int cap;+} CBMFieldTypeArray;+// Full extraction result for one file.typedef struct CBMFileResult {CBMArena arena; // owns local memory; composites may also retain child arenas below@@ -536,6 +553,7 @@ typedef struct CBMFileResult {CBMStringRefArray string_refs; // URL/config string literals from ASTCBMInfraBindingArray infra_bindings; // topic→URL pairs from IaC configsCBMChannelArray channels; // Socket.IO / EventEmitter pub/sub participation+ CBMFieldTypeArray field_types; // Python: annotated instance fields (#1277)const char *module_qn; // module qualified nameconst char *namespace_name; // declared namespace/package (Java/Kotlin/C#/PHP), NULL if none@@ -892,6 +910,7 @@ void cbm_rw_push(CBMRWArray *arr, CBMArena *a, CBMReadWrite rw);void cbm_typerefs_push(CBMTypeRefArray *arr, CBMArena *a, CBMTypeRef tr);void cbm_envaccess_push(CBMEnvAccessArray *arr, CBMArena *a, CBMEnvAccess ea);void cbm_typeassign_push(CBMTypeAssignArray *arr, CBMArena *a, CBMTypeAssign ta);+void cbm_fieldtype_push(CBMFieldTypeArray *arr, CBMArena *a, CBMFieldType ft);void cbm_stringref_push(CBMStringRefArray *arr, CBMArena *a, CBMStringRef sr);void cbm_infrabinding_push(CBMInfraBindingArray *arr, CBMArena *a, CBMInfraBinding ib);void cbm_impltrait_push(CBMImplTraitArray *arr, CBMArena *a, CBMImplTrait it);diff --git a/internal/cbm/extract_defs.c b/internal/cbm/extract_defs.cindex bb56e2870..de5b2e90d 100644--- a/internal/cbm/extract_defs.c+++ b/internal/cbm/extract_defs.c@@ -4584,6 +4584,169 @@ static bool extract_sql_ddl_class_def(CBMExtractCtx *ctx, TSNode node, const chareturn true;}+/* ── Python annotated instance fields (#1277) ─────────────────────+ * Exported as result->field_types (never graph nodes) so the cross-file LSP+ * can type `obj.x` when obj's class lives in another file. Only DECLARED+ * types count: a class-body annotation, a `self.x: T = v` annotation in+ * __init__, or `self.x = p` where p is an annotated __init__ parameter. An+ * unannotated right-hand side is never guessed at. */++static void py_push_field_type(CBMExtractCtx *ctx, const char *class_qn, TSNode name_node,+ const char *type_text) {+ char *name = cbm_node_text(ctx->arena, name_node, ctx->source);+ if (!name || !name[0] || !type_text || !type_text[0]) {+ return;+ }+ CBMFieldType ft = {.class_qn = class_qn, .field_name = name, .type_text = type_text};+ cbm_fieldtype_push(&ctx->result->field_types, ctx->arena, ft);+}++/* The assignment inside an expression_statement, or a null node. */+static TSNode py_statement_assignment(TSNode stmt) {+ TSNode null_node = {0};+ if (strcmp(ts_node_type(stmt), "expression_statement") != 0 ||+ ts_node_named_child_count(stmt) == 0) {+ return null_node;+ }+ TSNode inner = ts_node_named_child(stmt, 0);+ return strcmp(ts_node_type(inner), "assignment") == 0 ? inner : null_node;+}++/* Annotation text of the __init__ parameter called `name`, or NULL. */+static const char *py_init_param_annotation(CBMExtractCtx *ctx, TSNode params, const char *name) {+ uint32_t n = ts_node_named_child_count(params);+ for (uint32_t i = 0; i < n; i++) {+ TSNode p = ts_node_named_child(params, i);+ const char *pk = ts_node_type(p);+ TSNode pname = {0};+ if (strcmp(pk, "typed_default_parameter") == 0) {+ pname = ts_node_child_by_field_name(p, TS_FIELD("name"));+ } else if (strcmp(pk, "typed_parameter") == 0 && ts_node_named_child_count(p) > 0) {+ pname = ts_node_named_child(p, 0);+ } else {+ continue;+ }+ TSNode ptype = ts_node_child_by_field_name(p, TS_FIELD("type"));+ if (ts_node_is_null(pname) || ts_node_is_null(ptype) ||+ strcmp(ts_node_type(pname), "identifier") != 0) {+ continue;+ }+ char *pn = cbm_node_text(ctx->arena, pname, ctx->source);+ if (pn && strcmp(pn, name) == 0) {+ return cbm_node_text(ctx->arena, ptype, ctx->source);+ }+ }+ return NULL;+}++/* `self.x: T = v` / `self.x = p` inside __init__ (self = its first parameter). */+static void py_init_field_assignment(CBMExtractCtx *ctx, const char *class_qn, TSNode assign,+ TSNode params, const char *self_name) {+ TSNode left = ts_node_child_by_field_name(assign, TS_FIELD("left"));+ if (ts_node_is_null(left) || strcmp(ts_node_type(left), "attribute") != 0) {+ return;+ }+ TSNode obj = ts_node_child_by_field_name(left, TS_FIELD("object"));+ TSNode attr = ts_node_child_by_field_name(left, TS_FIELD("attribute"));+ if (ts_node_is_null(obj) || ts_node_is_null(attr) ||+ strcmp(ts_node_type(obj), "identifier") != 0) {+ return;+ }+ char *obj_name = cbm_node_text(ctx->arena, obj, ctx->source);+ if (!obj_name || strcmp(obj_name, self_name) != 0) {+ return;+ }+ TSNode ann = ts_node_child_by_field_name(assign, TS_FIELD("type"));+ if (!ts_node_is_null(ann)) {+ py_push_field_type(ctx, class_qn, attr, cbm_node_text(ctx->arena, ann, ctx->source));+ return;+ }+ TSNode right = ts_node_child_by_field_name(assign, TS_FIELD("right"));+ if (ts_node_is_null(right) || strcmp(ts_node_type(right), "identifier") != 0) {+ return;+ }+ char *rhs = cbm_node_text(ctx->arena, right, ctx->source);+ if (rhs && strcmp(rhs, self_name) != 0) {+ py_push_field_type(ctx, class_qn, attr, py_init_param_annotation(ctx, params, rhs));+ }+}++/* Every `self.x` field assignment in one __init__ body, nested blocks+ * included; nested functions, lambdas and classes have their own `self`. */+static void py_extract_init_fields(CBMExtractCtx *ctx, const char *class_qn, TSNode fn) {+ TSNode params = ts_node_child_by_field_name(fn, TS_FIELD("parameters"));+ TSNode body = ts_node_child_by_field_name(fn, TS_FIELD("body"));+ if (ts_node_is_null(params) || ts_node_is_null(body) ||+ ts_node_named_child_count(params) == 0) {+ return;+ }+ TSNode self_node = ts_node_named_child(params, 0);+ if (strcmp(ts_node_type(self_node), "identifier") != 0) {+ return;+ }+ char *self_name = cbm_node_text(ctx->arena, self_node, ctx->source);+ if (!self_name || !self_name[0]) {+ return;+ }+ TSNodeStack stack;+ ts_nstack_init(&stack, ctx, CBM_SZ_32);+ ts_nstack_push(&stack, body);+ while (stack.count > 0) {+ TSNode n = ts_nstack_pop(&stack);+ const char *k = ts_node_type(n);+ if (strcmp(k, "function_definition") == 0 || strcmp(k, "class_definition") == 0 ||+ strcmp(k, "lambda") == 0) {+ continue;+ }+ TSNode assign = py_statement_assignment(n);+ if (!ts_node_is_null(assign)) {+ py_init_field_assignment(ctx, class_qn, assign, params, self_name);+ continue;+ }+ /* Reverse push keeps source order on pop. */+ for (uint32_t i = ts_node_named_child_count(n); i > 0; i--) {+ ts_nstack_push(&stack, ts_node_named_child(n, i - 1));+ }+ }+}++static void extract_py_field_types(CBMExtractCtx *ctx, TSNode class_node, const char *class_qn) {+ TSNode body = ts_node_child_by_field_name(class_node, TS_FIELD("body"));+ if (ts_node_is_null(body)) {+ return;+ }+ uint32_t count = ts_node_named_child_count(body);+ /* Class-body annotations first: `x: T` / `x: T = v`. */+ for (uint32_t i = 0; i < count; i++) {+ TSNode assign = py_statement_assignment(ts_node_named_child(body, i));+ if (ts_node_is_null(assign)) {+ continue;+ }+ TSNode left = ts_node_child_by_field_name(assign, TS_FIELD("left"));+ TSNode ann = ts_node_child_by_field_name(assign, TS_FIELD("type"));+ if (!ts_node_is_null(left) && !ts_node_is_null(ann) &&+ strcmp(ts_node_type(left), "identifier") == 0) {+ py_push_field_type(ctx, class_qn, left, cbm_node_text(ctx->arena, ann, ctx->source));+ }+ }+ /* Then __init__. */+ for (uint32_t i = 0; i < count; i++) {+ TSNode fn = ts_node_named_child(body, i);+ if (strcmp(ts_node_type(fn), "decorated_definition") == 0) {+ fn = ts_node_child_by_field_name(fn, TS_FIELD("definition"));+ }+ if (ts_node_is_null(fn) || strcmp(ts_node_type(fn), "function_definition") != 0) {+ continue;+ }+ TSNode fname = ts_node_child_by_field_name(fn, TS_FIELD("name"));+ char *fn_name =+ ts_node_is_null(fname) ? NULL : cbm_node_text(ctx->arena, fname, ctx->source);+ if (fn_name && strcmp(fn_name, "__init__") == 0) {+ py_extract_init_fields(ctx, class_qn, fn);+ }+ }+}+static void extract_class_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec) {CBMArena *a = ctx->arena;const char *kind = ts_node_type(node);@@ -4970,6 +5133,10 @@ static void extract_class_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec// Extract class-level variables (field declarations)extract_class_variables(ctx, node, class_qn, spec);+ if (ctx->language == CBM_LANG_PYTHON) {+ extract_py_field_types(ctx, node, class_qn);+ }+// C# 12 primary-constructor parameters: declared on the class line// (`class Foo(IBar bar, IBaz baz) : Base { ... }`) and bound to implicit// captured fields accessible from any instance member. Tree-sitter c-sharpdiff --git a/internal/cbm/lsp/py_lsp.c b/internal/cbm/lsp/py_lsp.cindex 2cf66ad01..70de5dce7 100644--- a/internal/cbm/lsp/py_lsp.c+++ b/internal/cbm/lsp/py_lsp.c@@ -4965,6 +4965,47 @@ static const char **py_split_pipe(CBMArena *arena, const char *text) {return out;}+/* Split a class def's field_defs ("name:QN|name:QN", built by the Python+ * field fold in pass_lsp_cross.c) into the parallel NULL-terminated arrays a+ * CBMRegisteredType carries. The types are already project QNs, so each one+ * becomes a NAMED type verbatim. Without this, `obj.field.method()` on a class+ * from another file lost the field's type (#1277); same-file classes get their+ * fields from the per-file walk instead. Pure string work: no registry lookup+ * happens here, so it is safe inside the type-registration pass. */+static void py_split_field_defs(CBMArena *arena, const char *field_defs, const char ***names_out,+ const CBMType ***types_out) {+ *names_out = NULL;+ *types_out = NULL;+ const char **pairs = py_split_pipe(arena, field_defs);+ if (!pairs)+ return;+ int n = 0;+ while (pairs[n])+ n++;+ const char **names =+ (const char **)cbm_arena_alloc(arena, (size_t)(n + 1) * sizeof(const char *));+ const CBMType **types =+ (const CBMType **)cbm_arena_alloc(arena, (size_t)(n + 1) * sizeof(const CBMType *));+ if (!names || !types)+ return;+ int kept = 0;+ for (int i = 0; i < n; i++) {+ char *colon = strchr(pairs[i], ':');+ if (!colon || colon == pairs[i] || !colon[1])+ continue;+ *colon = '\0'; /* pairs[i] is this call's own arena copy */+ names[kept] = pairs[i];+ types[kept] = cbm_type_named(arena, colon + 1);+ kept++;+ }+ if (kept == 0)+ return;+ names[kept] = NULL;+ types[kept] = NULL;+ *names_out = names;+ *types_out = types;+}+/* Build a registry from CBMLSPDef[] supplied by the caller — covers both* the source file's own defs and cross-file referenced defs. */static void py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeRegistry *reg,@@ -4990,6 +5031,7 @@ static void py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeReif (d->method_names_str && d->method_names_str[0]) {rt.method_names = py_split_pipe(arena, d->method_names_str);}+ py_split_field_defs(arena, d->field_defs, &rt.field_names, &rt.field_types);cbm_registry_add_type(reg, rt);}}diff --git a/internal/cbm/result_compact.c b/internal/cbm/result_compact.cindex 90c8c6d82..82f661d05 100644--- a/internal/cbm/result_compact.c+++ b/internal/cbm/result_compact.c@@ -377,6 +377,12 @@ static void cr_walk(cr_ctx_t *c, CBMFileResult *r) {cr_str(c, &r->channels.items[i].transport);cr_str(c, &r->channels.items[i].enclosing_func_qn);}+ cr_array(c, (void **)&r->field_types.items, r->field_types.count, sizeof(CBMFieldType));+ for (int i = 0; i < r->field_types.count && r->field_types.items; i++) {+ cr_str(c, &r->field_types.items[i].class_qn);+ cr_str(c, &r->field_types.items[i].field_name);+ cr_str(c, &r->field_types.items[i].type_text);+ }cr_str(c, &r->module_qn);cr_str(c, &r->namespace_name);cr_list(c, &r->exports);@@ -523,6 +529,7 @@ void cbm_result_compact(CBMFileResult *result) {tmp.string_refs.cap = tmp.string_refs.count;tmp.infra_bindings.cap = tmp.infra_bindings.count;tmp.channels.cap = tmp.channels.count;+ tmp.field_types.cap = tmp.field_types.count;/* A composite kept its per-unit results only so shallow-copied strings* stayed valid; every string is now a copy of its own. */diff --git a/src/pipeline/pass_lsp_cross.c b/src/pipeline/pass_lsp_cross.cindex 3b74cc1eb..66751a682 100644--- a/src/pipeline/pass_lsp_cross.c+++ b/src/pipeline/pass_lsp_cross.c@@ -529,6 +529,132 @@ static void pxc_fold_go_struct_fields(CBMArena *arena, const CBMFileResult *resu}}+/* Python annotation text -> the one type name it declares, or NULL. Strips a+ * string-literal forward reference and unwraps `Optional[X]`, `X | None` and+ * `None | X`; anything else with brackets, commas or a real union (generics,+ * Callable, Union[A, B]) names no single receiver type and is dropped. */+static const char *pxc_py_annotation_type_name(CBMArena *arena, const char *text) {+ if (!text) {+ return NULL;+ }+ while (*text == ' ') {+ text++;+ }+ size_t n = strlen(text);+ while (n > 0 && text[n - 1] == ' ') {+ n--;+ }+ if (n >= 2 && (text[0] == '"' || text[0] == '\'') && text[n - 1] == text[0]) {+ text++;+ n -= 2;+ }+ static const char *const optional_prefixes[] = {"Optional[", "typing.Optional["};+ for (size_t i = 0; i < sizeof(optional_prefixes) / sizeof(optional_prefixes[0]); i++) {+ size_t plen = strlen(optional_prefixes[i]);+ if (n > plen + 1 && strncmp(text, optional_prefixes[i], plen) == 0 && text[n - 1] == ']') {+ text += plen;+ n -= plen + 1;+ break;+ }+ }+ static const char none_tail[] = " | None";+ static const char none_head[] = "None | ";+ const size_t none_len = sizeof(none_tail) - 1;+ if (n > none_len && strncmp(text + n - none_len, none_tail, none_len) == 0) {+ n -= none_len;+ } else if (n > none_len && strncmp(text, none_head, none_len) == 0) {+ text += none_len;+ n -= none_len;+ }+ if (n == 0) {+ return NULL;+ }+ for (size_t i = 0; i < n; i++) {+ char c = text[i];+ bool ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||+ c == '_' || c == '.';+ if (!ok) {+ return NULL;+ }+ }+ return cbm_arena_strndup(arena, text, n);+}++/* Python: fold the file's annotated instance fields (result->field_types,+ * #1277) into their class defs' field_defs as "name:QN|name:QN", the format+ * py_register_lsp_defs reads. Each annotation resolves through the same+ * registry + import map, and the same weak-strategy and type-like vetoes, as+ * the file's base classes (pxc_resolve_base_qn): a field whose type is not a+ * confidently-known project type is left out rather than guessed. Linear in+ * the file: one hash of the file's class defs, one pass over its fields. */+typedef struct {+ int owner; /* index into defs[], or -1 */+ const char *type_qn;+} pxc_py_field_t;++static void pxc_fold_py_field_types(CBMArena *arena, const CBMFileResult *result, CBMLSPDef *defs,+ int start, int end, const cbm_registry_t *reg,+ const char *module_qn, const char **imp_keys,+ const char **imp_vals, int imp_count) {+ int nf = result ? result->field_types.count : 0;+ if (!arena || nf == 0 || !defs || start >= end || !reg) {+ return;+ }+ CBMHashTable *by_qn = cbm_ht_create((uint32_t)(end - start));+ pxc_py_field_t *fields = (pxc_py_field_t *)cbm_arena_alloc(arena, (size_t)nf * sizeof(*fields));+ /* Per class def: exact buffer size, then the write cursor into it. */+ size_t *lens = (size_t *)cbm_arena_alloc(arena, (size_t)(end - start) * sizeof(size_t));+ size_t *used = (size_t *)cbm_arena_alloc(arena, (size_t)(end - start) * sizeof(size_t));+ if (!by_qn || !fields || !lens || !used) {+ cbm_ht_free(by_qn); /* NULL-safe */+ return;+ }+ memset(lens, 0, (size_t)(end - start) * sizeof(size_t));+ memset(used, 0, (size_t)(end - start) * sizeof(size_t));+ for (int si = start; si < end; si++) {+ if (defs[si].label && strcmp(defs[si].label, "Class") == 0 && defs[si].qualified_name) {+ cbm_ht_set(by_qn, defs[si].qualified_name, &defs[si]);+ }+ }+ for (int f = 0; f < nf; f++) {+ const CBMFieldType *ft = &result->field_types.items[f];+ fields[f].owner = -1;+ fields[f].type_qn = NULL;+ CBMLSPDef *owner = ft->class_qn ? (CBMLSPDef *)cbm_ht_get(by_qn, ft->class_qn) : NULL;+ const char *name = owner ? pxc_py_annotation_type_name(arena, ft->type_text) : NULL;+ const char *qn =+ name ? pxc_resolve_base_qn(reg, name, module_qn, imp_keys, imp_vals, imp_count) : NULL;+ if (!qn || !ft->field_name || !ft->field_name[0]) {+ continue;+ }+ fields[f].owner = (int)(owner - defs);+ fields[f].type_qn = qn;+ /* "name:QN" plus one byte for the '|' or the NUL after it. */+ lens[fields[f].owner - start] += strlen(ft->field_name) + 1 + strlen(qn) + 1;+ }+ cbm_ht_free(by_qn);+ for (int si = start; si < end; si++) {+ char *buf = lens[si - start] ? (char *)cbm_arena_alloc(arena, lens[si - start]) : NULL;+ if (buf) {+ buf[0] = '\0';+ }+ defs[si].field_defs = buf;+ }+ for (int f = 0; f < nf; f++) {+ char *buf = fields[f].owner >= 0 ? (char *)defs[fields[f].owner].field_defs : NULL;+ if (!buf) {+ continue;+ }+ int slot = fields[f].owner - start;+ int wrote =+ snprintf(buf + used[slot], lens[slot] - used[slot], "%s%s:%s", used[slot] ? "|" : "",+ result->field_types.items[f].field_name, fields[f].type_qn);+ if (wrote > 0) {+ used[slot] += (size_t)wrote;+ }+ }+}+/* Carry one Rust type-level impl independently of any method definition.* `impl Trait for Type {}` is semantically meaningful even when the block is* empty (the trait may provide defaults), so attaching the relation only to@@ -634,6 +760,10 @@ CBMLSPDef *cbm_pxc_collect_all_defs(const cbm_pipeline_ctx_t *ctx, CBMArena *areidx++;}}+ if (files[fi].language == CBM_LANG_PYTHON) {+ pxc_fold_py_field_types(arena, fr, defs, file_start, idx, base_reg, def_modules[fi],+ imp_keys, imp_vals, imp_count);+ }cbm_pxc_free_import_map(imp_keys, imp_vals, imp_count); /* NULL-safe */if (files[fi].language == CBM_LANG_GO) {pxc_fold_go_struct_fields(arena, fr, defs, file_start, idx);diff --git a/src/pipeline/pipeline.c b/src/pipeline/pipeline.cindex ba41b877c..32f9df6a5 100644--- a/src/pipeline/pipeline.c+++ b/src/pipeline/pipeline.c@@ -1156,7 +1156,8 @@ static void log_result_census(const char *tag, CBMFileResult **cache, int file_c(size_t)r->string_refs.count * sizeof(CBMStringRef) +(size_t)r->impl_traits.count * sizeof(CBMImplTrait) +(size_t)r->infra_bindings.count * sizeof(CBMInfraBinding) +- (size_t)r->channels.count * sizeof(CBMChannel);+ (size_t)r->channels.count * sizeof(CBMChannel) ++ (size_t)r->field_types.count * sizeof(CBMFieldType);cap_other += (size_t)r->imports.cap * sizeof(CBMImport) +(size_t)r->resolved_calls.cap * sizeof(CBMResolvedCall) +(size_t)r->throws.cap * sizeof(CBMThrow) +@@ -1165,7 +1166,8 @@ static void log_result_census(const char *tag, CBMFileResult **cache, int file_c(size_t)r->string_refs.cap * sizeof(CBMStringRef) +(size_t)r->impl_traits.cap * sizeof(CBMImplTrait) +(size_t)r->infra_bindings.cap * sizeof(CBMInfraBinding) +- (size_t)r->channels.cap * sizeof(CBMChannel);+ (size_t)r->channels.cap * sizeof(CBMChannel) ++ (size_t)r->field_types.cap * sizeof(CBMFieldType);n_defs += (size_t)r->defs.count;n_calls += (size_t)r->calls.count;n_usages += (size_t)r->usages.count;diff --git a/tests/test_extraction.c b/tests/test_extraction.cindex 0b6800cd1..4980426a9 100644--- a/tests/test_extraction.c+++ b/tests/test_extraction.c@@ -1182,6 +1182,62 @@ TEST(cpp_method_return_type_preserves_pointer_and_qualifier) {* ═══════════════════════════════════════════════════════════════════ *//* --- Python --- */+/* #1277: annotated Python instance fields reach result->field_types (the+ * cross-file LSP's only source for them); nothing unannotated is guessed and+ * no graph def is minted for a field. */+static const char *py_field_type_of(const CBMFileResult *r, const char *cls_suffix,+ const char *field) {+ for (int i = 0; i < r->field_types.count; i++) {+ const CBMFieldType *ft = &r->field_types.items[i];+ size_t cl = strlen(ft->class_qn);+ size_t sl = strlen(cls_suffix);+ if (cl >= sl && strcmp(ft->class_qn + cl - sl, cls_suffix) == 0 &&+ strcmp(ft->field_name, field) == 0) {+ return ft->type_text;+ }+ }+ return NULL;+}++TEST(python_annotated_instance_fields_exported_issue1277) {+ const char *src = "class Trainer(Base):\n"+ " engine: Contract\n"+ " limit: int = 3\n"+ " plain = 5\n\n"+ " def __init__(self, strategies: Contract, n, opt: 'Other' = None):\n"+ " self.strategies = strategies\n"+ " self.typed: Contract = strategies\n"+ " self.count = n\n"+ " self.made = make()\n"+ " self.opt = opt\n"+ " if n:\n"+ " self.nested: Nested = n\n"+ " def inner(other: Inner):\n"+ " self.hidden = other\n\n"+ " def later(self, x: Later):\n"+ " self.late = x\n";+ CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "trainer.py");+ ASSERT_NOT_NULL(r);+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "engine"), "Contract");+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "limit"), "int");+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "strategies"), "Contract");+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "typed"), "Contract");+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "opt"), "'Other'");+ ASSERT_STR_EQ(py_field_type_of(r, ".Trainer", "nested"), "Nested");+ /* Controls: no declared type, a nested function's binding, a non-__init__ method. */+ ASSERT_NULL(py_field_type_of(r, ".Trainer", "plain"));+ ASSERT_NULL(py_field_type_of(r, ".Trainer", "count"));+ ASSERT_NULL(py_field_type_of(r, ".Trainer", "made"));+ ASSERT_NULL(py_field_type_of(r, ".Trainer", "hidden"));+ ASSERT_NULL(py_field_type_of(r, ".Trainer", "late"));+ ASSERT_EQ(r->field_types.count, 6);+ for (int i = 0; i < r->defs.count; i++) {+ ASSERT_FALSE(r->defs.items[i].label && strcmp(r->defs.items[i].label, "Field") == 0);+ }+ cbm_free_result(r);+ PASS();+}+TEST(python_function) {CBMFileResult *r = extract("def greet(name):\n return f\"Hello {name}\"\n\ndef main():\n greet(\"World\")\n",@@ -8991,6 +9047,7 @@ SUITE(extraction) {/* Scripting */RUN_TEST(python_function);RUN_TEST(python_class);+ RUN_TEST(python_annotated_instance_fields_exported_issue1277);RUN_TEST(js_function);RUN_TEST(js_class);RUN_TEST(ts_function);diff --git a/tests/test_pipeline.c b/tests/test_pipeline.cindex 56be6b88e..b0ebc9f5a 100644--- a/tests/test_pipeline.c+++ b/tests/test_pipeline.c@@ -8166,6 +8166,98 @@ static void teardown_usages_repo(void) {g_usages_tmpdir[0] = '\0';}+/* #1277: typed instance fields of a Python class imported from another file.+ * Counts CALLS edges caller -> callee (QN suffixes) whose properties name an+ * LSP strategy. */+static int count_lsp_calls(cbm_store_t *s, const char *project, const char *caller_suffix,+ const char *callee_suffix) {+ cbm_edge_t *edges = NULL;+ int edge_count = 0;+ cbm_store_find_edges_by_type(s, project, "CALLS", &edges, &edge_count);+ int hits = 0;+ for (int i = 0; i < edge_count; i++) {+ cbm_node_t src = {0};+ cbm_node_t tgt = {0};+ if (cbm_store_find_node_by_id(s, edges[i].source_id, &src) == CBM_STORE_OK &&+ cbm_store_find_node_by_id(s, edges[i].target_id, &tgt) == CBM_STORE_OK) {+ size_t sl = strlen(src.qualified_name);+ size_t tl = strlen(tgt.qualified_name);+ size_t cs = strlen(caller_suffix);+ size_t ts = strlen(callee_suffix);+ if (sl >= cs && tl >= ts && strcmp(src.qualified_name + sl - cs, caller_suffix) == 0 &&+ strcmp(tgt.qualified_name + tl - ts, callee_suffix) == 0 &&+ edges[i].properties_json && strstr(edges[i].properties_json, "lsp")) {+ hits++;+ }+ }+ cbm_node_free_fields(&src);+ cbm_node_free_fields(&tgt);+ }+ if (edges)+ cbm_store_free_edges(edges, edge_count);+ return hits;+}++TEST(python_crossfile_typed_field_calls_issue1277) {+ const char *contracts = "class Contract:\n"+ " def process_batch(self) -> None:\n"+ " ...\n";+ const char *trainer = "from contracts import Contract\n\n"+ "def make():\n"+ " return None\n\n"+ "class Trainer:\n"+ " engine: Contract\n\n"+ " def __init__(self, strategies: Contract) -> None:\n"+ " self.strategies = strategies\n"+ " self.typed: Contract = strategies\n"+ " self.plain = make()\n";+ const char *loop = "from trainer import Trainer\n\n"+ "def run(trainer: Trainer) -> None:\n"+ " strategies = trainer.strategies\n"+ " strategies.process_batch()\n\n"+ "def run_typed(trainer: Trainer) -> None:\n"+ " trainer.typed.process_batch()\n\n"+ "def run_classlevel(trainer: Trainer) -> None:\n"+ " trainer.engine.process_batch()\n\n"+ "def run_untyped(trainer: Trainer) -> None:\n"+ " trainer.plain.process_batch()\n";+ if (setup_usages_repo("contracts.py", contracts, "trainer.py", trainer) != 0) {+ FAIL("failed to create temp dir");+ }+ char path[512];+ snprintf(path, sizeof(path), "%s/loop.py", g_usages_tmpdir);+ FILE *f = fopen(path, "w");+ ASSERT_NOT_NULL(f);+ fputs(loop, f);+ fclose(f);++ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/test_1277.db", g_usages_tmpdir);+ cbm_pipeline_t *p = cbm_pipeline_new(g_usages_tmpdir, db_path, CBM_MODE_FULL);+ ASSERT_NOT_NULL(p);+ ASSERT_EQ(cbm_pipeline_run(p), 0);+ cbm_store_t *s = cbm_store_open_path(db_path);+ ASSERT_NOT_NULL(s);+ const char *project = cbm_pipeline_project_name(p);++ int via_alias = count_lsp_calls(s, project, "loop.run", "contracts.Contract.process_batch");+ int via_typed =+ count_lsp_calls(s, project, "loop.run_typed", "contracts.Contract.process_batch");+ int via_class =+ count_lsp_calls(s, project, "loop.run_classlevel", "contracts.Contract.process_batch");+ int via_untyped = count_lsp_calls(s, project, "loop.run_untyped", "process_batch");++ cbm_store_close(s);+ cbm_pipeline_free(p);+ teardown_usages_repo();++ ASSERT_EQ(via_alias, 1); /* self.x = <annotated __init__ parameter> */+ ASSERT_EQ(via_typed, 1); /* self.x: T = ... */+ ASSERT_EQ(via_class, 1); /* class-level x: T */+ ASSERT_EQ(via_untyped, 0); /* control: no annotation, no guess */+ PASS();+}+TEST(usages_creates_edges) {/* Port of TestPassUsagesCreatesEdges.* Go source with callback reference → USAGE edge. */@@ -16378,6 +16470,7 @@ SUITE(pipeline) {RUN_TEST(implements_creates_override);RUN_TEST(implements_no_match);/* Usages pass (full pipeline integration) */+ RUN_TEST(python_crossfile_typed_field_calls_issue1277);RUN_TEST(usages_creates_edges);RUN_TEST(usages_no_duplicate_calls);RUN_TEST(calls_edge_carries_call_site_line);diff --git a/tests/test_py_lsp.c b/tests/test_py_lsp.cindex 3aaadee51..d65341900 100644--- a/tests/test_py_lsp.c+++ b/tests/test_py_lsp.c@@ -580,6 +580,119 @@ TEST(pylsp_crossfile_method_dispatch) {PASS();}+/* Issue #1277 (reproducer contributed by @Enferlain): a method call through a+ * typed instance field of a class imported from ANOTHER file. The field type+ * reaches the resolver only through CBMLSPDef.field_defs on the class def. */+TEST(pylsp_crossfile_receiver_through_typed_field) {+ const char *source = "from trainer import Trainer\n"+ "def run(trainer: Trainer):\n"+ " strategies = trainer.strategies\n"+ " return strategies.process_batch()\n";++ CBMLSPDef defs[3];+ memset(defs, 0, sizeof(defs));++ defs[0].qualified_name = "contracts.Contract";+ defs[0].short_name = "Contract";+ defs[0].label = "Class";+ defs[0].def_module_qn = "contracts";++ defs[1].qualified_name = "contracts.Contract.process_batch";+ defs[1].short_name = "process_batch";+ defs[1].label = "Method";+ defs[1].receiver_type = "contracts.Contract";+ defs[1].def_module_qn = "contracts";++ defs[2].qualified_name = "trainer.Trainer";+ defs[2].short_name = "Trainer";+ defs[2].label = "Class";+ defs[2].def_module_qn = "trainer";+ defs[2].field_defs = "strategies:contracts.Contract";++ const char *imp_names[] = {"Trainer"};+ const char *imp_qns[] = {"trainer.Trainer"};++ CBMArena arena;+ cbm_arena_init(&arena);+ CBMResolvedCallArray out = {0};++ cbm_run_py_lsp_cross(&arena, source, (int)strlen(source), "test.loop", defs, 3, imp_names,+ imp_qns, 1, NULL, &out, NULL);++ ASSERT_GTE(find_resolved_arr(&out, "run", "process_batch"), 0);+ cbm_arena_destroy(&arena);+ PASS();+}++/* #1277 on the production path: the sealed shared Tier-2 registry. Covers the+ * direct chain, the local alias, a field inherited from a base class, and two+ * controls: an undeclared field and a field whose type has no such method+ * must stay unresolved (never guessed). */+TEST(pylsp_crossfile_typed_field_shared_registry) {+ CBMArena arena;+ cbm_arena_init(&arena);++ CBMLSPDef defs[5];+ memset(defs, 0, sizeof(defs));+ defs[0].qualified_name = "contracts.Contract";+ defs[0].short_name = "Contract";+ defs[0].label = "Class";+ defs[0].def_module_qn = "contracts";+ defs[1].qualified_name = "contracts.Contract.process_batch";+ defs[1].short_name = "process_batch";+ defs[1].label = "Method";+ defs[1].receiver_type = "contracts.Contract";+ defs[1].def_module_qn = "contracts";+ defs[2].qualified_name = "trainer.Trainer";+ defs[2].short_name = "Trainer";+ defs[2].label = "Class";+ defs[2].def_module_qn = "trainer";+ defs[2].field_defs = "strategies:contracts.Contract|name:builtins.str";+ defs[3].qualified_name = "trainer.SubTrainer";+ defs[3].short_name = "SubTrainer";+ defs[3].label = "Class";+ defs[3].def_module_qn = "trainer";+ defs[3].embedded_types = "trainer.Trainer";+ defs[4].qualified_name = "trainer.Other";+ defs[4].short_name = "Other";+ defs[4].label = "Class";+ defs[4].def_module_qn = "trainer";+ for (int i = 0; i < 5; i++) {+ defs[i].lang = CBM_LANG_PYTHON;+ }++ CBMTypeRegistry *reg = cbm_py_build_cross_registry(&arena, defs, 5);+ ASSERT_NOT_NULL(reg);+ ASSERT_TRUE(reg->read_only);++ const char *src = "from trainer import Trainer, SubTrainer, Other\n"+ "def direct(t: Trainer):\n"+ " return t.strategies.process_batch()\n"+ "def alias(t: Trainer):\n"+ " s = t.strategies\n"+ " return s.process_batch()\n"+ "def inherited(t: SubTrainer):\n"+ " return t.strategies.process_batch()\n"+ "def undeclared(t: Other):\n"+ " return t.strategies.process_batch()\n"+ "def wrong_type(t: Trainer):\n"+ " return t.name.process_batch()\n";+ const char *imp_names[] = {"Trainer", "SubTrainer", "Other"};+ const char *imp_qns[] = {"trainer.Trainer", "trainer.SubTrainer", "trainer.Other"};+ CBMResolvedCallArray out = {0};+ cbm_run_py_lsp_cross_with_registry(&arena, src, (int)strlen(src), "test.loop", reg, imp_names,+ imp_qns, 3, NULL, &out, NULL);++ ASSERT_GTE(find_resolved_arr(&out, "direct", "Contract.process_batch"), 0);+ ASSERT_GTE(find_resolved_arr(&out, "alias", "Contract.process_batch"), 0);+ ASSERT_GTE(find_resolved_arr(&out, "inherited", "Contract.process_batch"), 0);+ ASSERT_EQ(find_resolved_arr(&out, "undeclared", "process_batch"), -1);+ ASSERT_EQ(find_resolved_arr(&out, "wrong_type", "process_batch"), -1);++ cbm_arena_destroy(&arena);+ PASS();+}+/* Graph-quality guard for the Python seal fix (per-file field overlay). In the* FUSED path the shared Tier-2 registry is read_only, so `self.b = Bar()` can no* longer be recorded by mutating the shared registry; it is recorded in the per-file@@ -2193,6 +2306,8 @@ SUITE(py_lsp) {RUN_TEST(pylsp_pep695_generic_class);/* Phase 9 — cross-file + batch */RUN_TEST(pylsp_crossfile_method_dispatch);+ RUN_TEST(pylsp_crossfile_receiver_through_typed_field);+ RUN_TEST(pylsp_crossfile_typed_field_shared_registry);RUN_TEST(pylsp_fused_self_attr_chain_via_overlay);RUN_TEST(pylsp_crossfile_classmethod_on_class_issue228);RUN_TEST(pylsp_crossfile_inheritance);