Skip to content

Commit f3bcb25

Browse files
committed
fix(registry): restrict same-module and unique-name suffix matches on receivers
Tighten call resolution precision in the registry: - Validate receiver prefixes in resolve_same_module: allow self receivers, exact module names, and namespace prefixes, while rejecting unrelated local function bindings (e.g. axios.get). - Preserve Go flat receiver dispatch (e.g. c.Area()) and qualified attribute chains in the same module. - In unique-name and suffix-match strategies, reject receiver mismatches when the callee targets a Function (not a Method), or when targeting a Method and the receiver is an imported alias or known Module/Class/Type that contradicts the candidate target. - Preserve resolution for untyped instance receivers (e.g. vm.load, c.val()) and builtins (e.g. builtins.dict.get). - Add unit test coverage in test_registry.c. Signed-off-by: sahil-mangla <[email protected]>
1 parent 9f85f10 commit f3bcb25

2 files changed

Lines changed: 334 additions & 29 deletions

File tree

‎src/pipeline/registry.c‎

Lines changed: 235 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1464,13 +1464,67 @@ static const char *same_module_candidate(const cbm_registry_t *r, const char *mo
14641464
return NULL;
14651465
}
14661466

1467+
static bool is_self_receiver(const char *prefix) {
1468+
if (!prefix || !prefix[0]) {
1469+
return true;
1470+
}
1471+
static const char *const self_receivers[] = {"self", "this", "cls", "@self", "$this",
1472+
"$self", "Me", "me", "Self", NULL};
1473+
for (int i = 0; self_receivers[i]; i++) {
1474+
if (strcmp(prefix, self_receivers[i]) == 0) {
1475+
return true;
1476+
}
1477+
}
1478+
return false;
1479+
}
1480+
1481+
static bool is_same_module_receiver(const char *prefix, const char *module_qn) {
1482+
if (is_self_receiver(prefix)) {
1483+
return true;
1484+
}
1485+
if (!module_qn || !module_qn[0]) {
1486+
return false;
1487+
}
1488+
char norm_prefix[CBM_SZ_256];
1489+
size_t plen = strlen(prefix);
1490+
if (plen >= sizeof(norm_prefix)) {
1491+
plen = sizeof(norm_prefix) - 1;
1492+
}
1493+
size_t j = 0;
1494+
for (size_t i = 0; i < plen && j + 1 < sizeof(norm_prefix); i++) {
1495+
if (prefix[i] == ':' && i + 1 < plen && prefix[i + 1] == ':') {
1496+
norm_prefix[j++] = '.';
1497+
i++;
1498+
} else {
1499+
norm_prefix[j++] = prefix[i];
1500+
}
1501+
}
1502+
norm_prefix[j] = '\0';
1503+
1504+
if (strcmp(norm_prefix, module_qn) == 0) {
1505+
return true;
1506+
}
1507+
size_t nlen = strlen(norm_prefix);
1508+
size_t mlen = strlen(module_qn);
1509+
if (mlen > nlen && module_qn[mlen - nlen - 1] == '.' &&
1510+
strcmp(module_qn + (mlen - nlen), norm_prefix) == 0) {
1511+
return true;
1512+
}
1513+
return false;
1514+
}
1515+
14671516
/* Strategy 2: Same-module match. Scoring elsewhere retains the raw file QN. */
14681517
static cbm_resolution_t resolve_same_module(const cbm_registry_t *r, const char *callee_name,
1469-
const char *suffix, const char *module_qn,
1470-
size_t scope_len) {
1518+
const char *prefix, const char *suffix,
1519+
const char *module_qn, size_t scope_len,
1520+
CBMLanguage lang) {
14711521
const char *stored_key = same_module_candidate(r, module_qn, scope_len, callee_name);
1472-
if (!stored_key && suffix && suffix[0])
1473-
stored_key = same_module_candidate(r, module_qn, scope_len, suffix);
1522+
if (!stored_key && suffix && suffix[0]) {
1523+
if (lang == CBM_LANG_GO || is_same_module_receiver(prefix, module_qn) ||
1524+
strchr(suffix, '.') != NULL || strstr(suffix, "::") != NULL) {
1525+
stored_key = same_module_candidate(r, module_qn, scope_len, suffix);
1526+
}
1527+
}
14741528
if (stored_key)
14751529
return (cbm_resolution_t){stored_key, "same_module", CONF_SAME_MODULE, REG_RESOLVED};
14761530
return empty_result();
@@ -1699,10 +1753,143 @@ static void candidates_without_members(const cbm_registry_t *r, const qn_array_t
16991753
.lang = side ? lang : NULL};
17001754
}
17011755

