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(cs-lsp): look up the global namespace in C# spec order
Martin Vogeldad89184cb88
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.hindex 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.cindex 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.cindex 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, constout[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 *shortif (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 thediff --git a/internal/cbm/lsp/cs_lsp.h b/internal/cbm/lsp/cs_lsp.hindex 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.cindex 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.cindex 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);