Break-glass merge PR #2630

Author: DeusData

internal/cbm/cbm.h

@@ -304,6 +304,15 @@ typedef struct {
      * values are escaped where the properties are written. Tail field:
      * zero-init stays valid. */
     const char **extra_props;
+    /* C-family platform variants (helpers.h cbm_platform_neutral_qn): the
+     * platform-neutral QN of a non-static file-scope function whose path
+     * carries a platform token (foo_win.c, src/unix/fs.c). The definition
+     * keeps its own path QN; this becomes the node's `variant_key` property,
+     * and the nodes of a project sharing one key are the platform variants of
+     * one function (the test-impact walk treats a change in any of them as a
+     * change of all, store_impact.h follow_variant_keys). NULL on every other
+     * definition. Tail field: zero-init stays valid. */
+    const char *variant_key;
 } CBMDefinition;
 
 /* Argument captured from a call expression */

internal/cbm/extract_defs.c

@@ -6609,14 +6609,6 @@ static void extract_func_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec
      * proj.myapp.db.Func, not proj.myapp.db.conn.Func). Other langs unchanged. */
     def.qualified_name =
         cbm_fqn_compute_source_lang(a, ctx->project, ctx->rel_path, qn_name, ctx->language);
-    /* C-family platform variants (foo_win.c / foo_posix.c, src/unix/ vs
-     * src/win/): an external-linkage file-scope function takes its
-     * platform-neutral QN, so its variants are one definition. The call-scope
-     * twin in extract_unified.c applies the same rule. */
-    if (!ctx->enclosing_class_qn) {
-        def.qualified_name = cbm_platform_variant_qn(a, ctx->language, ctx->project, ctx->rel_path,
-                                                     qn_name, def.qualified_name, node);
-    }
     /* A free function declared inside a namespace (C++/C#/PHP) is qualified by
      * the namespace scope the def walk carries (enclosing_class_qn was extended
      * by is_namespace_scope_kind), so `ns::serialize` is `proj.file.ns.serialize`
@@ -6715,6 +6707,16 @@ static void extract_func_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec
         }
     }
 
+    /* C-family platform variants (foo_win.c / foo_posix.c, src/unix/ vs
+     * src/win/): an external-linkage file-scope function keeps its path QN and
+     * carries its platform-neutral QN as the key that relates its variants
+     * (the node's `variant_key`). NULL for anything scoped, static, or in a
+     * path without a platform token. */
+    if (!ctx->enclosing_class_qn) {
+        def.variant_key = cbm_platform_neutral_qn(a, ctx->language, ctx->project, ctx->rel_path,
+                                                  qn_name, def.qualified_name, node);
+    }
+
     // Pony: fun/be/new (method/constructor/ffi_method) live in pony_func_types,
     // so the main def-walk extracts them here as "Function"; but one declared
     // inside a class/actor/struct/trait/interface/primitive IS a method. Detect

internal/cbm/extract_unified.c

@@ -1111,13 +1111,9 @@ static const char *compute_func_qn(CBMExtractCtx *ctx, TSNode node, const CBMLan
         return cbm_arena_sprintf(ctx->arena, "%s.%s", state->enclosing_class_qn, qn_name);
     }
     /* Java/Go: directory-based module so this enclosing-func QN matches the def
-     * QN and the LSP caller_qn (the lsp_resolve join keys on exact equality).
-     * C-family platform variants share their platform-neutral QN — the same
-     * rule extract_func_def applies, so in-body calls source to the def. */
-    const char *qn = cbm_fqn_compute_source_lang(ctx->arena, ctx->project, ctx->rel_path, qn_name,
-                                                 ctx->language);
-    return cbm_platform_variant_qn(ctx->arena, ctx->language, ctx->project, ctx->rel_path, qn_name,
-                                   qn, node);
+     * QN and the LSP caller_qn (the lsp_resolve join keys on exact equality). */
+    return cbm_fqn_compute_source_lang(ctx->arena, ctx->project, ctx->rel_path, qn_name,
+                                       ctx->language);
 }
 
 // Compute class QN for scope tracking.

internal/cbm/helpers.c

@@ -1946,24 +1946,24 @@ static bool func_is_static(TSNode func_node) {
     return false;
 }
 
