Park cross-repo member calls in C++, C# and Swift too (#3152)

The merge-time pass only had Java residue to work with, so a C++, C# or
Swift call whose receiver type lives in another repo was still dropped
with the type already in hand. Each of those three resolvers has the same
bail-out Java had — receiver typed, type declared nowhere in this corpus —
so each now parks the call by name for the merge to finish.

Two details the added languages force:

* Swift shares `all_raw_calls` with every other language and its raw_calls
  carry no `lang` tag, so the parked entry's language comes from the
  declaring file's suffix rather than from a tag that isn't there.
* C# collapses "absent", "ambiguous" and "scoping was decisive" into one
  `None` from `_resolve_type_name_nid`, and only the first is a cross-repo
  candidate, so the park re-checks the bare-name index instead of
  trusting the `None`.

On the merge side, a C++ class that only declares `void bar();` in a
header owns it through `defines`, not `method`, so the member index is
kept per relation: a C++ entry may fall back to `defines` when no
`method` of that name exists, and for every other language a `defines`
target is a field and cannot answer a call.

Tests cover a real two-repo build per language (both C++ receiver shapes),
the `defines` owner and its language restriction, the definition winning
over a same-named header declaration, and C++ not binding to a C# class
of the same name.

Author: xiongjianxu

graphify/cross_repo_calls.py

@@ -39,9 +39,17 @@
 # just as happily to a Python class of the same name in another repo. Extend this
 # map when another extractor starts parking calls.
 _LANG_SUFFIXES: dict[str, frozenset[str]] = {
+    "cpp": frozenset({".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx", ".h", ".cu", ".cuh"}),
+    "csharp": frozenset({".cs"}),
     "java": frozenset({".java"}),
+    "swift": frozenset({".swift"}),
 }
 
+# A declaration owns its members through a `method` edge, except in C++, where an
+# in-class declaration (`void bar();` in a header) is modelled as a field and
+# carries `defines` instead. `method` wins when both name the same member.
+_MEMBER_RELATIONS = ("defines", "method")
+
 
 def _key(label: object) -> str:
     """Normalize a node label or a parked name to its bare identifier.
@@ -97,17 +105,26 @@ def _index_declarations(merged: "nx.Graph") -> tuple[dict[str, list[str]], set[s
     return by_name, type_ids
 
 
-def _index_methods(merged: "nx.Graph", type_ids: set[str]) -> dict[tuple[str, str], list[str]]:
-    """Index each declaration's methods by name.
+def _index_members(
+    merged: "nx.Graph", type_ids: set[str]
+) -> dict[str, dict[tuple[str, str], list[str]]]:
+    """Index each declaration's members by relation, then by name.
 
     The merged graph is undirected, and a ``method`` edge carries no reliable
     direction once composed, so the owner is identified as the endpoint that is a
     type declaration. A nested declaration puts a type on both ends; that pair is
     skipped rather than guessed at.
+
+    Kept per relation rather than pooled: ``defines`` covers fields as well as
+    C++'s in-class member declarations, so only a language that needs it may look
+    there, and only when no ``method`` of that name exists.
     """
-    by_owner: dict[tuple[str, str], list[str]] = defaultdict(list)
+    by_relation: dict[str, dict[tuple[str, str], list[str]]] = {
+        relation: defaultdict(list) for relation in _MEMBER_RELATIONS
+    }
     for u, v, data in merged.edges(data=True):
-        if data.get("relation") != "method":
+        relation = data.get("relation")
+        if relation not in by_relation:
             continue
         if u in type_ids and v not in type_ids:
             owner, member = u, v
