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(cs-lsp): look up the global namespace in C# spec order

Martin Vogeldad89184cb88
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index 1c4fb7194..1a38c6f51 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -289,8 +289,9 @@ typedef struct {
* qualified_name (base QN = the first qn_sig_off bytes); 0 = no suffix.
* Always 0 until a language enables its callable_identity mode. */
uint32_t qn_sig_off;
- /* C# only: declared namespace of a TOP-LEVEL type (NULL for nested types,
- * the global namespace and every other language). Per type, because the
+ /* C# only: declared namespace of a TOP-LEVEL type, "" for the global
+ * namespace (proven only by a clean parse), NULL for nested types, an
+ * unknown namespace and every other language. Per type, because the
* file-level namespace_name records only a file's first namespace. */
const char *decl_namespace;
CBMTestDefinitionRole test_role; /* NONE preserves legacy helper/test-file semantics */
diff --git a/internal/cbm/extract_defs.c b/internal/cbm/extract_defs.c
index 3a476e4b8..46b1b51dc 100644
--- a/internal/cbm/extract_defs.c
+++ b/internal/cbm/extract_defs.c
@@ -8340,9 +8340,15 @@ static const char *cs_namespace_decl_name(CBMArena *a, TSNode ns, const char *so
/* Declared namespace of a C# type declaration: every enclosing namespace
* block (outer to inner) under an optional file-scoped namespace, which the
* grammar may attach either as an ancestor or as a preceding sibling of the
- * compilation unit's members. NULL = global namespace. The file-level
- * namespace_name keeps only the FIRST namespace of a file, which mislabels
- * every type of a multi-namespace file (#2120). */
+ * compilation unit's members. "" = the global namespace, NULL = unknown. The
+ * file-level namespace_name keeps only the FIRST namespace of a file, which
+ * mislabels every type of a multi-namespace file (#2120).
+ *
+ * "No namespace found" proves the global namespace only for a clean parse:
+ * error recovery can dissolve a namespace declaration around a construct the
+ * grammar does not know (a `ref partial struct` with members does it), leaving
+ * the types after it parented straight under the compilation unit. Calling
+ * those global would let them hide every imported type of the same name. */
static const char *cs_type_decl_namespace(CBMArena *a, TSNode node, const char *source) {
const char *acc = NULL;
bool file_scoped = false;
@@ -8376,7 +8382,10 @@ static const char *cs_type_decl_namespace(CBMArena *a, TSNode node, const char *
}
}
}
- return acc;
+ if (acc) {
+ return acc;
+ }
+ return ts_node_has_error(top) ? NULL : "";
}
static void extract_class_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec) {
diff --git a/internal/cbm/lsp/cs_lsp.c b/internal/cbm/lsp/cs_lsp.c
index 978fb5b71..03345da9f 100644
--- a/internal/cbm/lsp/cs_lsp.c
+++ b/internal/cbm/lsp/cs_lsp.c
@@ -261,11 +261,15 @@ void cs_lsp_init(CSLSPContext *ctx, CBMArena *arena, const char *source, int sou
/* ── using management ───────────────────────────────────────────── */
-void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
- const char *target_qn, bool is_global) {
+/* Append a using directive; `in_namespace` marks one declared inside a
+ * namespace body (CBMCSUsing.in_namespace). */
+static void cs_add_using_scoped(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
+ const char *target_qn, bool is_global, bool in_namespace) {
if (!target_qn)
return;
- /* Dedupe by (kind, local_name, target). */
+ /* Dedupe by (kind, local_name, target). The cross-file entry pre-loads
+ * the pipeline's import list without placement; the AST walk then finds
+ * the same directive and is the authority on where it was declared. */
for (int i = 0; i < ctx->using_count; i++) {
CBMCSUsing *u = &ctx->usings[i];
if (u->kind != kind)
@@ -276,6 +280,7 @@ void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_
const char *b = u->local_name ? u->local_name : "";
if (strcmp(a, b) != 0)
continue;
+ u->in_namespace = u->in_namespace || in_namespace;
return;
}
if (ctx->using_count >= ctx->using_cap) {
@@ -293,6 +298,12 @@ void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_
slot->local_name = local_name ? cbm_arena_strdup(ctx->arena, local_name) : "";
slot->target_qn = cbm_arena_strdup(ctx->arena, target_qn);
slot->is_global = is_global;
+ slot->in_namespace = in_namespace;
+}
+
+void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
+ const char *target_qn, bool is_global) {
+ cs_add_using_scoped(ctx, kind, local_name, target_qn, is_global, false);
}
/* ── namespace stack ────────────────────────────────────────────── */
@@ -362,12 +373,29 @@ static const char *cs_try_type_qn(CSLSPContext *ctx, const char *qn) {
return NULL;
}
+/* Append the file's using-namespace targets declared inside (`in_namespace`)
+ * or outside a namespace body. */
+static int cs_append_using_namespaces(const CSLSPContext *ctx, bool in_namespace, const char **out,
+ int n, int cap) {
+ for (int i = 0; i < ctx->using_count && n < cap; i++) {
+ const CBMCSUsing *u = &ctx->usings[i];
+ if (u->kind == CBM_CS_USING_NAMESPACE && u->in_namespace == in_namespace && u->target_qn &&
+ u->target_qn[0])
+ out[n++] = u->target_qn;
+ }
+ return n;
+}
+
/* Namespaces through which `qualifier` (the part of a type reference before
* its simple name, NULL for a simple name) can reach a top-level type, in C#
* lookup order: each enclosing namespace innermost outward, then the global
- * namespace (qualified references only) or the file's `using` namespaces
- * (simple names only -- a using-namespace directive does not import nested
- * namespaces). Returns the count written to `out` (at most `cap`). */
+ * namespace (qualified references only) or, for a simple name, the usings
+ * of the enclosing namespace bodies, the global namespace "" and last the
+ * compilation-unit usings (a using-namespace directive does not import nested
+ * namespaces). C# consults the members of the global namespace BEFORE the
+ * compilation unit's usings: a top-level type declared without a namespace
+ * hides an imported type of the same name. Returns the count written to
+ * `out` (at most `cap`). */
static int cs_visible_namespaces(CSLSPContext *ctx, const char *qualifier, const char **out,
int cap) {
int n = 0;
@@ -382,17 +410,13 @@ static int cs_visible_namespaces(CSLSPContext *ctx, const char *qualifier, const
out[n++] = qualifier;
return n;
}
- for (int i = 0; i < ctx->using_count && n < cap; i++) {
- const CBMCSUsing *u = &ctx->usings[i];
- if (u->kind == CBM_CS_USING_NAMESPACE && u->target_qn && u->target_qn[0])
- out[n++] = u->target_qn;
- }
- /* The global namespace is checked last: an unqualified name binds to a
- * top-level type declared without a namespace whatever the file imports
- * (#2120 residual — such types used to be invisible to step 8b). */
+ n = cs_append_using_namespaces(ctx, true, out, n, cap);
+ /* The global namespace (#2120 residual: such types used to be invisible
+ * to step 8b) ranks after every enclosing namespace and namespace-body
+ * using, and before the compilation-unit usings. */
if (n < cap)
out[n++] = "";
- return n;
+ return cs_append_using_namespaces(ctx, false, out, n, cap);
}
/* Bind a (possibly namespace-qualified) type reference to the project type
@@ -2824,12 +2848,19 @@ static void cs_process_type_decl(CSLSPContext *ctx, TSNode node) {
static void cs_collect_imports(CSLSPContext *ctx, TSNode root) {
/* Walk the entire tree once at top — using directives can appear at file
- * scope or inside namespace blocks. */
- TSNode stack[256];
+ * scope or inside namespace blocks. `in_ns` records per stacked node
+ * whether it sits inside a namespace declaration: a block namespace's
+ * body, or the compilation-unit siblings after a file-scoped namespace
+ * (the grammar may attach those either way). */
+ enum { CS_IMPORT_WALK_MAX = 256 };
+ TSNode stack[CS_IMPORT_WALK_MAX];
+ bool in_ns[CS_IMPORT_WALK_MAX];
int top = 0;
+ in_ns[top] = false;
stack[top++] = root;
while (top > 0) {
TSNode n = stack[--top];
+ bool n_in_ns = in_ns[top];
if (ts_node_is_null(n))
continue;
const char *k = ts_node_type(n);
@@ -2913,20 +2944,23 @@ static void cs_collect_imports(CSLSPContext *ctx, TSNode root) {
}
if (target) {
if (is_alias) {
- cs_lsp_add_using(ctx, CBM_CS_USING_ALIAS, alias_name ? alias_name : "", target,
- is_global);
+ cs_add_using_scoped(ctx, CBM_CS_USING_ALIAS, alias_name ? alias_name : "",
+ target, is_global, n_in_ns);
} else if (is_static) {
- cs_lsp_add_using(ctx, CBM_CS_USING_STATIC, "", target, is_global);
+ cs_add_using_scoped(ctx, CBM_CS_USING_STATIC, "", target, is_global, n_in_ns);
} else {
- cs_lsp_add_using(ctx, CBM_CS_USING_NAMESPACE, "", target, is_global);
+ cs_add_using_scoped(ctx, CBM_CS_USING_NAMESPACE, "", target, is_global,
+ n_in_ns);
}
}
}
/* Push children for traversal. We don't recurse into method bodies
* (using directives can't appear there), but namespace bodies may
* contain more usings. */
+ bool child_in_ns = n_in_ns || strcmp(k, "namespace_declaration") == 0 ||
+ strcmp(k, "file_scoped_namespace_declaration") == 0;
uint32_t cnc = ts_node_child_count(n);
- for (uint32_t i = 0; i < cnc && top < 256; i++) {
+ for (uint32_t i = 0; i < cnc && top < CS_IMPORT_WALK_MAX; i++) {
TSNode c = ts_node_child(n, i);
if (ts_node_is_null(c))
continue;
@@ -2935,7 +2969,11 @@ static void cs_collect_imports(CSLSPContext *ctx, TSNode root) {
strcmp(ck, "constructor_declaration") == 0 || strcmp(ck, "block") == 0) {
continue;
}
+ in_ns[top] = child_in_ns;
stack[top++] = c;
+ /* A file-scoped namespace covers the siblings that follow it. */
+ if (strcmp(ck, "file_scoped_namespace_declaration") == 0)
+ child_in_ns = true;
}
}
}
@@ -3782,10 +3820,11 @@ static const char *cs_top_level_namespace(const char *type_qn, const char *short
if (strncmp(type_qn, module_qn, mlen) != 0 || type_qn[mlen] != '.' ||
strcmp(type_qn + mlen + 1, short_name) != 0)
return NULL;
- /* Top-level C# type: its declared namespace, "" when it declares none
- * (global namespace) so step 8b can bind it — NULL stays reserved for
- * nested types, which no namespace can reach by simple name. */
- return (namespace_name && namespace_name[0]) ? namespace_name : "";
+ /* Top-level C# type: its declared namespace, "" for the global namespace
+ * so step 8b can bind it, NULL when extraction could not tell (a parse
+ * error dissolved the namespace; see cs_type_decl_namespace). NULL stays
+ * invisible to step 8b, as do nested types. */
+ return namespace_name;
}
/* Register one batch of CBMLSPDef[] into a registry. Shared by the
diff --git a/internal/cbm/lsp/cs_lsp.h b/internal/cbm/lsp/cs_lsp.h
index b7b6c4dc8..4c47fc67d 100644
--- a/internal/cbm/lsp/cs_lsp.h
+++ b/internal/cbm/lsp/cs_lsp.h
@@ -61,6 +61,11 @@ typedef struct {
const char *local_name; /* alias name; "" for non-alias */
const char *target_qn; /* dotted target QN */
bool is_global; /* `global using` */
+ /* Declared inside a namespace body rather than at compilation-unit level.
+ * C# consults a namespace declaration's usings right after that
+ * namespace's own members, but compilation-unit usings only after the
+ * global namespace's members, so the two rank on opposite sides of it. */
+ bool in_namespace;
} CBMCSUsing;
/* CSLSPContext — per-file type-evaluation state. */
diff --git a/tests/test_cs_lsp.c b/tests/test_cs_lsp.c
index 54184ea09..98b1a6e21 100644
--- a/tests/test_cs_lsp.c
+++ b/tests/test_cs_lsp.c
@@ -1254,6 +1254,50 @@ TEST(cslsp_cyclic_alias_qualifier_terminates) {
PASS();
}
+static const CBMDefinition *find_def_named(const CBMFileResult *r, const char *name) {
+ for (int i = 0; i < r->defs.count; i++) {
+ if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0)
+ return &r->defs.items[i];
+ }
+ return NULL;
+}
+
+/* A top-level C# type records its declared namespace; "" means the global
+ * namespace and is claimed only on a clean parse. The vendored grammar does
+ * not parse a `ref partial struct` with members, and error recovery dissolves
+ * the enclosing namespace, so the types after it surface with no namespace
+ * ancestor. Those must not read as global (they would hide every imported
+ * type of the same name); unknown (NULL) keeps them out of namespace binding
+ * exactly as before global-namespace binding existed. */
+TEST(cslsp_decl_namespace_global_needs_clean_parse) {
+ CBMFileResult *clean = extract_cs("public class Loose { }\n"
+ "namespace Acme.Lib { public class Kept { } }\n");
+ ASSERT(clean);
+ const CBMDefinition *loose = find_def_named(clean, "Loose");
+ const CBMDefinition *kept = find_def_named(clean, "Kept");
+ ASSERT(loose && kept);
+ ASSERT(loose->decl_namespace && strcmp(loose->decl_namespace, "") == 0);
+ ASSERT(kept->decl_namespace && strcmp(kept->decl_namespace, "Acme.Lib") == 0);
+ cbm_free_result(clean);
+
+ CBMFileResult *damaged = extract_cs("namespace Acme.Lib\n"
+ "{\n"
+ " public ref partial struct Handler\n"
+ " {\n"
+ " public void Append(string value) { }\n"
+ " }\n"
+ " public static partial class Gadget { }\n"
+ "}\n");
+ ASSERT(damaged);
+ const CBMDefinition *gadget = find_def_named(damaged, "Gadget");
+ ASSERT(gadget);
+ if (gadget->decl_namespace && !gadget->decl_namespace[0])
+ printf(" Gadget after a parse error claims the global namespace\n");
+ ASSERT(!gadget->decl_namespace || gadget->decl_namespace[0]);
+ cbm_free_result(damaged);
+ PASS();
+}
+
/* ── Suite ─────────────────────────────────────────────────── */
SUITE(cs_lsp) {
@@ -1319,4 +1363,5 @@ SUITE(cs_lsp) {
RUN_TEST(cslsp_httpclient_chain);
RUN_TEST(cslsp_ordinary_same_leaf_calls_join_by_exact_site);
RUN_TEST(cslsp_cyclic_alias_qualifier_terminates);
+ RUN_TEST(cslsp_decl_namespace_global_needs_clean_parse);
}
diff --git a/tests/test_parallel.c b/tests/test_parallel.c
index 892721228..4b67ea200 100644
--- a/tests/test_parallel.c
+++ b/tests/test_parallel.c
@@ -3103,11 +3103,16 @@ TEST(parallel_csharp_nested_type_and_global_namespace_binding) {
" return u.Check();\n"
" }\n"
"}\n";
- /* The lookup-order probe: the SAME simple name resolves through an
- * imported namespace AND exists in the global namespace. C# binds the
- * imported namespace first, so ImportUser.Run2 must hit the Other variant
- * and never the global one — proving the global namespace is appended
- * last in cs_visible_namespaces, not merged as an equal. */
+ /* The lookup-order probes: the SAME simple name is importable from
+ * Acme.Other.Web.Services AND declared in the global namespace. C# looks
+ * a simple name up namespace by namespace, innermost outward; at each one
+ * it checks that namespace's members, then the usings of the namespace
+ * declaration enclosing the reference. The global namespace comes last,
+ * and its "declaration" is the compilation unit, so:
+ * - a compilation-unit `using` (ImportUser) is consulted only AFTER the
+ * global namespace's members: the global UpdateService wins;
+ * - a `using` inside the namespace body (NsUsingUser) is consulted
+ * before any outer namespace: the imported UpdateService wins. */
static const char import_user_src[] =
"using Acme.Other.Web.Services;\n"
"namespace Acme.App;\n"
@@ -3115,7 +3120,17 @@ TEST(parallel_csharp_nested_type_and_global_namespace_binding) {
" public string Run2() {\n"
" var u = new UpdateService();\n"
" return u.Check();\n"
- " }\n"
+ " }\n"
+ "}\n";
+ static const char ns_using_user_src[] =
+ "namespace Acme.App {\n"
+ " using Acme.Other.Web.Services;\n"
+ " public class NsUsingUser {\n"
+ " public string Run3() {\n"
+ " var u = new UpdateService();\n"
+ " return u.Check();\n"
+ " }\n"
+ " }\n"
"}\n";
const char *project = "cbm_cs_nested";
static const char *rels[] = {
@@ -3128,11 +3143,13 @@ TEST(parallel_csharp_nested_type_and_global_namespace_binding) {
"src/App/ChainedUser.cs",
"src/App/Boot.cs",
"src/App/ImportUser.cs",
+ "src/App/NsUsingUser.cs",
};
- const char *srcs[] = {decoy_src, other_update_src, partner_src,
- backoffice_src, global_update_src, nested_user_src,
- chained_user_src, boot_src, import_user_src};
- enum { N_FILES = 9, N_CHECKS = 10 };
+ const char *srcs[] = {decoy_src, other_update_src, partner_src,
+ backoffice_src, global_update_src, nested_user_src,
+ chained_user_src, boot_src, import_user_src,
+ ns_using_user_src};
+ enum { N_FILES = 10, N_CHECKS = 12 };
char tmpdir[256];
snprintf(tmpdir, sizeof(tmpdir), "/tmp/cbm_par_cs_nested_XXXXXX");
@@ -3200,8 +3217,10 @@ TEST(parallel_csharp_nested_type_and_global_namespace_binding) {
ok[g][5] = !has_edge_from_callable_to_qn(gb, "ChainedUser.Run", decoy_handle, "CALLS");
ok[g][6] = has_edge_from_callable_to_qn(gb, "Boot.Boot1", global_check, "CALLS");
ok[g][7] = !has_edge_from_callable_to_qn(gb, "Boot.Boot1", other_check, "CALLS");
- ok[g][8] = has_edge_from_callable_to_qn(gb, "ImportUser.Run2", other_check, "CALLS");
- ok[g][9] = !has_edge_from_callable_to_qn(gb, "ImportUser.Run2", global_check, "CALLS");
+ ok[g][8] = has_edge_from_callable_to_qn(gb, "ImportUser.Run2", global_check, "CALLS");
+ ok[g][9] = !has_edge_from_callable_to_qn(gb, "ImportUser.Run2", other_check, "CALLS");
+ ok[g][10] = has_edge_from_callable_to_qn(gb, "NsUsingUser.Run3", other_check, "CALLS");
+ ok[g][11] = !has_edge_from_callable_to_qn(gb, "NsUsingUser.Run3", global_check, "CALLS");
for (int k = 0; k < N_CHECKS; k++) {
/* The ctor-edge checks 2/3 gate the parallel path only. In the
* sequential path the `new GrainCommand.Result(true)` edge is
@@ -3217,10 +3236,93 @@ TEST(parallel_csharp_nested_type_and_global_namespace_binding) {
if (!all) {
for (int g = 0; g < 2; g++) {
printf(" C# nested/global diagnostic %s: nested_code=%d/%d nested_ctor=%d/%d "
- "chained=%d/%d global_ns=%d/%d imported=%d/%d\n",
+ "chained=%d/%d global_ns=%d/%d cu_using=%d/%d ns_using=%d/%d\n",
g == 0 ? "sequential" : "parallel", ok[g][0], ok[g][1], ok[g][2], ok[g][3],
- ok[g][4], ok[g][5], ok[g][6], ok[g][7], ok[g][8], ok[g][9]);
+ ok[g][4], ok[g][5], ok[g][6], ok[g][7], ok[g][8], ok[g][9], ok[g][10],
+ ok[g][11]);
+ }
+ }
+ cbm_gbuf_free(graphs[0]);
+ cbm_gbuf_free(graphs[1]);
+ th_rmtree(tmpdir);
+ ASSERT_TRUE(all);
+ PASS();
+}
+
+/* A type extracted with no namespace is global only if its file parsed
+ * cleanly. The vendored grammar does not parse a `ref partial struct` with
+ * members (reference assemblies are full of them), and error recovery
+ * dissolves the namespace around it, so the static class after it surfaces
+ * with no namespace. Read as global, it outranked the compilation-unit
+ * `using` and took every `Gadget.Spin()` call from the real, visible type;
+ * on dotnet/runtime that moved 5,313 CALLS from implementation files into
+ * reference assemblies. The damaged file is registered FIRST so neither the
+ * old registry order nor the global rank can explain a pass. */
+TEST(parallel_csharp_parse_damaged_namespace_is_not_global) {
+ static const char damaged_src[] = "namespace Acme.Lib\n"
+ "{\n"
+ " public ref partial struct Handler\n"
+ " {\n"
+ " public void Append(string value) { }\n"
+ " }\n"
+ " public static partial class Gadget {\n"
+ " public static int Spin() => 9;\n"
+ " }\n"
+ "}\n";
+ static const char real_src[] = "namespace Acme.Lib;\n"
+ "public static class Gadget {\n"
+ " public static int Spin() => 1;\n"
+ "}\n";
+ static const char user_src[] = "using Acme.Lib;\n"
+ "namespace Acme.App;\n"
+ "public class GadgetUser {\n"
+ " public int Run() {\n"
+ " return Gadget.Spin();\n"
+ " }\n"
+ "}\n";
+ const char *project = "cbm_cs_damaged";
+ static const char *rels[] = {"src/Ref/Lib.cs", "src/Lib/Gadget.cs", "src/App/GadgetUser.cs"};
+ const char *srcs[] = {damaged_src, real_src, user_src};
+ enum { N_FILES = 3 };
+
+ char tmpdir[256];
+ snprintf(tmpdir, sizeof(tmpdir), "/tmp/cbm_par_cs_damaged_XXXXXX");
+ if (!cbm_mkdtemp(tmpdir)) {
+ FAIL("mkdtemp failed");
+ }
+ char paths[N_FILES][512];
+ cbm_file_info_t files[N_FILES] = {0};
+ for (int i = 0; i < N_FILES; i++) {
+ snprintf(paths[i], sizeof(paths[i]), "%s/%s", tmpdir, rels[i]);
+ if (th_write_file(paths[i], srcs[i]) != 0) {
+ th_rmtree(tmpdir);
+ FAIL("failed to write C# damaged-namespace fixture");
}
+ files[i].path = paths[i];
+ files[i].rel_path = (char *)rels[i];
+ files[i].language = CBM_LANG_CSHARP;
+ }
+
+ cbm_gbuf_t *graphs[2] = {run_sequential_with_lsp_cross(project, tmpdir, files, N_FILES), NULL};
+ g_harness_cs_registry = true;
+ graphs[1] = run_parallel(project, tmpdir, files, N_FILES, 2);
+ g_harness_cs_registry = false;
+ ASSERT_NOT_NULL(graphs[0]);
+ ASSERT_NOT_NULL(graphs[1]);
+
+ const char *real_spin = "cbm_cs_damaged.src.Lib.Gadget.Gadget.Spin";
+ const char *damaged_spin = "cbm_cs_damaged.src.Ref.Lib.Gadget.Spin";
+ bool ok[2][2];
+ for (int g = 0; g < 2; g++) {
+ ok[g][0] = has_edge_from_callable_to_qn(graphs[g], "GadgetUser.Run", real_spin, "CALLS");
+ ok[g][1] = !has_edge_from_callable_to_qn(graphs[g], "GadgetUser.Run", damaged_spin,
+ "CALLS");
+ }
+ bool all = ok[0][0] && ok[0][1] && ok[1][0] && ok[1][1];
+ if (!all) {
+ printf(" C# damaged-namespace diagnostic: sequential real=%d no_damaged=%d "
+ "parallel real=%d no_damaged=%d\n",
+ ok[0][0], ok[0][1], ok[1][0], ok[1][1]);
}
cbm_gbuf_free(graphs[0]);
cbm_gbuf_free(graphs[1]);
@@ -5898,6 +6000,7 @@ SUITE(parallel) {
RUN_TEST(parallel_tsx_import_namespace_exact_parity);
RUN_TEST(parallel_csharp_same_name_class_binds_by_namespace);
RUN_TEST(parallel_csharp_nested_type_and_global_namespace_binding);
+ RUN_TEST(parallel_csharp_parse_damaged_namespace_is_not_global);
RUN_TEST(parallel_kotlin_external_protocol_does_not_use_project_class_method_tail);
RUN_TEST(parallel_kotlin_nonbinary_operator_carriers_reach_graph);
RUN_TEST(parallel_rust_cross_crate_worker_receives_workspace_manifest);