-const char *cbm_platform_variant_qn(CBMArena *a, CBMLanguage lang, const char *project,
+const char *cbm_platform_neutral_qn(CBMArena *a, CBMLanguage lang, const char *project,
                                     const char *rel_path, const char *name, const char *qn,
                                     TSNode func_node) {
     if (!c_family_variant_lang(lang) || !rel_path || !name || !name[0] || !qn ||
         ts_node_is_null(func_node) || func_is_static(func_node)) {
-        return qn;
+        return NULL;
     }
     char *plain = cbm_fqn_compute(a, project, rel_path, name);
     if (!plain || strcmp(plain, qn) != 0) {
-        return qn; /* namespaced or otherwise scoped: not a file-scope function */
+        return NULL; /* namespaced or otherwise scoped: not a file-scope function */
     }
     /* Rebuild the path without platform tokens: a directory segment that is
      * one is dropped; a filename stem loses its platform suffix, and a stem
      * that IS a token leaves the function at its directory. */
     size_t len = strlen(rel_path);
     char *neutral = (char *)cbm_arena_alloc(a, len + SKIP_ONE);
     if (!neutral) {
-        return qn;
+        return NULL;
     }
     size_t out = 0;
     bool changed = false;
@@ -2010,16 +2010,15 @@ const char *cbm_platform_variant_qn(CBMArena *a, CBMLanguage lang, const char *p
     }
     neutral[out] = '\0';
     if (!changed) {
-        return qn;
+        return NULL;
     }
     if (dir_level) {
         /* No file stem left: the folder form keeps every directory segment
          * (cbm_fqn_compute would strip a dotted segment as an extension). */
         char *folder = cbm_fqn_folder(a, project ? project : "", neutral);
-        return folder ? cbm_arena_sprintf(a, "%s.%s", folder, name) : qn;
+        return folder ? cbm_arena_sprintf(a, "%s.%s", folder, name) : NULL;
     }
-    char *variant = cbm_fqn_compute(a, project, neutral, name);
-    return variant ? variant : qn;
+    return cbm_fqn_compute(a, project, neutral, name);
 }
 
 char *cbm_fqn_folder(CBMArena *a, const char *project, const char *rel_dir) {

internal/cbm/helpers.h

@@ -295,12 +295,17 @@ char *cbm_fqn_compute_source_lang(CBMArena *a, const char *project, const char *
 
 // C-family platform variants: the same external-linkage function defined in
 // files that differ only by a platform token (foo_win.c / foo_posix.c,
-// src/unix/fs.c / src/win/fs.c) is ONE function with platform variants — two
+// src/unix/fs.c / src/win/fs.c) is one function with platform variants — two
 // external definitions of one name cannot link into one program, so they are
-// alternatives by construction. Returns the platform-neutral QN (the path with
-// its platform tokens removed) for a non-static file-scope function of
-// C/C++/CUDA/ObjC whose `qn` is the plain file-stem form; otherwise `qn`.
-const char *cbm_platform_variant_qn(CBMArena *a, CBMLanguage lang, const char *project,
+// alternatives by construction. Each definition keeps its own path QN (it is
+// found by its file); this returns the KEY that relates the variants: the
+// platform-neutral QN (the path with its platform tokens removed), for a
+// non-static file-scope function of C/C++/CUDA/ObjC whose `qn` is the plain
+// file-stem form and whose path carries a platform token. NULL otherwise. A
+// pure function of the definition's own path, name and linkage: no other file
+// takes part, so a full index and an incremental repair write the same key.
+// It becomes the node's `variant_key` property (CBMDefinition.variant_key).
+const char *cbm_platform_neutral_qn(CBMArena *a, CBMLanguage lang, const char *project,
                                     const char *rel_path, const char *name, const char *qn,
                                     TSNode func_node);
 

internal/cbm/result_compact.c

@@ -278,6 +278,7 @@ static void cr_walk_def(cr_ctx_t *c, CBMDefinition *d) {
     cr_str(c, &d->variants);
     cr_list(c, &d->extra_props);
     cr_str(c, &d->decl_namespace);
+    cr_str(c, &d->variant_key);
 }
 
 static void cr_walk_call(cr_ctx_t *c, CBMCall *call) {

src/graph_buffer/graph_buffer.c

@@ -889,7 +889,11 @@ int cbm_gbuf_duplicate_edge_ids(const cbm_gbuf_t *gb) {
  * sorted, unique), so a change in any variant maps to the node. Recorded only
  * between definitions of the same label with real spans: a different kind
  * sharing the QN (C: struct vs function) is no variant, a span on line 0 is
- * no location (delta-route proxies), and a full tie is the same entity. */
+ * no location (delta-route proxies), and a full tie is the same entity.
+ * C-family platform files (foo_win.c / foo_posix.c, src/unix/ vs src/win/)
+ * do not collide here: each definition keeps its path QN, and they share a
+ * `variant_key` property instead (helpers.h cbm_platform_neutral_qn), which
+ * the test-impact walk follows (store_impact.h follow_variant_keys). */
 static void *gb_yy_malloc(void *ctx, size_t size) {
     (void)ctx;
     return cbm_alloc(CBM_MEM_CLASS_GBUF_STRING, size);

src/mcp/test_impact_engine_reach.c

@@ -290,11 +290,15 @@ static bool te_collect_sinks(te_ctx_t *c, te_sinks_t *s) {
 
 static bool te_walk(te_ctx_t *c, const te_sinks_t *sinks, const int64_t *extra, int extra_count,
                     cbm_impact_walk_t **out) {
+    /* A change in one platform variant of a function (foo_win.c / foo_posix.c)
+     * reaches whoever calls any of its variants: a caller binds to one of
+     * them, and the build of another platform runs another. */
     cbm_impact_policy_t policy = {.project = "test-impact",
                                   .edge_types = te_walk_types,
                                   .edge_type_count =
                                       (int)(sizeof(te_walk_types) / sizeof(te_walk_types[0])),
-                                  .follow_routes = true};
+                                  .follow_routes = true,
+                                  .follow_variant_keys = true};
     *out = NULL;
     if (cbm_impact_walk_open_scoped(c->scope, &policy, out) != CBM_STORE_OK) {
         return te_fallback(c, CBM_TEST_RESULT_FALLBACK_ENGINE_SATURATED,

src/mcp/test_impact_seed.c

@@ -168,11 +168,13 @@ static bool ts_has_span(const cbm_ti_node_t *nodes, int count, const cbm_node_t
 }
 
 /* The file's definitions, each with every span it has in the file: a
- * definition written once per #if branch or platform file is ONE node
+ * definition written once per #if branch or Go build-tagged file is ONE node
  * (graph_buffer.c "Definition variants") whose own span is one variant, so
  * its other variants here (other branches, or a node whose file_path names
- * another platform file) join as further spans of the same node. A change
- * in any variant then seeds that definition. */
+ * another file of the same QN) join as further spans of the same node. A
+ * change in any variant then seeds that definition. C-family platform files
+ * are separate nodes sharing a `variant_key`; the walk relates them
+ * (store_impact.h follow_variant_keys). */
 static ts_file_t *ts_load_file(cbm_ti_graph_t *g, const char *file) {
     cbm_node_t *rows = NULL;
     int count = 0;

src/pipeline/pass_definitions.c

@@ -309,9 +309,10 @@ static void build_def_props(char *buf, size_t bufsize, const CBMDefinition *def)
     }
     size_t pos = (size_t)n;
     append_json_string(buf, bufsize, &pos, "docstring", def->docstring);
-    /* Right after the docstring: the buffer is sized for exactly these two
-     * uncapped fields (pd_props_buf), so neither can be squeezed out. */
+    /* Right after the docstring: the buffer is sized for exactly these three
+     * uncapped fields (pd_props_buf), so none can be squeezed out. */
     append_json_raw(buf, bufsize, &pos, "variants", def->variants);
+    append_json_string(buf, bufsize, &pos, "variant_key", def->variant_key);
     append_json_string(buf, bufsize, &pos, "signature", def->signature);
     append_json_string(buf, bufsize, &pos, "return_type", def->return_type);
     append_json_string(buf, bufsize, &pos, "parent_class", def->parent_class);
@@ -353,10 +354,10 @@ static void build_def_props(char *buf, size_t bufsize, const CBMDefinition *def)
 }
 
 /* A def's properties buffer: CBM_SZ_2K for every other field plus the whole
- * serialized docstring and variants fields, which have no length cap (a field
- * that does not fit is dropped whole). Returns `stack` for a def with neither,
- * or when the larger buffer cannot be allocated. Twin of pass_parallel.c --
- * keep both in sync. */
+ * serialized docstring, variants and variant_key fields, which have no length
+ * cap (a field that does not fit is dropped whole). Returns `stack` for a def
+ * with none of them, or when the larger buffer cannot be allocated. Twin of
+ * pass_parallel.c -- keep both in sync. */
 static char *pd_props_buf(const CBMDefinition *def, char *stack, size_t *size) {
     size_t need = *size;
     if (def->docstring && def->docstring[0]) {
@@ -365,6 +366,10 @@ static char *pd_props_buf(const CBMDefinition *def, char *stack, size_t *size) {
     if (def->variants && def->variants[0]) {
         need += strlen("variants") + strlen(def->variants) + PD_JSON_FIELD_OVERHEAD;
     }
+    if (def->variant_key && def->variant_key[0]) {
+        need +=
+            strlen("variant_key") + def_json_escaped_len(def->variant_key) + PD_JSON_FIELD_OVERHEAD;
+    }
     if (need == *size) {
         return stack;
     }