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(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.c
index 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.c
index 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_t
create_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.c
index 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_t
cbm_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.c
index 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.h
index 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 #1572
diff --git a/src/pipeline/pipeline_incremental.c b/src/pipeline/pipeline_incremental.c
index 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.h
index 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 *c
CBMHashTable *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.c
index 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_packages
return 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 *st
continue;
}
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.c
index 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.c
index 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);
}