@@ -117,8 +134,18 @@ def _index_methods(merged: "nx.Graph", type_ids: set[str]) -> dict[tuple[str, st
             continue
         name = _key(merged.nodes[member].get("label"))
         if name:
-            by_owner[(owner, name)].append(member)
-    return by_owner
+            by_relation[relation][(owner, name)].append(member)
+    return by_relation
+
+
+def _member_relations(lang: str) -> tuple[str, ...]:
+    """Which owner→member relations may answer a call parked by ``lang``.
+
+    Only C++ models an in-class declaration (``void bar();`` in a header) as a
+    field, so only a C++ entry may fall back to ``defines``; for every other
+    language a ``defines`` target is a field, and a field cannot answer a call.
+    """
+    return ("method", "defines") if lang == "cpp" else ("method",)
 
 
 def link_cross_repo_member_calls(merged: "nx.Graph") -> int:
@@ -136,7 +163,7 @@ def link_cross_repo_member_calls(merged: "nx.Graph") -> int:
     by_name, type_ids = _index_declarations(merged)
     if not by_name:
         return 0
-    methods_by_owner = _index_methods(merged, type_ids)
+    members_by_relation = _index_members(merged, type_ids)
 
     added = 0
     for caller, caller_data in parked_nodes:
@@ -146,7 +173,8 @@ def link_cross_repo_member_calls(merged: "nx.Graph") -> int:
             # deliberately never re-decides a call inside one repo.
             continue
         for entry in _parked_entries(caller_data):
-            suffixes = _LANG_SUFFIXES.get(str(entry.get("lang") or ""))
+            lang = str(entry.get("lang") or "")
+            suffixes = _LANG_SUFFIXES.get(lang)
             receiver_type = _key(entry.get("receiver_type"))
             callee = _key(entry.get("callee"))
             if not suffixes or not receiver_type or not callee:
@@ -160,7 +188,11 @@ def link_cross_repo_member_calls(merged: "nx.Graph") -> int:
                 # The same guard the single-repo resolvers apply: two repos
                 # declaring the same name is an ambiguity, not a hit.
                 continue
-            targets = methods_by_owner.get((candidates[0], callee), [])
+            targets: list[str] = []
+            for relation in _member_relations(lang):
+                targets = members_by_relation[relation].get((candidates[0], callee), [])
+                if targets:
+                    break
             if len(targets) != 1:
                 continue
             target = targets[0]

graphify/extract.py

@@ -2861,6 +2861,52 @@ def _assembly_of_node(nid: str) -> str:
                 rc["caller_nid"] = remap[cn]
 
 
+UNRESOLVED_CALLS_KEY = "unresolved_calls"
+_MAX_PARKED_CALLS_PER_NODE = 64
+
+
+def _park_unresolved_member_call(
+    caller_node: dict | None,
+    callee: str,
+    receiver_type: str,
+    lang: str,
+    raw_call: dict,
+) -> None:
+    """Keep a member call whose receiver type is declared nowhere in this corpus.
+
+    A single-repo build can only bind ``obj.method()`` when the receiver's type is
+    declared in the same build, so a call into another repository is dropped with
+    the receiver type already in hand and nothing about it reaches ``graph.json``
+    — the one artifact ``merge-graphs`` and ``global add`` consume. Parking the
+    pair on the caller node lets a merged graph finish the edge (#3152).
+
+    The payload carries names only, never node ids: ids are rewritten by the
+    remaps and again by the repo prefixing, and a stale id inside metadata would
+    fail silently (#3150 was that bug). Names survive every rewrite.
+    """
+    if not caller_node or not callee or not receiver_type:
+        return
+    metadata = caller_node.setdefault("metadata", {})
+    if not isinstance(metadata, dict):
+        return
+    parked = metadata.setdefault(UNRESOLVED_CALLS_KEY, [])
+    if not isinstance(parked, list) or len(parked) >= _MAX_PARKED_CALLS_PER_NODE:
+        return
+    callee, receiver_type = str(callee), str(receiver_type)
+    for previous in parked:
+        if (
+            isinstance(previous, dict)
+            and previous.get("callee") == callee
+            and previous.get("receiver_type") == receiver_type
+        ):
+            return
+    entry = {"callee": callee, "receiver_type": receiver_type, "lang": lang}
+    location = raw_call.get("source_location")
+    if location:
+        entry["line"] = str(location)
+    parked.append(entry)
+
+
 def _resolve_swift_member_calls(
     per_file: list[dict],
     all_nodes: list[dict],
@@ -2977,7 +3023,8 @@ def _key(label: str) -> str:
             continue
         receiver = rc.get("receiver")
         callee = rc.get("callee")
-        if not receiver or not callee:
+        caller = rc.get("caller_nid")
+        if not receiver or not callee or not caller:
             continue
         # Determine the receiver's type. An upper-cased receiver is itself a type
         # (Type.staticMethod(), Singleton.shared.x()); otherwise look it up in the
@@ -2997,12 +3044,20 @@ def _key(label: str) -> str:
         if type_name in _LANGUAGE_BUILTIN_GLOBALS:
             continue
         type_defs = type_def_nids.get(_key(type_name), [])
-        if len(type_defs) != 1:  # ambiguous or absent -> bail (god-node guard)
+        if not type_defs:
+            # Declared nowhere here — in a multi-repo setup that usually means "in
+            # a repo this build does not contain", so park it for the merge
+            # (#3152). This resolver shares `all_raw_calls` with every other
+            # language and Swift raw_calls carry no `lang` tag, so the parked
+            # entry's language comes from the declaring file's suffix.
+            if str(rc.get("source_file", "")).lower().endswith(".swift"):
+                _park_unresolved_member_call(
+                    node_by_id.get(caller), callee, type_name, "swift", rc,
+                )
             continue
-        type_nid = type_defs[0]
-        caller = rc.get("caller_nid")
-        if not caller:
+        if len(type_defs) != 1:  # ambiguous -> bail (god-node guard)
             continue
+        type_nid = type_defs[0]
         method_nid = method_index.get((type_nid, _key(callee)))
         target = method_nid or type_nid
         relation = "calls" if method_nid else "references"
@@ -3410,7 +3465,17 @@ def _key(label: str) -> str:
         elif receiver[:1].isupper():
             # Foo::bar(): the type is named explicitly in source.
             type_defs = type_def_nids.get(_key(receiver), [])
-            if len(type_defs) != 1:  # ambiguous or absent -> bail (god-node guard)
+            if not type_defs:
+                # Declared nowhere here, which in a multi-repo setup usually means
+                # "in a repo this build does not contain" (#3152). `Foo::bar()` is
+                # also the shape of a namespace-qualified free function, so the
+                # merge side's guards do the deciding: it acts only when exactly
+                # one other repo declares a `Foo` owning exactly one `bar`.
+                _park_unresolved_member_call(
+                    node_by_id.get(caller), callee, receiver, "cpp", rc,
+                )
+                continue
+            if len(type_defs) != 1:  # ambiguous -> bail (god-node guard)
                 continue
             type_nid = type_defs[0]
             type_qualified = True
@@ -3420,7 +3485,12 @@ def _key(label: str) -> str:
             if not type_name:
                 continue
             type_defs = type_def_nids.get(_key(type_name), [])
-            if len(type_defs) != 1:  # ambiguous or absent -> bail (god-node guard)
+            if not type_defs:
+                _park_unresolved_member_call(
+                    node_by_id.get(caller), callee, type_name, "cpp", rc,
+                )
+                continue
+            if len(type_defs) != 1:  # ambiguous -> bail (god-node guard)
                 continue
             type_nid = type_defs[0]
             type_qualified = False
@@ -3584,6 +3654,18 @@ def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
         type_defs = type_def_nids.get(_key(type_name), [])
         return type_defs[0] if len(type_defs) == 1 else None
 
+    def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -> None:
+        """Park a call whose receiver type is declared nowhere in this corpus (#3152).
+
+        ``_resolve_type_name_nid`` collapses "absent", "ambiguous" and "scoping was
+        decisive" into one ``None``, and only the first is a cross-repo candidate,
+        so re-check the bare-name index instead of trusting the ``None``.
+        """
+        if type_name and not type_def_nids.get(_key(type_name)):
+            _park_unresolved_member_call(
+                caller_node, rc.get("callee"), type_name, "csharp", rc,
+            )
+
     all_raw_calls: list[dict] = []
     for result in per_file:
         all_raw_calls.extend(result.get("raw_calls", []))
@@ -3622,6 +3704,7 @@ def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
                 type_name = rc.get("receiver_type")
                 type_nid = _resolve_type_name_nid(type_name, caller_node, src_file)
                 if not type_nid:
+                    _park_if_absent(type_name or receiver, caller_node, rc)
                     continue
             type_qualified = True
         else:
@@ -3630,6 +3713,7 @@ def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
                 continue
             type_nid = _resolve_type_name_nid(type_name, caller_node, src_file)
             if not type_nid:  # ambiguous or absent -> bail (god-node guard)
+                _park_if_absent(type_name, caller_node, rc)
                 continue
             type_qualified = False
         method_nid = _method_on_type_or_bases(type_nid, _key(callee))
@@ -3702,52 +3786,6 @@ def _bind_member_field_tables(
     return bound
 
 
-UNRESOLVED_CALLS_KEY = "unresolved_calls"
-_MAX_PARKED_CALLS_PER_NODE = 64
-
-
-def _park_unresolved_member_call(
-    caller_node: dict | None,
-    callee: str,
-    receiver_type: str,
-    lang: str,
-    raw_call: dict,
-) -> None:
-    """Keep a member call whose receiver type is declared nowhere in this corpus.
-
-    A single-repo build can only bind ``obj.method()`` when the receiver's type is
-    declared in the same build, so a call into another repository is dropped with
-    the receiver type already in hand and nothing about it reaches ``graph.json``
-    — the one artifact ``merge-graphs`` and ``global add`` consume. Parking the
-    pair on the caller node lets a merged graph finish the edge (#3152).
-
-    The payload carries names only, never node ids: ids are rewritten by the
-    remaps and again by the repo prefixing, and a stale id inside metadata would
-    fail silently (#3150 was that bug). Names survive every rewrite.
-    """
-    if not caller_node or not callee or not receiver_type:
-        return
-    metadata = caller_node.setdefault("metadata", {})
-    if not isinstance(metadata, dict):
-        return
-    parked = metadata.setdefault(UNRESOLVED_CALLS_KEY, [])
-    if not isinstance(parked, list) or len(parked) >= _MAX_PARKED_CALLS_PER_NODE:
-        return
-    callee, receiver_type = str(callee), str(receiver_type)
-    for previous in parked:
-        if (
-            isinstance(previous, dict)
-            and previous.get("callee") == callee
-            and previous.get("receiver_type") == receiver_type
-        ):
-            return
-    entry = {"callee": callee, "receiver_type": receiver_type, "lang": lang}
-    location = raw_call.get("source_location")
-    if location:
-        entry["line"] = str(location)
-    parked.append(entry)
-
-
 def _resolve_java_member_calls(
     per_file: list[dict],
     all_nodes: list[dict],