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(extraction): attribute Swift lifecycle calls
Andrew Studnickyf200d7477f19
diff --git a/internal/cbm/extract_defs.c b/internal/cbm/extract_defs.cindex 916f1136f..9db81506c 100644--- a/internal/cbm/extract_defs.c+++ b/internal/cbm/extract_defs.c@@ -210,6 +210,11 @@ static void extract_elixir_call(CBMExtractCtx *ctx, TSNode node, const CBMLangSp// Get "name" field from a nodestatic TSNode func_name_node(TSNode node) {+ const char *node_type = ts_node_type(node);+ if (strcmp(node_type, "init_declaration") == 0 ||+ strcmp(node_type, "deinit_declaration") == 0) {+ return node;+ }TSNode name = ts_node_child_by_field_name(node, TS_FIELD("name"));if (ts_node_is_null(name)) {/* Protobuf rpc: name is in rpc_name child, not "name" field */diff --git a/internal/cbm/helpers.c b/internal/cbm/helpers.cindex 50c75bdf2..1a51dc971 100644--- a/internal/cbm/helpers.c+++ b/internal/cbm/helpers.c@@ -959,6 +959,16 @@ TSNode cbm_resolve_c_declarator_name_node(TSNode func_node) {// const", and a member lookup for "operator bool" (the implicit call in// `if (obj)`) misses.char *cbm_func_name_node_text(CBMArena *a, TSNode name_node, const char *source, CBMLanguage lang) {+ if (lang == CBM_LANG_SWIFT) {+ const char *kind = ts_node_type(name_node);+ if (strcmp(kind, "init_declaration") == 0) {+ return cbm_arena_strdup(a, "init");+ }+ if (strcmp(kind, "deinit_declaration") == 0) {+ return cbm_arena_strdup(a, "deinit");+ }+ }+char *text = cbm_node_text(a, name_node, source);if (text && strcmp(ts_node_type(name_node), "operator_cast") == 0) {char *paren = strchr(text, '(');diff --git a/internal/cbm/lang_specs.c b/internal/cbm/lang_specs.cindex 3a5fad0d4..8b29c9005 100644--- a/internal/cbm/lang_specs.c+++ b/internal/cbm/lang_specs.c@@ -571,7 +571,8 @@ static const char *objc_assign_types[] = {"assignment_expression", NULL};// well as in the name resolvers — extract_class_methods gates on this set, so// without the entry the requirement is walked and then discarded.static const char *swift_func_types[] = {"function_declaration", "protocol_function_declaration",- "macro_declaration", NULL};+ "macro_declaration", "init_declaration",+ "deinit_declaration", NULL};// KNOWN GAP: struct_declaration and enum_declaration are not node types in the// vendored tree-sitter-swift grammar — it models both as class_declaration — so// these two entries never match anything, and a bare Swift `enum` is labeleddiff --git a/tests/test_extraction.c b/tests/test_extraction.cindex 1e6506ed1..80cbd59e5 100644--- a/tests/test_extraction.c+++ b/tests/test_extraction.c@@ -69,6 +69,30 @@ static int has_def_qn(CBMFileResult *r, const char *qn) {return 0;}+/* Return the definition with the given qualified name, or NULL. Distinct from+ * find_def_by_name for the same reason has_def_qn is distinct from has_def. */+/* Find a definition by its qualified name relative to the file's module QN+ * (e.g. "Box.init" resolves to "<module_qn>.Box.init"). */+static const CBMDefinition *find_def_in_module(CBMFileResult *r, const char *rel_qn) {+ char qn[512];+ snprintf(qn, sizeof(qn), "%s.%s", r->module_qn, rel_qn);+ for (int i = 0; i < r->defs.count; i++) {+ if (r->defs.items[i].qualified_name && strcmp(r->defs.items[i].qualified_name, qn) == 0)+ return &r->defs.items[i];+ }+ return NULL;+}++/* Find an in-body call by its raw callee text; returns the call or NULL. */+static const CBMCall *find_call_by_callee(CBMFileResult *r, const char *callee) {+ for (int i = 0; i < r->calls.count; i++) {+ if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0) {+ return &r->calls.items[i];+ }+ }+ return NULL;+}+static int count_defs_with_label(CBMFileResult *r, const char *label) {int count = 0;for (int i = 0; i < r->defs.count; i++) {@@ -2004,6 +2028,247 @@ TEST(swift_force_unwrap_scanner_shift) {PASS();}+/* #2379: a struct's plain `init` is a callable, not a name-less hole -- a call+ * inside it must source from the initializer, not fall back to the file's+ * Module scope. */+TEST(swift_init_struct_issue2379) {+ CBMFileResult *r = extract("func helper() -> Int { 1 }\n"+ "struct Box {\n"+ " let value: Int\n"+ " init() {\n"+ " value = helper()\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Box.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Box.init");+ ASSERT_NOT_NULL(init_def);+ ASSERT_STR_EQ(init_def->label, "Method");+ ASSERT_STR_EQ(init_def->name, "init");++ const CBMCall *call = find_call_by_callee(r, "helper");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}++/* #2379: a class's designated init takes parameters -- coverage that a+ * parameterized init is extracted the same way as a bare one. */+TEST(swift_init_class_designated_issue2379) {+ CBMFileResult *r = extract("func helper() -> Int { 1 }\n"+ "final class Holder {\n"+ " let value: Int\n"+ " init(seed: Int) {\n"+ " value = helper() + seed\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Holder.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");+ ASSERT_NOT_NULL(init_def);+ ASSERT_STR_EQ(init_def->label, "Method");++ const CBMCall *call = find_call_by_callee(r, "helper");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}++/* #2379: a convenience init delegates via `self.init(...)`. Its call to+ * `other()` (an argument of the delegating call) must source from the+ * initializer, not from the file. */+TEST(swift_init_convenience_delegates_issue2379) {+ CBMFileResult *r = extract("func other() -> Int { 2 }\n"+ "final class Holder {\n"+ " let value: Int\n"+ " init(seed: Int) {\n"+ " value = seed\n"+ " }\n"+ " convenience init() {\n"+ " self.init(seed: other())\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Holder.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");+ ASSERT_NOT_NULL(init_def);++ /* self.init(...) is a plain member call today, same as any other+ * `receiver.member(...)` invocation -- no dedicated delegation handling. */+ ASSERT(has_call(r, "self.init"));++ const CBMCall *call = find_call_by_callee(r, "other");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}++/* #2379: two initializers in the same type calling the SAME callee must both+ * attribute to the type's init, not to the file's Module scope. Both share+ * the QN `Holder.init` -- codebase-memory-mcp already collapses overloaded+ * Swift methods onto one node (DeusData/codebase-memory-mcp#2061), and an+ * init is no exception; distinguishing overloads by signature is that+ * issue's concern, not this one's. */+TEST(swift_init_multiple_not_collapsed_issue2379) {+ CBMFileResult *r = extract("func shared() -> Int { 3 }\n"+ "final class Holder {\n"+ " let value: Int\n"+ " init(seed: Int) {\n"+ " value = shared()\n"+ " }\n"+ " convenience init() {\n"+ " self.init(seed: shared())\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Holder.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Holder.init");+ ASSERT_NOT_NULL(init_def);++ int from_init = 0;+ for (int i = 0; i < r->calls.count; i++) {+ const CBMCall *c = &r->calls.items[i];+ if (!c->callee_name || strcmp(c->callee_name, "shared") != 0 || !c->enclosing_func_qn) {+ continue;+ }+ ASSERT_STR_EQ(c->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(c->enclosing_func_qn, r->module_qn);+ from_init++;+ }+ ASSERT_EQ(from_init, 2);++ cbm_free_result(r);+ PASS();+}++/* #2379: a failable `init?` in an enum is still a callable initializer. */+TEST(swift_init_failable_enum_issue2379) {+ CBMFileResult *r = extract("func helper() -> Int { 1 }\n"+ "enum Mode {\n"+ " case on\n"+ " init?(flag: Bool) {\n"+ " if helper() > 0 { self = .on } else { return nil }\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Mode.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Mode.init");+ ASSERT_NOT_NULL(init_def);++ const CBMCall *call = find_call_by_callee(r, "helper");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}++/* #2379: `extension X { }` is modeled by the vendored grammar as a+ * class_declaration named X, so an init declared in an extension goes through+ * the same class-method path as one declared in the primary type. */+TEST(swift_init_extension_issue2379) {+ CBMFileResult *r = extract("func other() -> Int { 2 }\n"+ "extension Box {\n"+ " init(raw: Int) {\n"+ " value = other()\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Box+Raw.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *init_def = find_def_in_module(r, "Box.init");+ ASSERT_NOT_NULL(init_def);++ const CBMCall *call = find_call_by_callee(r, "other");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, init_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}++/* #2379: regression guard -- an ordinary method in the same type keeps its own+ * attribution unchanged (this already worked pre-fix; the initializer fix+ * must not disturb it). */+TEST(swift_method_still_attributed_issue2379) {+ CBMFileResult *r = extract("func other() -> Int { 2 }\n"+ "struct Box {\n"+ " init() {}\n"+ " func read() -> Int {\n"+ " other()\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Box.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *read_def = find_def_in_module(r, "Box.read");+ ASSERT_NOT_NULL(read_def);++ const CBMCall *call = find_call_by_callee(r, "other");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, read_def->qualified_name);++ cbm_free_result(r);+ PASS();+}++/* #2379: a `deinit` has the same gap as `init` -- no source-level name, so a+ * call inside its body attributed to the file's Module scope instead of the+ * type. */+TEST(swift_deinit_issue2379) {+ CBMFileResult *r = extract("func helper() -> Int { 1 }\n"+ "final class Deinitable {\n"+ " deinit {\n"+ " _ = helper()\n"+ " }\n"+ "}\n",+ CBM_LANG_SWIFT, "t", "Deinitable.swift");+ ASSERT_NOT_NULL(r);+ ASSERT_FALSE(r->has_error);++ const CBMDefinition *deinit_def = find_def_in_module(r, "Deinitable.deinit");+ ASSERT_NOT_NULL(deinit_def);+ ASSERT_STR_EQ(deinit_def->name, "deinit");++ const CBMCall *call = find_call_by_callee(r, "helper");+ ASSERT_NOT_NULL(call);+ ASSERT_NOT_NULL(call->enclosing_func_qn);+ ASSERT_STR_EQ(call->enclosing_func_qn, deinit_def->qualified_name);+ ASSERT_STR_NEQ(call->enclosing_func_qn, r->module_qn);++ cbm_free_result(r);+ PASS();+}+/* --- Objective-C --- */TEST(objc_interface) {CBMFileResult *r =@@ -4528,16 +4793,6 @@ TEST(extract_ts_decorators_survive_interleaved_comment) {PASS();}-/* Find an in-body call by its raw callee text; returns the call or NULL. */-static const CBMCall *find_call_by_callee(CBMFileResult *r, const char *callee) {- for (int i = 0; i < r->calls.count; i++) {- if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0) {- return &r->calls.items[i];- }- }- return NULL;-}-/* #1892: the Swift grammar declares no "arguments" field, so the generic field* lookup read nothing and every Swift call lost its arguments. Without the URL* the service-pattern table cannot raise an HTTP_CALLS edge or a Route node,@@ -8442,6 +8697,14 @@ SUITE(extraction) {RUN_TEST(swift_constructor_call);RUN_TEST(swift_chained_call);RUN_TEST(swift_force_unwrap_scanner_shift);+ RUN_TEST(swift_init_struct_issue2379);+ RUN_TEST(swift_init_class_designated_issue2379);+ RUN_TEST(swift_init_convenience_delegates_issue2379);+ RUN_TEST(swift_init_multiple_not_collapsed_issue2379);+ RUN_TEST(swift_init_failable_enum_issue2379);+ RUN_TEST(swift_init_extension_issue2379);+ RUN_TEST(swift_method_still_attributed_issue2379);+ RUN_TEST(swift_deinit_issue2379);RUN_TEST(swift_call_string_arg_issue1892);RUN_TEST(swift_nested_url_constructor_issue1892);RUN_TEST(swift_nested_url_no_bang_issue1892);