fix(elixir): resolve qualified and aliased remote calls (#4206)

Co-Authored-By: Grok Bot <noreply@x.ai>

Author: Mpasha17

graphify/extract.py

@@ -5772,6 +5772,73 @@ def _resolve_elixir_import_targets(
         e["target"] = target_nid
 
 
+def _resolve_elixir_qualified_calls(
+    per_file: list[dict],
+    all_nodes: list[dict],
+    all_edges: list[dict],
+) -> None:
+    """Resolve Elixir remote calls that name their module (#4206).
+
+    extract_elixir expands the receiver of `App.Accounts.get_user(id)` /
+    `Accounts.get_user(id)` (through the caller's `alias` table and
+    `__MODULE__`) and stamps it on the raw_call as ``elixir_module``; calls
+    into a module of the same file are linked there already. The shared pass
+    skips member calls, so this pass is strictly additive, like
+    `_resolve_csharp_qualified_calls`.
+
+    The module must match exactly one top-level module in the corpus and the
+    function must be one of its own defs. A module outside the corpus (Ecto's
+    `Repo`, `Enum`, `Map`) gets no edge rather than a same-named guess.
+    """
+    raw = [
+        rc
+        for result in per_file
+        for rc in result.get("raw_calls", [])
+        if rc.get("elixir_module") and rc.get("callee") and rc.get("caller_nid")
+    ]
+    if not raw:
+        return
+
+    module_nids: dict[str, list[str]] = {}
+    labels: dict[str, str] = {}
+    for n in all_nodes:
+        labels[n["id"]] = str(n.get("label") or "")
+        if n.get("_elixir_module") and n.get("source_file"):
+            module_nids.setdefault(labels[n["id"]], []).append(n["id"])
+    defs: dict[tuple[str, str], str] = {}
+    for e in all_edges:
+        if e.get("relation") == "method":
+            name = labels.get(e.get("target", ""), "")
+            if name.endswith("()"):
+                defs.setdefault((e["source"], name[:-2]), e["target"])
+
+    existing_pairs = {
+        (e.get("source"), e.get("target"))
+        for e in all_edges
+        if e.get("relation") == "calls"
+    }
+    for rc in raw:
+        candidates = module_nids.get(rc["elixir_module"], [])
+        if len(candidates) != 1:
+            continue
+        caller = rc["caller_nid"]
+        tgt = defs.get((candidates[0], rc["callee"]))
+        if tgt is None or tgt == caller or (caller, tgt) in existing_pairs:
+            continue
+        existing_pairs.add((caller, tgt))
+        all_edges.append({
+            "source": caller,
+            "target": tgt,
+            "relation": "calls",
+            "context": "call",
+            "confidence": "EXTRACTED",  # the module is written in source
+            "confidence_score": 1.0,
+            "source_file": rc.get("source_file", ""),
+            "source_location": rc.get("source_location"),
+            "weight": 1.0,
+        })
+
+
 def _resolve_kotlin_member_calls(
     per_file: list[dict],
     all_nodes: list[dict],
@@ -5942,6 +6009,13 @@ def _resolve_kotlin_member_calls(
         _resolve_elixir_import_targets,
     )
 )
+register_language_resolver(
+    LanguageResolver(
+        "elixir_qualified_calls",
+        frozenset({".ex", ".exs"}),
+        _resolve_elixir_qualified_calls,
+    )
+)
 # Pascal/Delphi cross-file inherited-method-call resolution: a call from a
 # manual descendant class to a method it inherits from an ancestor declared
 # in a DIFFERENT file (the common generated-base/manual-descendant split,

graphify/extractors/elixir.py

@@ -1,6 +1,7 @@
 """Elixir extractor. Moved verbatim from graphify/extract.py."""
 from __future__ import annotations
 
+import re
 from pathlib import Path
 from typing import Any
 
@@ -61,6 +62,11 @@ def add_edge(src: str, tgt: str, relation: str, line: int,
     # is the file's top level), along with each module's and function's parent.
     call_scope: dict[str | None, list[str]] = {}
     enclosing: dict[str, str | None] = {}
+    # For qualified calls (`Mod.fun()`, #4206): each module's full name, each
+    # scope's `alias` table (same scoping as call_scope) and each module's defs.
+    module_names: dict[str, str] = {}
+    aliases: dict[str | None, dict[str, str]] = {}
+    module_defs: dict[tuple[str, str], str] = {}
 
     _IMPORT_KEYWORDS = frozenset({"alias", "import", "require", "use"})
 
@@ -99,10 +105,11 @@ def _text(n) -> str:
                 return [_text(child)]
         return []
 
-    def _get_defimpl_target(node) -> str | None:
-        """The `for:` target module of a `defimpl Proto, for: Type` argument
-        list. The grammar holds it in a trailing `keywords` node as a `pair`
-        whose keyword is `for:` and whose value is an `alias`."""
+    def _get_keyword_alias(node, key: str) -> str | None:
+        """The module given for keyword ``key`` in an argument list, e.g. the
+        `for:` of `defimpl Proto, for: Type` or the `as:` of `alias A.B, as: C`.
+        The grammar holds it in a trailing `keywords` node as a `pair` whose
+        keyword is `key:` and whose value is an `alias`."""
         for child in node.children:
             if child.type != "keywords":
                 continue
@@ -116,10 +123,53 @@ def _get_defimpl_target(node) -> str | None:
                         kw = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
                     elif sub.type == "alias":
                         val = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
-                if kw and kw.rstrip(": ").strip() == "for" and val:
+                if kw and kw.rstrip(": ").strip() == key and val:
                     return val
         return None
 
+    def _expand_module(name: str, scope: str | None) -> str:
+        """Expand the first segment of a module reference through the `alias`
+        tables visible from ``scope`` (or `__MODULE__` to the current module)."""
+        first, _, rest = name.partition(".")
+        target = None
+        if first == "__MODULE__":
+            # ``scope`` is a module, or a function directly inside one.
+            if scope is not None and scope not in module_names:
+                scope = enclosing.get(scope)
+            target = (module_names.get(scope) if scope is not None else None) or None
+        else:
+            seen: set[str | None] = set()
+            container = scope
+            while container not in seen:
+                seen.add(container)
+                target = aliases.get(container, {}).get(first)
+                if target is not None or container is None:
+                    break
+                container = enclosing.get(container)
+        if target is None:
+            return name
+        return f"{target}.{rest}" if rest else target
+
+    def _record_aliases(arguments_node, scope: str | None) -> None:
+        modules = [_expand_module(m, scope) for m in _get_alias_modules(arguments_node)]
+        as_name = _get_keyword_alias(arguments_node, "as")
+        table = aliases.setdefault(scope, {})
+        if as_name and len(modules) == 1:
+            table[as_name] = modules[0]
+        elif not as_name:
+            for module in modules:
+                table[module.rsplit(".", 1)[-1]] = module
+
+    def _register_module(nid: str, name: str, parent: str | None) -> None:
+        # A nested `defmodule Inner` is `Outer.Inner`, and `Inner` is
+        # auto-aliased inside Outer.
+        parent_name = module_names.get(parent) if parent is not None else None
+        if parent_name:
+            first = name.split(".", 1)[0]
+            aliases.setdefault(parent, {})[first] = f"{parent_name}.{first}"
+            name = f"{parent_name}.{name}"
+        module_names[nid] = name
+
     def walk(node, parent_module_nid: str | None = None) -> None:
         if node.type != "call":
             for child in node.children:
@@ -160,6 +210,7 @@ def walk(node, parent_module_nid: str | None = None) -> None:
                      **({"_elixir_module": True} if parent_module_nid is None else {}))
             add_edge(file_nid, module_nid, "contains", line)
             enclosing[module_nid] = parent_module_nid
+            _register_module(module_nid, module_name, parent_module_nid)
             if do_block_node:
                 for child in do_block_node.children:
                     walk(child, parent_module_nid=module_nid)
@@ -179,6 +230,7 @@ def walk(node, parent_module_nid: str | None = None) -> None:
                      **({"_elixir_module": True} if parent_module_nid is None else {}))
             add_edge(parent_module_nid or file_nid, proto_nid, "contains", line)
             enclosing[proto_nid] = parent_module_nid
+            _register_module(proto_nid, proto_name, parent_module_nid)
             if do_block_node:
                 for child in do_block_node.children:
                     walk(child, parent_module_nid=proto_nid)
@@ -190,12 +242,13 @@ def walk(node, parent_module_nid: str | None = None) -> None:
             proto_name = _get_alias_text(arguments_node) if arguments_node else None
             if not proto_name:
                 return
-            target = _get_defimpl_target(arguments_node)
+            target = _get_keyword_alias(arguments_node, "for")
             impl_nid = _make_id(stem, "defimpl", proto_name, target or "")
             label = f"{proto_name} (for {target})" if target else proto_name
             add_node(impl_nid, label, line)
             add_edge(parent_module_nid or file_nid, impl_nid, "contains", line)
             enclosing[impl_nid] = parent_module_nid
+            module_names[impl_nid] = f"{proto_name}.{target}" if target else ""
             # Link the implementation to the protocol it satisfies. A same-file
             # protocol resolves directly; a cross-file target is filtered out by
             # the dangling-edge guard below rather than left hanging.
@@ -247,6 +300,7 @@ def walk(node, parent_module_nid: str | None = None) -> None:
             enclosing[func_nid] = parent_module_nid
             if parent_module_nid:
                 add_edge(parent_module_nid, func_nid, "method", line)
+                module_defs.setdefault((parent_module_nid, func_name), func_nid)
             else:
                 add_edge(file_nid, func_nid, "contains", line)
             if do_block_node:
@@ -261,6 +315,8 @@ def walk(node, parent_module_nid: str | None = None) -> None:
                 # calls; alias/require do not.
                 if keyword in ("import", "use"):
                     call_scope.setdefault(parent_module_nid, []).append(module_name)
+            if keyword == "alias":
+                _record_aliases(arguments_node, parent_module_nid)
             return
 
         for child in node.children:
@@ -273,6 +329,9 @@ def walk(node, parent_module_nid: str | None = None) -> None:
         normalised = n["label"].strip("()").lstrip(".")
         label_to_nid[normalised] = n["id"]
 
+    module_nid_by_name = {name: nid for nid, name in module_names.items()}
+    _MODULE_REF = re.compile(r"(__MODULE__|[A-Z]\w*)(\.[A-Z]\w*)*")
+
     seen_call_pairs: set[tuple[str, str]] = set()
     raw_calls: list[dict] = []
     _SKIP_KEYWORDS = frozenset({
@@ -304,25 +363,44 @@ def walk_calls(node, caller_nid: str) -> None:
             if child.type == "identifier":
                 kw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
                 if kw in _SKIP_KEYWORDS:
+                    if kw == "alias":  # a function-local alias
+                        for c in node.children:
+                            if c.type == "arguments":
+                                _record_aliases(c, caller_nid)
                     for c in node.children:
                         walk_calls(c, caller_nid)
                     return
                 break
         callee_name: str | None = None
         is_member_call: bool = False
+        receiver_module: str | None = None
         for child in node.children:
             if child.type == "dot":
                 is_member_call = True
                 dot_text = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
                 parts = dot_text.rstrip(".").split(".")
                 if parts:
                     callee_name = parts[-1]
+                # `Mod.fun()` / `Alias.fun()` / `__MODULE__.fun()`: keep the
+                # module. A variable (`mod.fun()`) or atom receiver stays None.
+                if child.child_count == 3:
+                    receiver = child.children[0]
+                    receiver_text = source[receiver.start_byte:receiver.end_byte].decode(
+                        "utf-8", errors="replace")
+                    if _MODULE_REF.fullmatch(receiver_text):
+                        receiver_module = _expand_module(receiver_text, caller_nid)
                 break
             if child.type == "identifier":
                 callee_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
                 break
-        if callee_name and callee_name not in _LANGUAGE_BUILTIN_GLOBALS:
-            tgt_nid = label_to_nid.get(callee_name)
+        if callee_name and (receiver_module or callee_name not in _LANGUAGE_BUILTIN_GLOBALS):
+            # A remote call only ever reaches the named module's own def: never
+            # the bare name, which bound `Repo.insert(x)` to a local insert/1.
+            if receiver_module is not None:
+                mod_nid = module_nid_by_name.get(receiver_module)
+                tgt_nid = module_defs.get((mod_nid, callee_name)) if mod_nid else None
+            else:
+                tgt_nid = None if is_member_call else label_to_nid.get(callee_name)
             if tgt_nid and tgt_nid != caller_nid:
                 pair = (caller_nid, tgt_nid)
                 if pair not in seen_call_pairs:
@@ -338,6 +416,7 @@ def walk_calls(node, caller_nid: str) -> None:
                     "source_file": str_path,
                     "source_location": f"L{node.start_point[0] + 1}",
                     "elixir_call_scope": _call_scope_for(caller_nid),
+                    **({"elixir_module": receiver_module} if receiver_module else {}),
                 })
         for child in node.children:
             walk_calls(child, caller_nid)