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(extraction): attribute Swift lifecycle calls

Andrew Studnickyf200d7477f19
diff --git a/internal/cbm/extract_defs.c b/internal/cbm/extract_defs.c
index 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 node
static 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.c
index 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.c
index 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 labeled
diff --git a/tests/test_extraction.c b/tests/test_extraction.c
index 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);