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(registry): resolve package-path imports against the project's own packages
Yyunozor138a62253d28
diff --git a/src/pipeline/pass_calls.c b/src/pipeline/pass_calls.cindex 7fc6bc423..f0f9b499f 100644--- a/src/pipeline/pass_calls.c+++ b/src/pipeline/pass_calls.c@@ -675,7 +675,8 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call,* #725 guard, after the service-pattern bypasses above, so no HTTP/route* edge can be lost to it. */if (cbm_suppress_external_import_shadow(call->callee_name, res.strategy, file_imports, imp_keys,- imp_count, cbm_pipeline_get_pkgmap())) {+ imp_count, cbm_pipeline_get_pkgmap(),+ cbm_pipeline_get_nsmap())) {return 0;}emit_classified_edge(ctx, call, source_node, target_node, &res, module_qn, imp_keys, imp_vals,diff --git a/src/pipeline/pass_definitions.c b/src/pipeline/pass_definitions.cindex 7ac98e9cd..eac9d0a96 100644--- a/src/pipeline/pass_definitions.c+++ b/src/pipeline/pass_definitions.c@@ -844,7 +844,9 @@ int cbm_pipeline_pass_definitions(cbm_pipeline_ctx_t *ctx, const cbm_file_info_tcreate_channel_edges_for_file(ctx, result, files[i].rel_path);cbm_pipeline_create_env_configures_for_file(ctx, result, files[i].rel_path);}- cbm_pipeline_namespace_map_free(namespace_map);+ /* Publish instead of free — see the twin in pass_parallel.c (#1355). */+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(namespace_map);if (owns_local_cache) {for (int i = 0; i < file_count; i++) {if (local_cache[i]) {diff --git a/src/pipeline/pass_parallel.c b/src/pipeline/pass_parallel.cindex a57d594cf..d7aa7bba9 100644--- a/src/pipeline/pass_parallel.c+++ b/src/pipeline/pass_parallel.c@@ -1343,7 +1343,11 @@ int cbm_build_registry_from_cache(cbm_pipeline_ctx_t *ctx, const cbm_file_info_tcbm_pipeline_create_env_configures_for_file(ctx, result, rel);}- cbm_pipeline_namespace_map_free(namespace_map);+ /* Publish instead of free: the call pass needs the same declared-package+ * set to tell an in-tree package path from a third-party one (#1355).+ * The pipeline owns it from here and frees it in its cleanup. */+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(namespace_map);cbm_log_info("parallel.registry.done", "entries", itoa_log(reg_entries), "defines",itoa_log(defines_edges), "imports", itoa_log(imports_edges));@@ -2571,7 +2575,8 @@ static void resolve_file_calls(resolve_ctx_t *rc, resolve_worker_state_t *ws, CB}if (target_node && source_node->id != target_node->id &&cbm_suppress_external_import_shadow(call->callee_name, res.strategy, &result->imports,- imp_keys, imp_count, cbm_pipeline_get_pkgmap())) {+ imp_keys, imp_count, cbm_pipeline_get_pkgmap(),+ cbm_pipeline_get_nsmap())) {/* #1355: same guard as pass_calls.c — a bare call bound by an* external package import must not become a CALLS edge to an* unrelated project symbol of the same name. */diff --git a/src/pipeline/pipeline.c b/src/pipeline/pipeline.cindex 938437549..1f15263a4 100644--- a/src/pipeline/pipeline.c+++ b/src/pipeline/pipeline.c@@ -229,6 +229,18 @@ void cbm_pipeline_set_pkgmap(CBMHashTable *map) {g_pkgmap = map;}+/* ── Global declared-package map (one active pipeline at a time) ── */++static CBMHashTable *g_nsmap = NULL;++CBMHashTable *cbm_pipeline_get_nsmap(void) {+ return g_nsmap;+}++void cbm_pipeline_set_nsmap(CBMHashTable *map) {+ g_nsmap = map;+}+bool cbm_pipeline_had_format_migration(const cbm_pipeline_t *p) {return p && p->format_migration;}@@ -2349,6 +2361,8 @@ static int cbm_pipeline_run_staged(cbm_pipeline_t *p) {cleanup:cbm_pkgmap_free(cbm_pipeline_get_pkgmap());cbm_pipeline_set_pkgmap(NULL);+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(NULL);cbm_discover_free(files, file_count);cbm_pipeline_free_semantic_manifest(baseline_manifest, baseline_count);cbm_gbuf_free(p->gbuf);diff --git a/src/pipeline/pipeline.h b/src/pipeline/pipeline.hindex 45ef74f84..81afe6b9a 100644--- a/src/pipeline/pipeline.h+++ b/src/pipeline/pipeline.h@@ -301,11 +301,16 @@ bool cbm_suppress_weak_local_binding_call(bool enabled, bool callee_is_locally_b* strategy are all kept. `indexed_packages` is the pipeline package map: a* specifier naming a package the tree itself declares (a workspace sibling)* counts as in-tree and is kept too; NULL disables that check.+ * `declared_packages` is the pipeline namespace map and does the same job for+ * package-path specifiers, which have no in-tree/external shape of their own:+ * `import org.example.util.assertThing` is kept when some indexed file+ * declares `package org.example.util`; NULL disables that check.* Pure; unit-tested in test_registry.c. */bool cbm_suppress_external_import_shadow(const char *callee_name, const char *strategy,const CBMImportArray *file_imports,const char **import_map_keys, int import_map_count,- const CBMHashTable *indexed_packages);+ const CBMHashTable *indexed_packages,+ const CBMHashTable *declared_packages);/* #725: drop a suffix_match CALLS edge when the caller language and the* target file's language disagree. unique_name (candidates == 1) is #1572diff --git a/src/pipeline/pipeline_incremental.c b/src/pipeline/pipeline_incremental.cindex bf71a1f84..6f147b25a 100644--- a/src/pipeline/pipeline_incremental.c+++ b/src/pipeline/pipeline_incremental.c@@ -1612,6 +1612,8 @@ static int closure_probe_surfaces(cbm_pipeline_t *p, const char *project,* leaked one map per probed run (LSan, macOS CI). */cbm_pkgmap_free(cbm_pipeline_get_pkgmap());cbm_pipeline_set_pkgmap(NULL);+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(NULL);cbm_path_alias_collection_free(aliases);cbm_gbuf_free(probe_gbuf);return rc;@@ -2183,6 +2185,8 @@ static int run_closure_delta(cbm_pipeline_t *p, const char *db_path, const char}cbm_pkgmap_free(cbm_pipeline_get_pkgmap());cbm_pipeline_set_pkgmap(NULL);+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(NULL);if (phase_rc != 0) {cbm_log_error("delta.err", "phase", "extract_resolve", "rc", itoa_buf(phase_rc));goto out;@@ -2762,6 +2766,8 @@ int cbm_pipeline_run_incremental(cbm_pipeline_t *p, const char *db_path, cbm_fil* full pipeline's ownership boundary on both success and failure. */cbm_pkgmap_free(cbm_pipeline_get_pkgmap());cbm_pipeline_set_pkgmap(NULL);+ cbm_pipeline_namespace_map_free(cbm_pipeline_get_nsmap());+ cbm_pipeline_set_nsmap(NULL);if (phase_rc != 0) {cbm_log_error("incremental.err", "phase", "extract_resolve", "rc", itoa_buf(phase_rc));diff --git a/src/pipeline/pipeline_internal.h b/src/pipeline/pipeline_internal.hindex 45b0baf6b..a8e0d5616 100644--- a/src/pipeline/pipeline_internal.h+++ b/src/pipeline/pipeline_internal.h@@ -172,6 +172,16 @@ static inline int cbm_pipeline_relpath_is_excluded(const char *rel_path, char *cCBMHashTable *cbm_pipeline_get_pkgmap(void);void cbm_pipeline_set_pkgmap(CBMHashTable *map);+/* Get the current pipeline's declared-package map (NULL if none): the+ * namespace/package → File-QN map built by cbm_pipeline_namespace_map_build+ * from every indexed file's own `package`/`namespace`/`using` declaration.+ * The import passes build it to resolve namespace imports; it is published+ * here so the call passes can ask whether a package-path specifier names a+ * package the tree itself declares (#1355). Set before resolve starts, read+ * only afterwards — same single-writer contract as the pkgmap above. */+CBMHashTable *cbm_pipeline_get_nsmap(void);+void cbm_pipeline_set_nsmap(CBMHashTable *map);+/* Unified module resolver: relative → pkgmap → fqn_module fallback.* Handles bare specifiers via pkgmap lookup with prefix matching.* Caller must free() the returned string. */diff --git a/src/pipeline/registry.c b/src/pipeline/registry.cindex adbe2c713..f16c0ddb8 100644--- a/src/pipeline/registry.c+++ b/src/pipeline/registry.c@@ -565,6 +565,84 @@ static bool specifier_names_indexed_package(const CBMHashTable *indexed_packagesreturn false;}+/* True when the specifier is a package PATH the indexed tree itself DECLARES.+ * `declared_packages` is the pipeline's namespace map, keyed by the+ * dot-normalized `package` / `namespace` / `use` declaration of every indexed+ * file (cbm_pipeline_namespace_map_build), so this is the JVM/CLR/PHP+ * counterpart of the manifest-name test above: those languages have no+ * specifier shape that separates in-tree from third-party, and their manifests+ * (pom.xml, build.gradle) name artifacts, not packages.+ *+ * A package-path specifier names a member inside a package, so the trailing+ * segment is walked off one at a time, exactly like the namespace-map lookup in+ * cbm_pipeline_resolve_import_node: `org.jetbrains.exposed.v1.tests.shared+ * .assertEquals` -> `org.jetbrains.exposed.v1.tests.shared`, which Exposed's+ * own Assert.kt declares, so the call keeps its edge. `java.net.URL` walks to+ * `java.net` then `java`, which no project file declares, so it stays external+ * and the guard still cuts its bind to an in-tree `URL` class.+ *+ * Separator normalization mirrors the map builder's: PHP writes `\`, some+ * grammars `::` or `/`. NULL disables the check. */+static bool specifier_names_declared_package(const CBMHashTable *declared_packages,+ const char *module_path) {+ if (!declared_packages || !module_path || !module_path[0]) {+ return false;+ }+ char buf[CBM_SZ_512];+ if (strlen(module_path) >= sizeof(buf)) {+ return false;+ }+ snprintf(buf, sizeof(buf), "%s", module_path);+ char *brace = strchr(buf, '{');+ if (brace) {+ *brace = '\0'; /* grouped import — the prefix is the package */+ }+ char *alias = strstr(buf, " as ");+ if (alias) {+ *alias = '\0';+ }+ for (char *p = buf; *p; p++) {+ if (*p == '\\' || *p == ':' || *p == '/') {+ *p = '.';+ }+ }+ /* Collapse the empty segments "::" just produced, then strip glob/+ * separator noise off the tail. */+ for (;;) {+ char *dd = strstr(buf, "..");+ if (!dd) {+ break;+ }+ memmove(dd, dd + 1, strlen(dd + 1) + 1);+ }+ size_t len = strlen(buf);+ while (len > 0 && (buf[len - 1] == '*' || buf[len - 1] == '.' || buf[len - 1] == ' ')) {+ buf[--len] = '\0';+ }+ if (buf[0] == '\0') {+ return false;+ }+ if (cbm_ht_has(declared_packages, buf)) {+ return true;+ }+ /* The walk has no floor, and that is a deliberate false-NEGATIVE: once the+ * tree declares `com.example`, EVERY specifier under `com.example.**` reads+ * as in-tree, including a third-party library that happens to publish under+ * a declared prefix. Such a call keeps the same-name fallback it has on+ * main, so the cost is a fabricated edge this guard could have removed —+ * never a real edge lost. Stopping earlier would need a rule for where a+ * package path ends and a type begins, and getting that wrong fails the+ * other way. Pinned by external_import_shadow_declared_prefix_is_permissive+ * in test_registry.c. */+ for (char *dot = strrchr(buf, '.'); dot != NULL; dot = strrchr(buf, '.')) {+ *dot = '\0';+ if (cbm_ht_has(declared_packages, buf)) {+ return true;+ }+ }+ return false;+}+static bool import_map_binds(const char **import_map_keys, int import_map_count,const char *local_name) {if (!import_map_keys || import_map_count <= 0) {@@ -612,11 +690,21 @@ static bool import_map_binds(const char **import_map_keys, int import_map_count,* specifier the tree's own manifests claim is treated exactly like a relative* one. NULL disables the check and restores the specifier-shape-only contract.*+ * `declared_packages` closes the same hole for the package-path languages,+ * where NO specifier shape says in-tree: `import+ * org.jetbrains.exposed.v1.tests.shared.assertEquals` is spelled exactly like+ * `import kotlin.test.assertEquals`, and only the tree's own `package`+ * declarations tell them apart. It is permissive by construction — any+ * specifier UNDER a declared package prefix counts as in-tree, see the note on+ * the walk — so it can leave a fabricated edge in place, never remove a real+ * one. NULL disables the check.+ ** Pure + side-effect-free so the contract is unit-testable without a pipeline. */bool cbm_suppress_external_import_shadow(const char *callee_name, const char *strategy,const CBMImportArray *file_imports,const char **import_map_keys, int import_map_count,- const CBMHashTable *indexed_packages) {+ const CBMHashTable *indexed_packages,+ const CBMHashTable *declared_packages) {if (!callee_name || !callee_name[0] || !strategy || !strategy[0]) {return false;}@@ -640,7 +728,8 @@ bool cbm_suppress_external_import_shadow(const char *callee_name, const char *stcontinue;}if (specifier_is_relative(imp->module_path) ||- specifier_names_indexed_package(indexed_packages, imp->module_path)) {+ specifier_names_indexed_package(indexed_packages, imp->module_path) ||+ specifier_names_declared_package(declared_packages, imp->module_path)) {return false; /* an in-tree binding for this name — never suppress */}external_binding = true;diff --git a/tests/test_pipeline.c b/tests/test_pipeline.cindex f772acc69..36bb243a3 100644--- a/tests/test_pipeline.c+++ b/tests/test_pipeline.c@@ -5222,6 +5222,132 @@ TEST(pipeline_external_import_shadow_keeps_workspace_sibling_issue1355) {PASS();}+/* #1355: the same tree once more, in a package-path language. A Kotlin/Java+ * specifier is a dotted package path whether the package is the project's own+ * or a dependency, so specifier shape decides nothing and the package map only+ * knows manifest artifact names. The tree's own `package` declarations are the+ * evidence, and the pipeline already collects them (the namespace map the+ * import passes build). `assertEquals` is imported twice — from the project's+ * package and from kotlin.test — exactly as JetBrains/Exposed writes it, which+ * is what leaves the import map without a key and hands the call to the+ * project-wide guess. */+static void write_declared_package_shadow_fixture(const char *dir, int pad_files) {+ /* One directory level only — write_temp_file's mkdir does not recurse, and+ * a deeper path fails silently. The package path lives in the `package`+ * declaration, not in the directory layout, which is the whole point. */+ write_temp_file(dir, "util/Assert.kt",+ "package com.example.util\n"+ "\n"+ "fun pkgEq(a: String, b: String): Boolean {\n"+ " return a == b\n"+ "}\n");+ /* The lone project symbol named pkgSpec, in a third package so the guess+ * that reaches it is a project-wide one and not a same-module hit. */+ write_temp_file(dir, "spec/SpecHelpers.kt",+ "package com.example.spec\n"+ "\n"+ "fun pkgSpec(label: String): Boolean {\n"+ " return label.isNotEmpty()\n"+ "}\n");+ write_temp_file(dir, "app/Query.kt",+ "package com.example.app\n"+ "\n"+ "import com.example.util.pkgEq\n"+ "import kotlin.test.pkgEq\n"+ "import kotlin.test.pkgSpec\n"+ "import org.junit.pkgSpec\n"+ "\n"+ "fun pkgBuild(id: String): Boolean {\n"+ " return pkgEq(id, id) && pkgSpec(id)\n"+ "}\n");+ for (int i = 0; i < pad_files; i++) {+ char name[64];+ char body[128];+ snprintf(name, sizeof(name), "app/Pad%02d.kt", i);+ snprintf(body, sizeof(body),+ "package com.example.app\n\nfun pkgPad%02d(): Int {\n return %d\n}\n", i, i);+ write_temp_file(dir, name, body);+ }+}++static int assert_declared_package_shadow_contract(const char *dir, const char *db_name) {+ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/%s", dir, db_name);+ cbm_pipeline_t *p = cbm_pipeline_new(dir, db_path, CBM_MODE_FULL);+ if (!p) {+ return 1;+ }+ if (cbm_pipeline_run(p) != 0) {+ cbm_pipeline_free(p);+ return 2;+ }+ const char *project = cbm_pipeline_project_name(p);+ cbm_store_t *s = cbm_store_open_path(db_path);+ if (!s) {+ cbm_pipeline_free(p);+ return 3;+ }+ int rc = 0;+ /* The package the tree declares: `com.example.util` is in-project, so the+ * call keeps its edge. RED without the declared-package check — this is the+ * 426-edge class measured on JetBrains/Exposed.+ *+ * The matching negative — an undeclared package is still cut — is asserted+ * where it can be reached on BOTH resolvers: directly on the predicate in+ * test_registry.c (external_import_shadow_declared_package_kept, including+ * `java.net.URL`), and end-to-end in the route fixture below. The+ * sequential resolver builds its own import map straight from the+ * extraction records, without the ambiguity check its parallel twin+ * applies, so a doubly-imported Kotlin name resolves by `import_map` there+ * and never reaches this guard at all — asserting the negative here would+ * assert that quirk, not this contract. */+ if (!cross_file_call_exists(s, project, "pkgBuild", "pkgEq")) {+ rc = 4;+ }+ cbm_store_close(s);+ cbm_pipeline_free(p);+ return rc;+}++TEST(pipeline_external_import_shadow_keeps_declared_package_issue1355) {+ char tmp[256];+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_pkg_import_shadow_XXXXXX");+ if (!cbm_mkdtemp(tmp)) {+ FAIL("tmpdir");+ }+ write_declared_package_shadow_fixture(tmp, EXTERNAL_IMPORT_SHADOW_PARALLEL_PAD);++ const char *old_workers = getenv("CBM_WORKERS");+ char *saved_workers = old_workers ? strdup(old_workers) : NULL;+ const char *old_single = getenv("CBM_INDEX_SINGLE_THREAD");+ char *saved_single = old_single ? strdup(old_single) : NULL;++ cbm_setenv("CBM_INDEX_SINGLE_THREAD", "1", 1);+ int sequential = assert_declared_package_shadow_contract(tmp, "pkg-sequential.db");++ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");+ cbm_setenv("CBM_WORKERS", "4", 1);+ int parallel = assert_declared_package_shadow_contract(tmp, "pkg-parallel.db");++ if (saved_workers) {+ cbm_setenv("CBM_WORKERS", saved_workers, 1);+ free(saved_workers);+ } else {+ cbm_unsetenv("CBM_WORKERS");+ }+ if (saved_single) {+ cbm_setenv("CBM_INDEX_SINGLE_THREAD", saved_single, 1);+ free(saved_single);+ } else {+ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");+ }+ th_rmtree(tmp);++ ASSERT_EQ(sequential, 0);+ ASSERT_EQ(parallel, 0);+ PASS();+}+TEST(pipeline_tsjs_receiver_parallel_keeps_service_edges) {char tmp[256];snprintf(tmp, sizeof(tmp), "/tmp/cbm_tsjs_par_XXXXXX");@@ -13572,6 +13698,7 @@ SUITE(pipeline) {RUN_TEST(pipeline_python_bare_local_binding_parallel_suppresses_weak_edge);RUN_TEST(pipeline_external_import_shadow_not_bound_to_local_homonym_issue1355);RUN_TEST(pipeline_external_import_shadow_keeps_workspace_sibling_issue1355);+ RUN_TEST(pipeline_external_import_shadow_keeps_declared_package_issue1355);RUN_TEST(pipeline_parallel_python_cross_only_dunder_gets_synthetic_carrier);RUN_TEST(pipeline_parallel_rust_cross_only_macro_hidden_gets_synthetic_carrier);RUN_TEST(pipeline_arg_url_rejects_non_http_slash_arguments);diff --git a/tests/test_registry.c b/tests/test_registry.cindex d8494ce82..d12048d83 100644--- a/tests/test_registry.c+++ b/tests/test_registry.c@@ -986,14 +986,19 @@ TEST(external_import_shadow_drops_package_bound_bare_call) {/* Only the relative import materialized an IMPORTS edge. */const char *keys[] = {"users"};- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, keys, 1, NULL));- ASSERT_TRUE(cbm_suppress_external_import_shadow("sql", "unique_name", &arr, keys, 1, NULL));- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "suffix_match", &arr, keys, 1, NULL));- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "field_type_hint", &arr, keys, 1, NULL));- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "fuzzy", &arr, keys, 1, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, keys, 1, NULL, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("sql", "unique_name", &arr, keys, 1, NULL, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "suffix_match", &arr, keys, 1, NULL, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "field_type_hint", &arr, keys, 1, NULL, NULL));+ ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "fuzzy", &arr, keys, 1, NULL, NULL));/* A file whose imports all failed to materialize is still covered: the* evidence is the import statement, not the map. */- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL, NULL));PASS();}@@ -1011,42 +1016,47 @@ TEST(external_import_shadow_keeps_everything_else) {const int nkeys = 2;/* Import-/receiver-/module-aware strategies are never this guard's business. */- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "import_map", &arr, keys, nkeys, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq", "import_map_suffix", &arr, keys, nkeys, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "same_module", &arr, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow("eq", "import_map", &arr, keys, nkeys, NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "import_map_suffix", &arr, keys, nkeys,+ NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq", "qualified_suffix", &arr, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow("eq", "same_module", &arr, keys, nkeys, NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "qualified_suffix", &arr, keys, nkeys,+ NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq", "lsp_ts_import", &arr, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow("eq", "lsp_ts_import", &arr, keys, nkeys, NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq", "lsp_ts_method", &arr, keys, nkeys, NULL));- ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq", "service_pattern", &arr, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow("eq", "lsp_ts_method", &arr, keys, nkeys, NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "service_pattern", &arr, keys, nkeys,+ NULL, NULL));/* A relative specifier names a path inside the tree — a missing IMPORTS edge* there is an in-project gap, not an external binding. */+ ASSERT_FALSE(cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, keys, nkeys,+ NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, keys, nkeys, NULL));- ASSERT_FALSE(- cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, NULL, 0, NULL));+ cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, NULL, 0, NULL, NULL));/* A package the import map DOES bind resolved in-graph (workspace package). */ASSERT_FALSE(cbm_suppress_external_import_shadow("getRootContainer", "unique_name", &arr, keys,- nkeys, NULL));+ nkeys, NULL, NULL));/* A name the file never imports (called with no import at all). */- ASSERT_FALSE(- cbm_suppress_external_import_shadow("helper", "unique_name", &arr, keys, nkeys, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("helper", "unique_name", &arr, keys, nkeys,+ NULL, NULL));/* Member and package/namespace-qualified callees belong to the* receiver-aware guards, not to this one. */+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq.apply", "unique_name", &arr, keys, nkeys,+ NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq::apply", "unique_name", &arr, keys, nkeys,+ NULL, NULL));+ /* Empty / absent inputs. */+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", NULL, &arr, keys, nkeys, NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "", &arr, keys, nkeys, NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq.apply", "unique_name", &arr, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow(NULL, "unique_name", &arr, keys, nkeys, NULL, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("eq::apply", "unique_name", &arr, keys, nkeys, NULL));- /* Empty / absent inputs. */- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", NULL, &arr, keys, nkeys, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "", &arr, keys, nkeys, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow(NULL, "unique_name", &arr, keys, nkeys, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("", "unique_name", &arr, keys, nkeys, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", NULL, keys, nkeys, NULL));+ cbm_suppress_external_import_shadow("", "unique_name", &arr, keys, nkeys, NULL, NULL));+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("eq", "unique_name", NULL, keys, nkeys, NULL, NULL));PASS();}@@ -1065,8 +1075,8 @@ TEST(external_import_shadow_relative_binding_wins_the_tie) {};CBMImportArray a = {.items = pkg_first, .count = 2, .cap = 2};CBMImportArray b = {.items = rel_first, .count = 2, .cap = 2};- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &a, NULL, 0, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &b, NULL, 0, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &a, NULL, 0, NULL, NULL));+ ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &b, NULL, 0, NULL, NULL));PASS();}@@ -1089,10 +1099,12 @@ TEST(external_import_shadow_windows_relative_specifier_kept) {* keep the edge because it is in-tree, not external. RED before the fix* (specifier_is_relative saw '.' / '/' only, so all three were classified* external and suppressed); GREEN after. */- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL));- ASSERT_FALSE(cbm_suppress_external_import_shadow("sql", "unique_name", &arr, NULL, 0, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, NULL, 0, NULL));+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL, NULL));+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("sql", "unique_name", &arr, NULL, 0, NULL, NULL));+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("normalize", "unique_name", &arr, NULL, 0, NULL, NULL));/* A bare package specifier without any drive letter or leading separator* (e.g. "drizzle-orm") must still be external — this predicate must not* become "anything with a colon or backslash". */@@ -1100,7 +1112,8 @@ TEST(external_import_shadow_windows_relative_specifier_kept) {{.local_name = "eq", .module_path = "drizzle-orm"},};CBMImportArray parr = {.items = pkg_only, .count = 1, .cap = 1};- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "unique_name", &parr, NULL, 0, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "unique_name", &parr, NULL, 0, NULL, NULL));PASS();}@@ -1127,33 +1140,140 @@ TEST(external_import_shadow_workspace_sibling_kept) {/* Exact name, subpath, and scoped subpath all resolve to an in-tree* package — the same-name fallback keeps its chance. */- ASSERT_FALSE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, pkgs));ASSERT_FALSE(- cbm_suppress_external_import_shadow("pgTable", "suffix_match", &arr, NULL, 0, pkgs));+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, pkgs, NULL));+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("pgTable", "suffix_match", &arr, NULL, 0, pkgs, NULL));ASSERT_FALSE(- cbm_suppress_external_import_shadow("hoisted", "unique_name", &arr, NULL, 0, pkgs));+ cbm_suppress_external_import_shadow("hoisted", "unique_name", &arr, NULL, 0, pkgs, NULL));/* A genuine third-party dependency is untouched by the new check: the tree* declares no package called "vitest", so the #1355 removal still happens. */- ASSERT_TRUE(cbm_suppress_external_import_shadow("test", "suffix_match", &arr, NULL, 0, pkgs));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("test", "suffix_match", &arr, NULL, 0, pkgs, NULL));/* A tree with no manifests at all (pkgmap NULL) keeps the pre-existing* specifier-shape-only contract — every one of these is external again. */- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL));ASSERT_TRUE(- cbm_suppress_external_import_shadow("pgTable", "suffix_match", &arr, NULL, 0, NULL));+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, NULL, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("pgTable", "suffix_match", &arr, NULL, 0, NULL, NULL));/* An unrelated package map must not accidentally match by prefix: "drizzle"* is not "drizzle-orm", and the walk is by path segment, not by substring. */CBMHashTable *other = cbm_ht_create(8);ASSERT_NOT_NULL(other);cbm_ht_set(other, "drizzle", (void *)"qn");- ASSERT_TRUE(cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, other));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("eq", "unique_name", &arr, NULL, 0, other, NULL));cbm_ht_free(other);cbm_ht_free(pkgs);PASS();}+TEST(external_import_shadow_declared_package_kept) {+ /* #1355: package-path specifiers (Java, Kotlin, C#, PHP) carry NO shape+ * that separates in-tree from third-party — `import+ * org.jetbrains.exposed.v1.tests.shared.assertEquals` is spelled exactly+ * like `import kotlin.test.assertEquals`, and neither is "relative". Only+ * the tree's own `package` declarations tell them apart; the manifests the+ * package map reads (pom.xml, build.gradle) name artifacts, not packages.+ * Measured on JetBrains/Exposed at 0e4d81a4: without this check the guard+ * removed 426 CALLS edges, every one of them a real in-project call into+ * the repository's own Assert.kt. */+ CBMImport imports[] = {+ {.local_name = "assertEquals", .module_path = "org.example.tests.shared.assertEquals"},+ {.local_name = "assertEquals", .module_path = "kotlin.test.assertEquals"},+ {.local_name = "Helper", .module_path = "org.example.util.Helper"},+ {.local_name = "URL", .module_path = "java.net.URL"},+ {.local_name = "Logger", .module_path = "App\\Support\\Logger"},+ };+ CBMImportArray arr = {.items = imports, .count = 5, .cap = 5};++ CBMHashTable *nspkgs = cbm_ht_create(8);+ ASSERT_NOT_NULL(nspkgs);+ cbm_ht_set(nspkgs, "org.example.tests.shared", (void *)"qn");+ cbm_ht_set(nspkgs, "org.example.util", (void *)"qn");+ cbm_ht_set(nspkgs, "App.Support", (void *)"qn");++ /* The specifier names a member of a package the tree declares, so the walk+ * strips the member segment and finds it — the call keeps its edge. */+ ASSERT_FALSE(cbm_suppress_external_import_shadow("assertEquals", "suffix_match", &arr, NULL, 0,+ NULL, nspkgs));+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("Helper", "unique_name", &arr, NULL, 0, NULL, nspkgs));+ /* PHP writes its separator as a backslash; the key normalization has to+ * match the namespace map's, which stores dots. */+ ASSERT_FALSE(+ cbm_suppress_external_import_shadow("Logger", "unique_name", &arr, NULL, 0, NULL, nspkgs));+ /* Negative space, and the effect the census called valuable: `java.net.URL`+ * walks to "java.net" then "java", neither declared by any project file, so+ * a bare `URL` bound to an in-tree URL class is still cut. */+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("URL", "suffix_match", &arr, NULL, 0, NULL, nspkgs));+ /* NULL restores the previous contract: without the declared-package set+ * every one of these reads as external again. */+ ASSERT_TRUE(cbm_suppress_external_import_shadow("assertEquals", "suffix_match", &arr, NULL, 0,+ NULL, NULL));+ ASSERT_TRUE(+ cbm_suppress_external_import_shadow("Helper", "unique_name", &arr, NULL, 0, NULL, NULL));++ /* The walk is by dotted segment, not by substring: a tree that declares+ * "org.example.tests" must not claim "org.example.testsuite.helper". */+ CBMImport near[] = {+ {.local_name = "near", .module_path = "org.example.testsuite.helper.near"},+ };+ CBMImportArray narr = {.items = near, .count = 1, .cap = 1};+ CBMHashTable *prefix_only = cbm_ht_create(8);+ ASSERT_NOT_NULL(prefix_only);+ cbm_ht_set(prefix_only, "org.example.tests", (void *)"qn");+ ASSERT_TRUE(cbm_suppress_external_import_shadow("near", "unique_name", &narr, NULL, 0, NULL,+ prefix_only));++ cbm_ht_free(prefix_only);+ cbm_ht_free(nspkgs);+ PASS();+}++TEST(external_import_shadow_declared_prefix_is_permissive) {+ /* #1355, known limitation pinned deliberately. The declared-package walk+ * has no floor: once the tree declares `com.example`, a third-party+ * library publishing under `com.example.vendor` reads as in-tree and the+ * guard stands down. The call then keeps exactly the edge it has on main,+ * so this direction costs a fabricated edge the guard could have removed —+ * it never removes a real one, which is the side a call-resolution+ * suppressor has to fail on.+ *+ * This test exists so the behaviour cannot change silently: tightening the+ * walk (stopping at the first type-shaped segment, say) must flip these+ * two assertions, not slip through unnoticed. */+ CBMImport imports[] = {+ {.local_name = "vendorCall", .module_path = "com.example.vendor.pkg.vendorCall"},+ };+ CBMImportArray arr = {.items = imports, .count = 1, .cap = 1};++ CBMHashTable *declares_prefix = cbm_ht_create(8);+ ASSERT_NOT_NULL(declares_prefix);+ cbm_ht_set(declares_prefix, "com.example", (void *)"qn");+ /* The tree declares only the prefix, yet the whole subtree is treated as+ * in-tree — the permissive direction. */+ ASSERT_FALSE(cbm_suppress_external_import_shadow("vendorCall", "unique_name", &arr, NULL, 0,+ NULL, declares_prefix));++ /* Change nothing but the declared package and the guard fires again, which+ * is what proves the previous assertion came from the prefix walk and not+ * from some other clause standing down. */+ CBMHashTable *declares_other = cbm_ht_create(8);+ ASSERT_NOT_NULL(declares_other);+ cbm_ht_set(declares_other, "com.other", (void *)"qn");+ ASSERT_TRUE(cbm_suppress_external_import_shadow("vendorCall", "unique_name", &arr, NULL, 0,+ NULL, declares_other));++ cbm_ht_free(declares_other);+ cbm_ht_free(declares_prefix);+ PASS();+}+/* ── Suite ─────────────────────────────────────────────────────── *//* Method call THROUGH an imported symbol that is itself an indexed node@@ -1258,4 +1378,6 @@ SUITE(registry) {RUN_TEST(external_import_shadow_relative_binding_wins_the_tie);RUN_TEST(external_import_shadow_windows_relative_specifier_kept);RUN_TEST(external_import_shadow_workspace_sibling_kept);+ RUN_TEST(external_import_shadow_declared_package_kept);+ RUN_TEST(external_import_shadow_declared_prefix_is_permissive);}