trailmark 0.2.2__tar.gz → 0.3.1__tar.gz

{trailmark-0.2.2 → trailmark-0.3.1}/.github/workflows/ci.yml

@@ -38,7 +38,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b  # v8.1.0
 
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
         with:
@@ -59,7 +59,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b  # v8.1.0
 
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
         with:

{trailmark-0.2.2 → trailmark-0.3.1}/.github/workflows/mutation.yml

@@ -22,7 +22,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b  # v8.1.0
 
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
         with:

{trailmark-0.2.2 → trailmark-0.3.1}/.github/workflows/publish.yml

@@ -17,7 +17,7 @@ jobs:
         with:
           persist-credentials: false
 
-      - uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b  # v8.1.0
 
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
         with:

{trailmark-0.2.2 → trailmark-0.3.1}/CONTRIBUTING.md

@@ -50,8 +50,12 @@ Linux (CI runs on Ubuntu without issue).
 
 ## Architecture
 
-Trailmark has a three-layer architecture:
+Trailmark has a parse layer followed by a three-layer analysis stack:
 
+0. **Parse API** (`src/trailmark/parse.py`) -- public entry point for
+   parsing files or directories into a raw `CodeGraph`. Lazily imports
+   the appropriate language parser. Used directly for parse-only
+   workflows and internally by `QueryEngine`.
 1. **CodeGraph** (`src/trailmark/models/graph.py`) -- mutable data
    container holding nodes, edges, annotations, and entrypoints.
 2. **GraphStore** (`src/trailmark/storage/graph_store.py`) -- wraps
@@ -75,6 +79,7 @@ Trailmark has a three-layer architecture:
 
 1. Create `src/trailmark/parsers/<lang>/parser.py` implementing the
    `BaseParser` protocol from `src/trailmark/parsers/base.py`.
-2. Register the language in `src/trailmark/parsers/__init__.py`.
+2. Register the parser in `_PARSER_MAP` and its file extensions in
+   `_LANGUAGE_EXTENSIONS`, both in `src/trailmark/parse.py`.
 3. Add tests in `tests/test_<lang>_parser.py`.
 4. Update the language table in `README.md`.