1756+
static bool qn_ends_with_qualified(const char *candidate_qn, const char *callee_name) {
1757+
if (!candidate_qn || !callee_name) {
1758+
return false;
1759+
}
1760+
char norm_callee[CBM_SZ_256];
1761+
size_t clen = strlen(callee_name);
1762+
if (clen >= sizeof(norm_callee)) {
1763+
clen = sizeof(norm_callee) - 1;
1764+
}
1765+
size_t j = 0;
1766+
for (size_t i = 0; i < clen && j + 1 < sizeof(norm_callee); i++) {
1767+
if (callee_name[i] == ':' && i + 1 < clen && callee_name[i + 1] == ':') {
1768+
norm_callee[j++] = '.';
1769+
i++;
1770+
} else {
1771+
norm_callee[j++] = callee_name[i];
1772+
}
1773+
}
1774+
norm_callee[j] = '\0';
1775+
1776+
size_t nlen = strlen(norm_callee);
1777+
size_t qlen = strlen(candidate_qn);
1778+
if (qlen < nlen) {
1779+
return false;
1780+
}
1781+
if (strcmp(candidate_qn, norm_callee) == 0) {
1782+
return true;
1783+
}
1784+
if (qlen > nlen && candidate_qn[qlen - nlen - 1] == '.' &&
1785+
strcmp(candidate_qn + (qlen - nlen), norm_callee) == 0) {
1786+
return true;
1787+
}
1788+
return false;
1789+
}
1790+
1791+
static bool is_builtin_candidate(const char *qn) {
1792+
if (!qn) {
1793+
return false;
1794+
}
1795+
return strncmp(qn, "builtins.", 9) == 0 || strncmp(qn, "<python-builtins>.", 18) == 0 ||
1796+
strncmp(qn, "<kotlin-builtins>.", 18) == 0;
1797+
}
1798+
1799+
static bool is_candidate_method(const cbm_registry_t *r, const char *qn) {
1800+
const char *label = cbm_registry_label_of(r, qn);
1801+
return label && strcmp(label, "Method") == 0;
1802+
}
1803+
1804+
static bool is_imported_receiver(const char *prefix, const char **import_keys, int import_count) {
1805+
if (!prefix || !import_keys || import_count <= 0) {
1806+
return false;
1807+
}
1808+
for (int i = 0; i < import_count; i++) {
1809+
if (import_keys[i] && strcmp(import_keys[i], prefix) == 0) {
1810+
return true;
1811+
}
1812+
}
1813+
return false;
1814+
}
1815+
1816+
static bool is_known_type_or_namespace(const cbm_registry_t *r, const char *name) {
1817+
if (!r || !name || !name[0]) {
1818+
return false;
1819+
}
1820+
const char *exact_label = cbm_registry_label_of(r, name);
1821+
if (exact_label &&
1822+
(strcmp(exact_label, "Class") == 0 || strcmp(exact_label, "Module") == 0 ||
1823+
strcmp(exact_label, "Namespace") == 0 || strcmp(exact_label, "Struct") == 0 ||
1824+
strcmp(exact_label, "Interface") == 0 || strcmp(exact_label, "Enum") == 0 ||
1825+
strcmp(exact_label, "Package") == 0)) {
1826+
return true;
1827+
}
1828+
const qn_array_t *arr = cbm_ht_get(r->by_name, name);
1829+
if (!arr) {
1830+
return false;
1831+
}
1832+
for (int i = 0; i < arr->count; i++) {
1833+
const char *label = cbm_registry_label_of(r, arr->items[i]);
1834+
if (label && (strcmp(label, "Class") == 0 || strcmp(label, "Module") == 0 ||
1835+
strcmp(label, "Namespace") == 0 || strcmp(label, "Struct") == 0 ||
1836+
strcmp(label, "Interface") == 0 || strcmp(label, "Enum") == 0 ||
1837+
strcmp(label, "Package") == 0)) {
1838+
return true;
1839+
}
1840+
}
1841+
return false;
1842+
}
1843+
1844+
static bool should_reject_receiver(const cbm_registry_t *r, const char *callee_name,
1845+
const char *candidate_qn, const char **import_keys,
1846+
int import_count) {
1847+
if (!callee_name || !candidate_qn) {
1848+
return false;
1849+
}
1850+
const char *dot = strchr(callee_name, '.');
1851+
const char *colons = strstr(callee_name, "::");
1852+
const char *sep = dot;
1853+
if (colons && (!sep || colons < sep)) {
1854+
sep = colons;
1855+
}
1856+
if (!sep) {
1857+
return false;
1858+
}
1859+
char prefix[CBM_SZ_256];
1860+
size_t plen = (size_t)(sep - callee_name);
1861+
if (plen >= sizeof(prefix)) {
1862+
plen = sizeof(prefix) - 1;
1863+
}
1864+
memcpy(prefix, callee_name, plen);
1865+
prefix[plen] = '\0';
1866+
1867+
if (is_self_receiver(prefix)) {
1868+
return false;
1869+
}
1870+
if (is_builtin_candidate(candidate_qn)) {
1871+
return false;
1872+
}
1873+
if (qn_ends_with_qualified(candidate_qn, callee_name)) {
1874+
return false;
1875+
}
1876+
if (!is_candidate_method(r, candidate_qn)) {
1877+
return true;
1878+
}
1879+
if (is_imported_receiver(prefix, import_keys, import_count)) {
1880+
return true;
1881+
}
1882+
if (is_known_type_or_namespace(r, prefix)) {
1883+
return true;
1884+
}
1885+
return false;
1886+
}
1887+
17021888
/* Strategies 3.5, 3 and 4 over one same-name candidate set. */
17031889
static cbm_resolution_t resolve_name_candidates(const cbm_registry_t *r, const qn_array_t *arr,
17041890
const char *callee_name, const char *module_qn,
1705-
const char **import_vals, int import_count) {
1891+
const char **import_keys, const char **import_vals,
1892+
int import_count) {
17061893
/* Strategy 3.5: a qualified callee disambiguates among multiple same-name
17071894
* candidates by full qualified tail, before bare-name scoring collapses
17081895
* them onto a single winner. */
@@ -1718,6 +1905,9 @@ static cbm_resolution_t resolve_name_candidates(const cbm_registry_t *r, const q
17181905
if (!receiver_chain_admits(callee_name, arr->items[0])) {
17191906
return empty_result();
17201907
}
1908+
if (should_reject_receiver(r, callee_name, arr->items[0], import_keys, import_count)) {
1909+
return empty_result();
1910+
}
17211911
double conf = CONF_UNIQUE_NAME;
17221912
if (import_vals && import_count > 0 &&
17231913
!is_import_reachable(arr->items[0], import_vals, import_count)) {
@@ -1727,19 +1917,27 @@ static cbm_resolution_t resolve_name_candidates(const cbm_registry_t *r, const q
17271917
}
17281918

17291919
/* Strategy 4: multiple candidates */
1920+
cbm_resolution_t res;
17301921
if (import_vals && import_count > 0) {
1731-
return resolve_multi_with_imports(r, arr, module_qn, import_vals, import_count);
1732-
}
1733-
const char *best = best_by_import_distance(r, (const char **)arr->items, qn_test_flags(arr),
1734-
qn_lang_flags(arr), arr->count, module_qn);
1735-
if (best) {
1736-
if (!receiver_chain_admits(callee_name, best)) {
1737-
return empty_result();
1922+
res = resolve_multi_with_imports(r, arr, module_qn, import_vals, import_count);
1923+
} else {
1924+
const char *best = best_by_import_distance(r, (const char **)arr->items, qn_test_flags(arr),
1925+
qn_lang_flags(arr), arr->count, module_qn);
1926+
if (best) {
1927+
if (!receiver_chain_admits(callee_name, best)) {
1928+
return empty_result();
1929+
}
1930+
double conf = candidate_count_penalty(CONF_SUFFIX_MATCH, arr->count);
1931+
res = (cbm_resolution_t){best, "suffix_match", conf, arr->count};
1932+
} else {
1933+
res = empty_result();
17381934
}
1739-
double conf = candidate_count_penalty(CONF_SUFFIX_MATCH, arr->count);
1740-
return (cbm_resolution_t){best, "suffix_match", conf, arr->count};
17411935
}
1742-
return empty_result();
1936+
if (res.qualified_name &&
1937+
should_reject_receiver(r, callee_name, res.qualified_name, import_keys, import_count)) {
1938+
return empty_result();
1939+
}
1940+
return res;
17431941
}
17441942

17451943
/* Strategy 3+4: Name lookup + suffix match. skip_members: the callee cannot
@@ -1750,8 +1948,9 @@ static cbm_resolution_t resolve_name_candidates(const cbm_registry_t *r, const q
17501948
* 345 -> 9 callers (2026-10-13 graph audit). Dropping only the Fields made
17511949
* libc `read()` the unique name of a C++ adapter's Method instead. */
17521950
static cbm_resolution_t resolve_name_lookup(const cbm_registry_t *r, const char *callee_name,
1753-
const char *module_qn, const char **import_vals,
1754-
int import_count, bool skip_members) {
1951+
const char *module_qn, const char **import_keys,
1952+
const char **import_vals, int import_count,
1953+
bool skip_members) {
17551954
const char *lookup = simple_name(callee_name);
17561955
const qn_array_t *arr = cbm_ht_get(r->by_name, lookup);
17571956
if (!arr || arr->count == 0) {
@@ -1769,17 +1968,20 @@ static cbm_resolution_t resolve_name_lookup(const cbm_registry_t *r, const char
17691968
if (view.count == 0) {
17701969
return empty_result();
17711970
}
1772-
return resolve_name_candidates(r, &view, callee_name, module_qn, import_vals, import_count);
1971+
return resolve_name_candidates(r, &view, callee_name, module_qn, import_keys, import_vals,
1972+
import_count);
17731973
}
1774-
return resolve_name_candidates(r, arr, callee_name, module_qn, import_vals, import_count);
1974+
return resolve_name_candidates(r, arr, callee_name, module_qn, import_keys, import_vals,
1975+
import_count);
17751976
}
17761977

17771978
/* The strategy chain shared by both public resolve variants (no caching here —
17781979
* cbm_registry_resolve owns the per-file cache). */
17791980
static cbm_resolution_t registry_resolve_chain(const cbm_registry_t *r, const char *callee_name,
17801981
const char *module_qn, const char **import_map_keys,
17811982
const char **import_map_vals, int import_map_count,
1782-
size_t scope_len, bool skip_members) {
1983+
size_t scope_len, bool skip_members,
1984+
CBMLanguage lang) {
17831985
/* Split callee at the first path separator: "pkg.Func" → prefix="pkg",
17841986
* suffix="Func". Rust/C++ use "::" rather than ".", so honor whichever
17851987
* separator appears first ("lib::square" → prefix="lib", suffix="square").
@@ -1812,12 +2014,12 @@ static cbm_resolution_t registry_resolve_chain(const cbm_registry_t *r, const ch
18122014
resolve_import_map(r, prefix, suffix, import_map_keys, import_map_vals, import_map_count);
18132015
if (!(res.qualified_name && res.qualified_name[0])) {
18142016
/* Strategy 2: same module */
1815-
res = resolve_same_module(r, callee_name, suffix, module_qn, scope_len);
2017+
res = resolve_same_module(r, callee_name, prefix, suffix, module_qn, scope_len, lang);
18162018
}
18172019
if (!(res.qualified_name && res.qualified_name[0])) {
18182020
/* Strategy 3+4: name lookup */
1819-
res = resolve_name_lookup(r, callee_name, module_qn, import_map_vals, import_map_count,
1820-
skip_members);
2021+
res = resolve_name_lookup(r, callee_name, module_qn, import_map_keys, import_map_vals,
2022+
import_map_count, skip_members);
18212023
}
18222024
return res;
18232025
}
@@ -1868,7 +2070,8 @@ bool cbm_registry_name_guess_vetoed(const cbm_registry_t *r, CBMLanguage caller_
18682070
static cbm_resolution_t registry_resolve_scoped(const cbm_registry_t *r, const char *callee_name,
18692071
const char *module_qn, const char **import_map_keys,
18702072
const char **import_map_vals, int import_map_count,
1871-
size_t scope_len, bool skip_members) {
2073+
size_t scope_len, bool skip_members,
2074+
CBMLanguage lang) {
18722075
if (!r || !callee_name) {
18732076
return empty_result();
18742077
}
@@ -1883,7 +2086,7 @@ static cbm_resolution_t registry_resolve_scoped(const cbm_registry_t *r, const c
18832086

18842087
cbm_resolution_t res =
18852088
registry_resolve_chain(r, callee_name, module_qn, import_map_keys, import_map_vals,
1886-
import_map_count, scope_len, skip_members);
2089+
import_map_count, scope_len, skip_members, lang);
18872090

18882091
/* Data relations (Table/View) are lineage-only registry members: common
18892092
* table names (users, orders, config) collide with code identifiers across
@@ -1925,7 +2128,8 @@ cbm_resolution_t cbm_registry_resolve(const cbm_registry_t *r, const char *calle
19252128
const char *module_qn, const char **import_map_keys,
19262129
const char **import_map_vals, int import_map_count) {
19272130
return registry_resolve_scoped(r, callee_name, module_qn, import_map_keys, import_map_vals,
1928-
import_map_count, module_qn ? strlen(module_qn) : 0, false);
2131+
import_map_count, module_qn ? strlen(module_qn) : 0, false,
2132+
CBM_LANG_COUNT);
19292133
}
19302134

19312135
static size_t lang_scope_len(const char *module_qn, CBMLanguage lang) {
@@ -1938,7 +2142,7 @@ cbm_resolution_t cbm_registry_resolve_lang(const cbm_registry_t *r, const char *
19382142
const char **import_map_vals, int import_map_count,
19392143
CBMLanguage lang) {
19402144
return registry_resolve_scoped(r, callee_name, module_qn, import_map_keys, import_map_vals,
1941-
import_map_count, lang_scope_len(module_qn, lang), false);
2145+
import_map_count, lang_scope_len(module_qn, lang), false, lang);
19422146
}
19432147

19442148
cbm_resolution_t cbm_registry_resolve_call_lang(const cbm_registry_t *r, const char *callee_name,
@@ -1952,7 +2156,8 @@ cbm_resolution_t cbm_registry_resolve_call_lang(const cbm_registry_t *r, const c
19522156
bool skip_members = lang == CBM_LANG_C && callee_name && !strchr(callee_name, '.') &&
19532157
!strstr(callee_name, "->");
19542158
return registry_resolve_scoped(r, callee_name, module_qn, import_map_keys, import_map_vals,
1955-
import_map_count, lang_scope_len(module_qn, lang), skip_members);
2159+
import_map_count, lang_scope_len(module_qn, lang), skip_members,
2160+
lang);
19562161
}
19572162

19582163
/* ── Class-qualified route handlers (PHP, #1146) ─────────────────── */
@@ -2120,7 +2325,8 @@ cbm_resolution_t cbm_registry_resolve_lineage(const cbm_registry_t *r, const cha
21202325
* it would poison one variant with the other's semantics. SQL files hold
21212326
* few distinct relation refs, so the chain walk stays cheap. */
21222327
return registry_resolve_chain(r, callee_name, module_qn, import_map_keys, import_map_vals,
2123-
import_map_count, module_qn ? strlen(module_qn) : 0, false);
2328+
import_map_count, module_qn ? strlen(module_qn) : 0, false,
2329+
CBM_LANG_COUNT);
21242330
}
21252331

21262332
/* ── Fuzzy Resolve ──────────────────────────────────────────────── */

0 commit comments

Comments
 (0)