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(python): a per-file def selection follows package re-exports

Martin Vogel0ae936f053b1
diff --git a/src/pipeline/pass_lsp_cross.c b/src/pipeline/pass_lsp_cross.c
index 42b9fba9b..e6807413f 100644
--- a/src/pipeline/pass_lsp_cross.c
+++ b/src/pipeline/pass_lsp_cross.c
@@ -2774,6 +2774,123 @@ void cbm_pxc_free_module_def_index(CBMModuleDefIndex *idx) {
free(idx);
}
+/* A Python namespace record that points at another module (a re-export or a
+ * star import; `__all__` points nowhere). */
+static bool pxc_is_py_reexport_record(const CBMLSPDef *d) {
+ return d->lang == CBM_LANG_PYTHON && d->label && d->receiver_type &&
+ (strcmp(d->label, "PyReexport") == 0 || strcmp(d->label, "PyStarImport") == 0);
+}
+
+/* The index entry of the Python module `qn` (a module file, or a package via
+ * its `__init__`), or NULL. */
+static const pxc_module_entry_t *pxc_py_module_entry(const CBMModuleDefIndex *idx, const char *qn,
+ size_t len) {
+ char key[CBM_SZ_1K];
+ if (len + sizeof(".__init__") > sizeof(key))
+ return NULL;
+ memcpy(key, qn, len);
+ key[len] = '\0';
+ const pxc_module_entry_t *e = (const pxc_module_entry_t *)cbm_ht_get(idx->ht, key);
+ if (e)
+ return e;
+ memcpy(key + len, ".__init__", sizeof(".__init__"));
+ return (const pxc_module_entry_t *)cbm_ht_get(idx->ht, key);
+}
+
+/* The entry of the module `spec` names from inside the module `module_qn`:
+ * a relative spec (leading dots) against that module's package, exactly; an
+ * absolute spec under the longest prefix of module_qn that has it (the
+ * project and any source root precede the import path). `member`, when set,
+ * also names a submodule (`from . import base`). NULL when nothing matches. */
+static const pxc_module_entry_t *pxc_py_spec_entry(const CBMModuleDefIndex *idx,
+ const char *module_qn, const char *spec,
+ const char *member) {
+ char qn[CBM_SZ_1K];
+ size_t level = strspn(spec, ".");
+ const char *rest = spec + level;
+ if (level > 0) {
+ size_t base = strlen(module_qn); /* drop the module's own segment first */
+ for (size_t up = 0; up < level; up++) {
+ while (base > 0 && module_qn[base - 1] != '.')
+ base--;
+ if (base == 0)
+ return NULL;
+ base--;
+ }
+ int n = rest[0] ? snprintf(qn, sizeof(qn), "%.*s.%s", (int)base, module_qn, rest)
+ : snprintf(qn, sizeof(qn), "%.*s", (int)base, module_qn);
+ if (n < 0 || (size_t)n >= sizeof(qn))
+ return NULL;
+ const pxc_module_entry_t *e = pxc_py_module_entry(idx, qn, (size_t)n);
+ if (!e && member) {
+ int m = snprintf(qn + n, sizeof(qn) - (size_t)n, ".%s", member);
+ if (m > 0 && (size_t)(n + m) < sizeof(qn))
+ e = pxc_py_module_entry(idx, qn, (size_t)(n + m));
+ }
+ return e;
+ }
+ for (size_t cut = strlen(module_qn); cut > 0; cut--) {
+ if (module_qn[cut - 1] != '.')
+ continue;
+ int n = snprintf(qn, sizeof(qn), "%.*s%s", (int)cut, module_qn, rest);
+ if (n < 0 || (size_t)n >= sizeof(qn))
+ continue;
+ const pxc_module_entry_t *e = pxc_py_module_entry(idx, qn, (size_t)n);
+ if (e)
+ return e;
+ }
+ return NULL;
+}
+
+/* A per-file selection holds the defs of the caller's own and imported
+ * modules. A Python package that re-exports a name keeps only the record;
+ * the definition lives in the module the record points at, possibly through
+ * further re-exports. Select those modules' defs too, following every
+ * selected record once (a worklist over def indices: linear in the defs it
+ * reaches), so the per-file LSP can fold the chain as the shared registry
+ * does. */
+static void pxc_mark_reexport_targets(const CBMModuleDefIndex *idx, bool *selected,
+ const CBMLSPDef *all_defs, int *total) {
+ int cap = idx->def_count;
+ int *work = (int *)cbm_alloc(CBM_MEM_CLASS_EXTRACT, (size_t)cap * sizeof(int));
+ bool *queued = (bool *)cbm_calloc(CBM_MEM_CLASS_EXTRACT, (size_t)cap * sizeof(bool));
+ if (!work || !queued) {
+ cbm_free(CBM_MEM_CLASS_EXTRACT, work);
+ cbm_free(CBM_MEM_CLASS_EXTRACT, queued);
+ return;
+ }
+ int n = 0;
+ for (int i = 0; i < cap; i++) {
+ if (selected[i] && pxc_is_py_reexport_record(&all_defs[i])) {
+ queued[i] = true;
+ work[n++] = i;
+ }
+ }
+ for (int w = 0; w < n; w++) {
+ const CBMLSPDef *r = &all_defs[work[w]];
+ bool star = strcmp(r->label, "PyStarImport") == 0;
+ const pxc_module_entry_t *e =
+ r->def_module_qn ? pxc_py_spec_entry(idx, r->def_module_qn, r->receiver_type,
+ star ? NULL : r->method_names_str)
+ : NULL;
+ for (int j = 0; e && j < e->count; j++) {
+ int di = e->indices[j];
+ if (di < 0 || di >= cap || all_defs[di].lang != CBM_LANG_PYTHON)
+ continue;
+ if (!selected[di]) {
+ selected[di] = true;
+ (*total)++;
+ }
+ if (!queued[di] && pxc_is_py_reexport_record(&all_defs[di])) {
+ queued[di] = true;
+ work[n++] = di;
+ }
+ }
+ }
+ cbm_free(CBM_MEM_CLASS_EXTRACT, work);
+ cbm_free(CBM_MEM_CLASS_EXTRACT, queued);
+}
+
CBMLSPDef *cbm_pxc_filter_defs_for_file(const CBMModuleDefIndex *idx, CBMLSPDef *all_defs,
CBMLanguage caller_lang, const char *caller_namespace,
const char *own_module, const char *const *imp_qns,
@@ -2806,6 +2923,9 @@ CBMLSPDef *cbm_pxc_filter_defs_for_file(const CBMModuleDefIndex *idx, CBMLSPDef
pxc_module_entry_t *e = (pxc_module_entry_t *)cbm_ht_get(idx->namespace_ht, namespace_key);
total += pxc_mark_entry_defs(selected, e, all_defs, caller_lang);
}
+ if (caller_lang == CBM_LANG_PYTHON) {
+ pxc_mark_reexport_targets(idx, selected, all_defs, &total);
+ }
if (total == 0) {
cbm_free(CBM_MEM_CLASS_EXTRACT, selected);