{trailmark-0.2.2 → trailmark-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trailmark
-Version: 0.2.2
+Version: 0.3.1
 Summary: Parse source code into a queryable graph of functions, classes, calls, and semantic annotations
 Project-URL: Homepage, https://github.com/trailofbits/trailmark
 Project-URL: Repository, https://github.com/trailofbits/trailmark
@@ -11,7 +11,7 @@ License-File: LICENSE
 License-File: NOTICE
 Requires-Python: >=3.12
 Requires-Dist: rustworkx<1.0,>=0.17
-Requires-Dist: tree-sitter-language-pack<2.0,>=0.13
+Requires-Dist: tree-sitter-language-pack!=1.6.3,<1.7,>=0.13
 Requires-Dist: tree-sitter<1.0,>=0.25
 Description-Content-Type: text/markdown
 
@@ -107,7 +107,7 @@ flowchart TD
     class CG data
 ```
 
-Node IDs follow the scheme `module:function`, `module:Class`, or `module:Class.method` for unambiguous lookup. Edge confidence is tagged as `certain` (direct calls, `self.method()`), `inferred` (attribute access on non-self objects), or `uncertain` (dynamic dispatch).
+Node IDs follow the scheme `module:function`, `module:Class`, or `module:Class.method` for unambiguous lookup. Directory parsing resolves bare cross-file calls when a unique definition exists; ambiguous cross-file calls are left at their original best-effort target and marked `uncertain`. Edge confidence is tagged as `certain` (direct calls, `self.method()`), `inferred` (attribute access on non-self objects), or `uncertain` (dynamic dispatch or ambiguous resolution).
 
 ### 2. Index
 
@@ -384,8 +384,13 @@ See [docs/entrypoint-patterns.md](docs/entrypoint-patterns.md) for the full refe
 ### Programmatic API
 
 ```python
+from trailmark.parse import parse_directory, parse_file
 from trailmark.query.api import QueryEngine
 
+# Parse-only API: get the raw CodeGraph without building GraphStore/QueryEngine.
+graph = parse_file("path/to/file.py")
+graph = parse_directory("path/to/project", language="auto")
+
 # Single-language (default) or auto-detect + merge across all languages
 engine = QueryEngine.from_directory("path/to/project")
 engine = QueryEngine.from_directory("path/to/project", language="auto")

{trailmark-0.2.2 → trailmark-0.3.1}/README.md

@@ -90,7 +90,7 @@ flowchart TD
     class CG data
 ```
 
-Node IDs follow the scheme `module:function`, `module:Class`, or `module:Class.method` for unambiguous lookup. Edge confidence is tagged as `certain` (direct calls, `self.method()`), `inferred` (attribute access on non-self objects), or `uncertain` (dynamic dispatch).
+Node IDs follow the scheme `module:function`, `module:Class`, or `module:Class.method` for unambiguous lookup. Directory parsing resolves bare cross-file calls when a unique definition exists; ambiguous cross-file calls are left at their original best-effort target and marked `uncertain`. Edge confidence is tagged as `certain` (direct calls, `self.method()`), `inferred` (attribute access on non-self objects), or `uncertain` (dynamic dispatch or ambiguous resolution).
 
 ### 2. Index
 
@@ -367,8 +367,13 @@ See [docs/entrypoint-patterns.md](docs/entrypoint-patterns.md) for the full refe
 ### Programmatic API
 
 ```python
+from trailmark.parse import parse_directory, parse_file
 from trailmark.query.api import QueryEngine
 
+# Parse-only API: get the raw CodeGraph without building GraphStore/QueryEngine.
+graph = parse_file("path/to/file.py")
+graph = parse_directory("path/to/project", language="auto")
+
 # Single-language (default) or auto-detect + merge across all languages
 engine = QueryEngine.from_directory("path/to/project")
 engine = QueryEngine.from_directory("path/to/project", language="auto")

{trailmark-0.2.2 → trailmark-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trailmark"
-version = "0.2.2"
+version = "0.3.1"
 description = "Parse source code into a queryable graph of functions, classes, calls, and semantic annotations"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -14,7 +14,7 @@ authors = [
 ]
 dependencies = [
     "tree-sitter>=0.25,<1.0",
-    "tree-sitter-language-pack>=0.13,<2.0",
+    "tree-sitter-language-pack>=0.13,<1.7,!=1.6.3",
     "rustworkx>=0.17,<1.0",
 ]
 

trailmark-0.3.1/src/trailmark/__init__.py

@@ -0,0 +1,16 @@
+"""Trailmark: Parse source code into queryable graphs for security analysis."""
+
+from trailmark.parse import (
+    detect_languages,
+    parse_directory,
+    parse_file,
+    supported_languages,
+)
+
+__all__ = [
+    "detect_languages",
+    "parse_directory",
+    "parse_file",
+    "supported_languages",
+]
+__version__ = "0.3.1"

{trailmark-0.2.2 → trailmark-0.3.1}/src/trailmark/analysis/preanalysis.py

@@ -78,9 +78,9 @@ def _compute_blast_radius(store: GraphStore) -> dict[str, Any]:
     Nodes above the threshold are collected in a subgraph.
     """
     graph = store._graph  # noqa: SLF001
-    digraph = store._digraph  # noqa: SLF001
-    id_to_idx = store._id_to_idx  # noqa: SLF001
-    idx_to_id = store._idx_to_id  # noqa: SLF001
+    digraph = store._call_digraph  # noqa: SLF001
+    id_to_idx = store._call_id_to_idx  # noqa: SLF001
+    idx_to_id = store._call_idx_to_id  # noqa: SLF001
 
     high_blast: set[str] = set()
     max_radius = 0

trailmark-0.3.1/src/trailmark/parse.py

@@ -0,0 +1,216 @@
+"""Public parse-only API for building raw Trailmark code graphs."""
+
+from __future__ import annotations
+
+import importlib
+import os
+from pathlib import Path
+
+from trailmark.models.graph import CodeGraph
+from trailmark.parsers._common import should_skip_dir
+from trailmark.parsers.base import LanguageParser
+
+_PARSER_MAP: dict[str, tuple[str, str]] = {
+    "python": ("trailmark.parsers.python", "PythonParser"),
+    "javascript": ("trailmark.parsers.javascript", "JavaScriptParser"),
+    "typescript": ("trailmark.parsers.typescript", "TypeScriptParser"),
+    "php": ("trailmark.parsers.php", "PHPParser"),
+    "ruby": ("trailmark.parsers.ruby", "RubyParser"),
+    "c": ("trailmark.parsers.c", "CParser"),
+    "cpp": ("trailmark.parsers.cpp", "CppParser"),
+    "c_sharp": ("trailmark.parsers.csharp", "CSharpParser"),
+    "java": ("trailmark.parsers.java", "JavaParser"),
+    "go": ("trailmark.parsers.go", "GoParser"),
+    "rust": ("trailmark.parsers.rust", "RustParser"),
+    "solidity": ("trailmark.parsers.solidity", "SolidityParser"),
+    "cairo": ("trailmark.parsers.cairo", "CairoParser"),
+    "circom": ("trailmark.parsers.circom", "CircomParser"),
+    "haskell": ("trailmark.parsers.haskell", "HaskellParser"),
+    "erlang": ("trailmark.parsers.erlang", "ErlangParser"),
+    "masm": ("trailmark.parsers.masm", "MasmParser"),
+    "swift": ("trailmark.parsers.swift", "SwiftParser"),
+    "objc": ("trailmark.parsers.objc", "ObjCParser"),
+    "kotlin": ("trailmark.parsers.kotlin", "KotlinParser"),
+    "dart": ("trailmark.parsers.dart", "DartParser"),
+}
+
+# Extensions used for language auto-detection. Keep these aligned with each
+# parser's internal _EXTENSIONS tuple. Shared extensions (e.g., `.h` between C
+# and C++) are handled by prioritizing the more specific language — C++ is
+# tried before plain C when both report files.
+_LANGUAGE_EXTENSIONS: dict[str, tuple[str, ...]] = {
+    "python": (".py",),
+    "javascript": (".js", ".jsx", ".mjs", ".cjs"),
+    "typescript": (".ts", ".tsx"),
+    "php": (".php",),
+    "ruby": (".rb",),
+    "c": (".c",),
+    "cpp": (".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"),
+    "c_sharp": (".cs",),
+    "java": (".java",),
+    "go": (".go",),
+    "rust": (".rs",),
+    "solidity": (".sol",),
+    "cairo": (".cairo",),
+    "circom": (".circom",),
+    "haskell": (".hs",),
+    "erlang": (".erl",),
+    "masm": (".masm",),
+    "swift": (".swift",),
+    # `.h` files can be C, ObjC, or C++; auto-detect only fires on .m/.mm.
+    # The parser itself still walks .h when invoked with language="objc".
+    "objc": (".m", ".mm"),
+    "kotlin": (".kt", ".kts"),
+    "dart": (".dart",),
+}
+
+_SUPPORTED_LANGUAGES = tuple(_PARSER_MAP.keys())
+
+
+def supported_languages() -> tuple[str, ...]:
+    """Return the supported Trailmark parser language names."""
+    return _SUPPORTED_LANGUAGES
+
+
+def parse_file(path: str, language: str | None = None) -> CodeGraph:
+    """Parse a single file into a raw ``CodeGraph``.
+
+    Args:
+        path: Source file to parse.
+        language: Optional explicit parser language. If omitted, language is
+            inferred from the file extension.
+
+    Raises:
+        ValueError: If the language is unsupported or cannot be inferred.
+    """
+    file_path = Path(path)
+    resolved_language = _resolve_file_language(file_path, language)
+    return _get_parser(resolved_language).parse_file(str(file_path))
+
+
+def parse_directory(path: str, language: str = "python") -> CodeGraph:
+    """Parse a directory into a raw ``CodeGraph``.
+
+    ``language`` accepts a specific language name (e.g. ``"python"``),
+    ``"auto"`` to detect and merge all supported languages found under the
+    directory, or a comma-separated list like ``"python,rust"``.
+    """
+    languages = _resolve_directory_languages(path, language)
+    return _parse_and_merge(path, languages)
+
+
+def detect_languages(path: str) -> list[str]:
+    """Return the sorted languages with at least one file under ``path``.
+
+    Detection walks the directory once, classifies each file by extension,
+    and returns the languages that have at least one match. Order is the
+    order languages are registered in ``_LANGUAGE_EXTENSIONS``, which
+    roughly corresponds to popularity and keeps deterministic behavior.
+    """
+    root = Path(path)
+    if not root.exists():
+        return []
+
+    ext_to_language: dict[str, str] = {}
+    for lang, exts in _LANGUAGE_EXTENSIONS.items():
+        for ext in exts:
+            # When languages share an extension (none currently do, but
+            # guard against it), the FIRST registration wins.
+            ext_to_language.setdefault(ext, lang)
+
+    found: set[str] = set()
+    for _dirpath, dirs, files in os.walk(root):
+        # Keep detection aligned with the parser walk rules.
+        dirs[:] = [d for d in dirs if not should_skip_dir(d)]
+        for name in files:
+            ext = _file_extension(name)
+            if ext in ext_to_language:
+                found.add(ext_to_language[ext])
+        if len(found) == len(_LANGUAGE_EXTENSIONS):
+            break
+
+    return [lang for lang in _LANGUAGE_EXTENSIONS if lang in found]
+
+
+def _get_parser(language: str) -> LanguageParser:
+    """Lazily import and instantiate a parser for the given language."""
+    entry = _PARSER_MAP.get(language)
+    if entry is None:
+        msg = f"Unsupported language: {language}"
+        raise ValueError(msg)
+    module = importlib.import_module(entry[0])
+    cls = getattr(module, entry[1])
+    return cls()
+
+
+def _resolve_file_language(path: Path, language: str | None) -> str:
+    """Resolve a single-file parse request to one concrete language."""
+    if language is None or language == "auto":
+        detected = _detect_file_language(path)
+        if detected is None:
+            msg = f"Could not infer supported language from file extension: {path}"
+            raise ValueError(msg)
+        return detected
+    if "," in language:
+        msg = f"Single-file parse requires one language, got: {language}"
+        raise ValueError(msg)
+    if language not in _PARSER_MAP:
+        msg = f"Unsupported language: {language}"
+        raise ValueError(msg)
+    return language
+
+
+def _resolve_directory_languages(path: str, spec: str) -> list[str]:
+    """Expand a directory ``language`` argument into concrete languages."""
+    if spec == "auto":
+        detected = detect_languages(path)
+        if not detected:
+            msg = f"No supported languages detected under {path}"
+            raise ValueError(msg)
+        return detected
+    names = [name.strip() for name in spec.split(",") if name.strip()] if "," in spec else [spec]
+    for name in names:
+        if name not in _PARSER_MAP:
+            msg = f"Unsupported language: {name}"
+            raise ValueError(msg)
+    return names
+
+
+def _parse_and_merge(path: str, languages: list[str]) -> CodeGraph:
+    """Parse ``path`` with each language parser and merge into one graph."""
+    if len(languages) == 1:
+        # Preserves pre-polyglot behavior exactly for the common case.
+        return _get_parser(languages[0]).parse_directory(path)
+
+    merged = CodeGraph(language="polyglot", root_path=str(Path(path).resolve()))
+    for lang in languages:
+        sub = _get_parser(lang).parse_directory(path)
+        merged.merge(sub)
+    # merge() doesn't touch `language`; preserve the polyglot marker.
+    merged.language = "polyglot"
+    return merged
+
+
+def _detect_file_language(path: Path) -> str | None:
+    """Infer one supported language from a file extension."""
+    ext = _file_extension(path.name)
+    for language, exts in _LANGUAGE_EXTENSIONS.items():
+        if ext in exts:
+            return language
+    return None
+
+
+def _file_extension(name: str) -> str:
+    """Return the lowercase extension including leading dot, or ``''``."""
+    dot = name.rfind(".")
+    if dot < 0:
+        return ""
+    return name[dot:].lower()
+
+
+__all__ = [
+    "detect_languages",
+    "parse_directory",
+    "parse_file",
+    "supported_languages",
+]

{trailmark-0.2.2 → trailmark-0.3.1}/src/trailmark/parsers/_common.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
+import dataclasses
 import os
 from collections.abc import Callable
 from contextvars import ContextVar
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from trailmark.models.edges import CodeEdge, EdgeKind
+from trailmark.models.edges import CodeEdge, EdgeConfidence, EdgeKind
 from trailmark.models.graph import CodeGraph
 from trailmark.models.nodes import (
     BranchInfo,
@@ -104,6 +105,11 @@ _EXCLUDED_DIRS = frozenset(
 )
 
 
+def should_skip_dir(dirname: str) -> bool:
+    """Return whether a directory should be skipped during source walks."""
+    return dirname in _EXCLUDED_DIRS or dirname.startswith(".")
+
+
 def walk_source_files(
     dir_path: str,
     extensions: tuple[str, ...],
@@ -114,7 +120,8 @@ def walk_source_files(
     and does not follow symlinks.
     """
     for root, dirs, files in os.walk(dir_path, followlinks=False):
-        dirs[:] = [d for d in dirs if d not in _EXCLUDED_DIRS and not d.startswith(".")]
+        dirs[:] = [d for d in dirs if not should_skip_dir(d)]
+        dirs.sort()
         for fname in sorted(files):
             if any(fname.endswith(ext) for ext in extensions):
                 yield os.path.join(root, fname)
@@ -142,6 +149,7 @@ def parse_directory(
             merged.merge(file_graph)
     finally:
         _DIRECTORY_PARSE_ROOT.reset(token)
+    _link_cross_file_calls(merged)
     return merged
 
 
@@ -291,3 +299,60 @@ def first_child_by_type(node: Node, type_name: str) -> Node | None:
         if child.type == type_name:
             return child
     return None
+
+
+def _link_cross_file_calls(graph: CodeGraph) -> None:
+    """Rewrite dangling call edges to point at definitions in other modules.
+
+    Per-file parsers resolve bare calls like ``foo()`` as
+    ``current_module:foo``.  After merging, if ``foo`` is defined in
+    another module, that edge target doesn't exist.  This pass builds a
+    name index and rewrites those edges to the actual definition site.
+    """
+    defined_nodes = graph.nodes
+
+    name_to_ids: dict[str, list[str]] = {}
+    for node_id, unit in defined_nodes.items():
+        if unit.kind.value in {"function", "method"}:
+            name_to_ids.setdefault(unit.name, []).append(node_id)
+
+    new_edges: list[CodeEdge] = []
+    for edge in graph.edges:
+        if edge.kind != EdgeKind.CALLS or edge.target_id in defined_nodes:
+            new_edges.append(edge)
+            continue
+
+        target = edge.target_id
+        if "::" in target or "->" in target:
+            new_edges.append(edge)
+            continue
+
+        bare_name = target.rsplit(":", 1)[-1] if ":" in target else target
+        if "." in bare_name or "->" in bare_name:
+            new_edges.append(edge)
+            continue
+        candidates = name_to_ids.get(bare_name)
+
+        if not candidates:
+            new_edges.append(edge)
+            continue
+
+        if len(candidates) == 1:
+            new_edges.append(dataclasses.replace(edge, target_id=candidates[0]))
+        else:
+            # Ambiguous: prefer a single cross-file candidate when a same-file
+            # declaration is also present, but do not invent an arbitrary call
+            # target when multiple cross-file definitions share the same name.
+            src_module = edge.source_id.rsplit(":", 1)[0] if ":" in edge.source_id else ""
+            cross = [c for c in candidates if not c.startswith(src_module + ":")]
+            if len(cross) == 1:
+                new_edges.append(dataclasses.replace(edge, target_id=cross[0]))
+            else:
+                new_edges.append(
+                    dataclasses.replace(
+                        edge,
+                        confidence=EdgeConfidence.UNCERTAIN,
+                    )
+                )
+
+    graph.edges = new_edges

{trailmark-0.2.2 → trailmark-0.3.1}/src/trailmark/parsers/c/parser.py

@@ -92,6 +92,17 @@ def _visit_module(
         _visit_top_level_node(child, file_path, module_id, graph)
 
 
+_PREPROC_CONTAINER_TYPES = frozenset(
+    {
+        "preproc_if",
+        "preproc_ifdef",
+        "preproc_else",
+        "preproc_elif",
+        "ERROR",
+    }
+)
+
+
 def _visit_top_level_node(
     child: Node,
     file_path: str,
@@ -109,6 +120,9 @@ def _visit_top_level_node(
         _extract_struct(child, file_path, module_id, graph)
     elif child.type == "enum_specifier":
         _extract_enum(child, file_path, module_id, graph)
+    elif child.type in _PREPROC_CONTAINER_TYPES:
+        for nested in child.children:
+            _visit_top_level_node(nested, file_path, module_id, graph)
 
 
 def _extract_type_def(

{trailmark-0.2.2 → trailmark-0.3.1}/src/trailmark/parsers/cpp/parser.py

@@ -127,9 +127,14 @@ def _visit_top_level_node(
             module_id,
             graph,
         )
-    elif child.type == "linkage_specification":
-        # `extern "C" { ... }` wraps nested declarations — unwrap and
-        # dispatch each child back through this visitor.
+    elif child.type in (
+        "linkage_specification",
+        "preproc_if",
+        "preproc_ifdef",
+        "preproc_else",
+        "preproc_elif",
+        "ERROR",
+    ):
         for nested in child.children:
             _visit_top_level_node(nested, file_path, module_id, class_id, graph)
     elif child.type == "class_specifier":

{trailmark-0.2.2 → trailmark-0.3.1}/src/trailmark/parsers/erlang/parser.py

@@ -405,14 +405,37 @@ def _walk_calls(
     calls: list[tuple[str, Node]],
 ) -> None:
     """Recursively find call nodes and extract targets."""
+    if node.type == "remote":
+        name = _remote_call_name(node)
+        if name:
+            calls.append((name, node))
+        _walk_call_arguments(node.child_by_field_name("fun"), calls)
+        return
+
     if node.type == "call":
         name = _call_target_name(node)
         if name:
             calls.append((name, node))
+        _walk_call_arguments(node, calls)
+        return
+
     for child in node.children:
         _walk_calls(child, calls)
 
 
+def _walk_call_arguments(
+    node: Node | None,
+    calls: list[tuple[str, Node]],
+) -> None:
+    """Walk a call's argument expressions without re-visiting its target."""
+    if node is None:
+        return
+    for i, child in enumerate(node.children):
+        if node.field_name_for_child(i) == "expr":
+            continue
+        _walk_calls(child, calls)
+
+
 def _call_target_name(node: Node) -> str:
     """Extract the function name from a call node."""
     expr = node.child_by_field_name("expr")
@@ -433,8 +456,8 @@ def _remote_call_name(remote: Node) -> str:
         return ""
     # remote_module has a module field containing the atom.
     mod_atom = mod_node.child_by_field_name("module")
-    mod_name = node_text(mod_atom) if mod_atom is not None else ""
-    fun_name = node_text(fun_node)
+    mod_name = node_text(mod_atom) if mod_atom is not None else node_text(mod_node).rstrip(":")
+    fun_name = _call_target_name(fun_node) if fun_node.type == "call" else node_text(fun_node)
     if mod_name and fun_name:
         return f"{mod_name}:{fun_name}"
     return ""