@@ -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. */
14681517static 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. */
17031889static 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. */
17521950static 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). */
17791980static 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_
18682070static 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
19312135static 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
19442148cbm_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