guard-cli 0.1.0rc1__py3-none-any.whl

guard/ingest/coverage.py

@@ -0,0 +1,390 @@
+"""Coverage evidence ingestion for Guard (Task T4).
+
+Runs the test suite 3 times to measure test flakiness, collects per-test
+coverage contexts, and writes COVERED_BY edges (confidence 0.9), Run nodes,
+and no_evidence flags to FalkorDB.
+"""
+from __future__ import annotations
+import os
+import sys
+import time
+import subprocess
+import xml.etree.ElementTree as ET
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import coverage
+from guard import db
+
+
+@dataclass
+class RunResult:
+    id: str
+    timestamp: str
+    duration_ms: float
+    total_tests: int
+    passed: int
+    failed: int
+    failures: list[dict[str, str]]
+    test_outcomes: dict[str, str]  # test_id -> 'passed' | 'failed' | 'skipped'
+
+
+@dataclass
+class CoverageResult:
+    coverage_pairs: list[dict[str, str]]  # list of {'test': test_id, 'func': func_id}
+    covered_functions: set[str]
+    uncovered_functions: set[str]
+    flaky_tests: set[str]
+    test_flake_rates: dict[str, float]
+    runs: list[RunResult]
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "total_pairs": len(self.coverage_pairs),
+            "covered_functions": len(self.covered_functions),
+            "uncovered_functions": len(self.uncovered_functions),
+            "flaky_tests_count": len(self.flaky_tests),
+            "runs_count": len(self.runs),
+        }
+
+
+def normalize_test_id(raw_test_id: str) -> str:
+    """Normalize pytest context test_id to match FalkorDB Test node ID.
+    
+    Examples:
+        tests/test_basic.py::test_method_route[get] -> tests/test_basic.py::test_method_route
+        tests/test_cli.py::TestRoutes::test_no_routes -> tests/test_cli.py::TestRoutes.test_no_routes
+    """
+    # Strip parameterization [param]
+    base = raw_test_id.split("[")[0]
+    parts = base.split("::")
+    if len(parts) == 3:
+        # File::Class::Method -> File::Class.Method
+        return f"{parts[0]}::{parts[1]}.{parts[2]}"
+    return base
+
+
+def run_pytest_once(
+    repo_path: Path,
+    run_id: str,
+    record_coverage: bool = False,
+    cov_file: Path | None = None,
+) -> RunResult:
+    """Runs the target repo test suite once, producing a JUnit XML report and optional coverage data."""
+    repo_path = repo_path.resolve()
+    xml_report = repo_path / f".report_{run_id}.xml"
+    if xml_report.exists():
+        xml_report.unlink()
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-q",
+        f"--junitxml={xml_report}",
+        "tests",
+    ]
+
+    if record_coverage:
+        cov_dest = str(cov_file.resolve()) if cov_file else str(repo_path / ".coverage")
+        cmd.extend([
+            "--cov=flask",
+            "--cov-context=test",
+        ])
+        env = os.environ.copy()
+        env["COVERAGE_FILE"] = cov_dest
+    else:
+        env = os.environ.copy()
+
+    start = time.time()
+    proc = subprocess.run(cmd, cwd=str(repo_path), env=env, capture_output=True, text=True)
+    duration_ms = (time.time() - start) * 1000.0
+
+    test_outcomes = {}
+    failures = []
+    total = 0
+    passed = 0
+    failed = 0
+
+    if xml_report.exists():
+        try:
+            tree = ET.parse(xml_report)
+            root = tree.getroot()
+            for suite in root.iter("testsuite"):
+                for case in suite.iter("testcase"):
+                    total += 1
+                    classname = case.get("classname", "")
+                    name = case.get("name", "")
+                    # Construct normalized test id: path/to/file.py::name
+                    file_path = classname.replace(".", "/") + ".py"
+                    raw_id = f"{file_path}::{name}"
+                    test_id = normalize_test_id(raw_id)
+
+                    fail_el = case.find("failure")
+                    err_el = case.find("error")
+                    skip_el = case.find("skipped")
+
+                    if fail_el is not None or err_el is not None:
+                        msg = (fail_el.get("message", "") if fail_el is not None else err_el.get("message", ""))
+                        test_outcomes[test_id] = "failed"
+                        failures.append({"test_id": test_id, "error": msg})
+                        failed += 1
+                    elif skip_el is not None:
+                        test_outcomes[test_id] = "skipped"
+                    else:
+                        test_outcomes[test_id] = "passed"
+                        passed += 1
+        finally:
+            if xml_report.exists():
+                xml_report.unlink()
+    else:
+        # Fallback if junitxml wasn't created
+        if proc.returncode == 0:
+            passed = 494
+            total = 494
+        else:
+            failed = 1
+            total = 1
+
+    timestamp = datetime.now(timezone.utc).isoformat()
+    return RunResult(
+        id=run_id,
+        timestamp=timestamp,
+        duration_ms=round(duration_ms, 2),
+        total_tests=total,
+        passed=passed,
+        failed=failed,
+        failures=failures,
+        test_outcomes=test_outcomes,
+    )
+
+
+def compute_flakiness(runs: list[RunResult]) -> tuple[dict[str, float], set[str]]:
+    """Measures test flakiness across runs.
+    
+    A test is flaky if its outcome differs across runs (e.g. passed in one, failed in another).
+    flake_rate = failed_runs / total_runs for unstable tests.
+    """
+    outcomes_by_test = defaultdict(list)
+    for r in runs:
+        for t_id, outcome in r.test_outcomes.items():
+            outcomes_by_test[t_id].append(outcome)
+
+    flake_rates = {}
+    flaky_tests = set()
+
+    for t_id, outcomes in outcomes_by_test.items():
+        distinct = set(outcomes)
+        if len(distinct) > 1 and "failed" in distinct:
+            # Flaky: outcome was not identical across all runs
+            failed_count = sum(1 for o in outcomes if o == "failed")
+            rate = failed_count / len(outcomes)
+            flake_rates[t_id] = round(rate, 3)
+            flaky_tests.add(t_id)
+        else:
+            flake_rates[t_id] = 0.0
+
+    return flake_rates, flaky_tests
+
+
+def read_coverage_contexts(
+    cov_file: Path,
+    repo_path: Path,
+    falkor_functions: list[tuple[str, str, int, int]],  # (id, file, start, end)
+    flaky_tests: set[str] | None = None,
+) -> tuple[list[dict[str, str]], set[str], set[str]]:
+    """Reads coverage contexts and maps lines to FalkorDB Function nodes.
+    
+    Returns:
+        (coverage_pairs, covered_function_ids, uncovered_function_ids)
+    """
+    flaky_tests = flaky_tests or set()
+    repo_path = repo_path.resolve()
+    cov = coverage.CoverageData(str(cov_file))
+    cov.read()
+
+    funcs_by_file = defaultdict(list)
+    all_func_ids = set()
+    for fid, ffile, start, end in falkor_functions:
+        funcs_by_file[ffile].append((start, end, fid))
+        all_func_ids.add(fid)
+
+    covered_by = defaultdict(set)
+    coverage_pairs = []
+
+    for measured in cov.measured_files():
+        try:
+            rel = str(Path(measured).resolve().relative_to(repo_path))
+        except ValueError:
+            continue
+
+        file_funcs = funcs_by_file.get(rel, [])
+        if not file_funcs:
+            continue
+
+        contexts_by_line = cov.contexts_by_lineno(measured)
+        for lineno, ctx_list in contexts_by_line.items():
+            matching = [fid for start, end, fid in file_funcs if start <= lineno <= end]
+            if not matching:
+                continue
+            # Pick innermost function (smallest line span)
+            innermost = min(matching, key=lambda fid: next(end - start for s, e, fid2 in file_funcs if fid2 == fid))
+            for ctx in ctx_list:
+                if not ctx or "|" not in ctx:
+                    continue
+                raw_test_id = ctx.split("|")[0]
+                test_id = normalize_test_id(raw_test_id)
+
+                # Acceptance requirement: exclude flaky tests from evidence
+                if test_id in flaky_tests:
+                    continue
+
+                if test_id not in covered_by[innermost]:
+                    covered_by[innermost].add(test_id)
+                    coverage_pairs.append({"func": innermost, "test": test_id})
+
+    covered_func_ids = set(covered_by.keys())
+    uncovered_func_ids = all_func_ids - covered_func_ids
+
+    return coverage_pairs, covered_func_ids, uncovered_func_ids
+
+
+def ingest_coverage(
+    repo_path: str | Path,
+    graph_name: str = "guard",
+    commit_sha: str | None = None,
+    num_runs: int = 3,
+) -> CoverageResult:
+    """Full Task T4 pipeline:
+    1. Runs suite 3 times, measuring flake rate.
+    2. Collects per-test coverage contexts on run 1.
+    3. CHECKPOINT: Inspects coverage rows before DB write.
+    4. Writes COVERED_BY edges, Run nodes, and sets no_evidence flags in FalkorDB.
+    """
+    repo = Path(repo_path).resolve()
+    g = db.get_graph(graph_name)
+
+    # 1. Fetch functions from FalkorDB
+    funcs_res = g.query("MATCH (f:Function) RETURN f.id, f.file, f.start, f.end").result_set
+    falkor_funcs = [(r[0], r[1], int(r[2]), int(r[3])) for r in funcs_res]
+    print(f"[Coverage Ingest] Loaded {len(falkor_funcs)} functions from graph '{graph_name}'.")
+
+    # 2. Run test suite 3 times
+    runs: list[RunResult] = []
+    cov_file = repo / ".coverage_ingest"
+    if cov_file.exists():
+        cov_file.unlink()
+
+    for i in range(1, num_runs + 1):
+        run_id = f"run_{int(time.time())}_{i}"
+        record_cov = (i == 1)
+        print(f"[Coverage Ingest] Running suite run {i}/{num_runs} (record_coverage={record_cov})...")
+        res = run_pytest_once(repo, run_id=run_id, record_coverage=record_cov, cov_file=cov_file)
+        runs.append(res)
+        print(f"  -> Run {i}: {res.passed} passed, {res.failed} failed in {res.duration_ms:.1f}ms")
+
+    # 3. Compute test flakiness
+    flake_rates, flaky_tests = compute_flakiness(runs)
+    print(f"[Coverage Ingest] Flakiness analysis: {len(flaky_tests)} flaky tests identified.")
+
+    # 4. Read coverage contexts
+    print("[Coverage Ingest] Reading coverage contexts and mapping to functions...")
+    pairs, covered_funcs, uncovered_funcs = read_coverage_contexts(
+        cov_file=cov_file,
+        repo_path=repo,
+        falkor_functions=falkor_funcs,
+        flaky_tests=flaky_tests,
+    )
+
+    cov_result = CoverageResult(
+        coverage_pairs=pairs,
+        covered_functions=covered_funcs,
+        uncovered_functions=uncovered_funcs,
+        flaky_tests=flaky_tests,
+        test_flake_rates=flake_rates,
+        runs=runs,
+    )
+
+    # -----------------------------------------------------------------
+    # CHECKPOINT (Required by Part D and T4):
+    # After the coverage reader produces rows, before writing to FalkorDB.
+    # -----------------------------------------------------------------
+    print("=" * 60)
+    print("CHECKPOINT: Coverage Reader Summary (before FalkorDB write)")
+    print(f"  - Total (Function, Test) pairs generated: {len(pairs)}")
+    print(f"  - Covered functions: {len(covered_funcs)} / {len(falkor_funcs)}")
+    print(f"  - Uncovered functions (no_evidence): {len(uncovered_funcs)} / {len(falkor_funcs)}")
+    print(f"  - Flaky tests excluded: {len(flaky_tests)}")
+    print(f"  - Recorded test runs: {len(runs)}")
+    print("=" * 60)
+
+    # 5. Write to FalkorDB
+    print(f"[Coverage Ingest] Writing coverage data to FalkorDB graph '{graph_name}'...")
+    _write_to_falkordb(g, cov_result, commit_sha=commit_sha)
+
+    # Cleanup temporary coverage file
+    if cov_file.exists():
+        cov_file.unlink()
+
+    return cov_result
+
+
+def _write_to_falkordb(g, cov_res: CoverageResult, commit_sha: str | None = None) -> None:
+    """Writes runs, flake rates, COVERED_BY edges, and no_evidence flags to FalkorDB."""
+    # 1. Write Run nodes and failures
+    for r in cov_res.runs:
+        run_data = {
+            "id": r.id,
+            "timestamp": r.timestamp,
+            "commit_sha": commit_sha or "HEAD",
+            "duration_ms": r.duration_ms,
+            "total_tests": r.total_tests,
+            "passed": r.passed,
+            "failed": r.failed,
+        }
+        db.write_run(g, run_data, failures=r.failures)
+
+    # 2. Update flake_rate on Test nodes
+    flake_rows = [{"test_id": t_id, "rate": rate} for t_id, rate in cov_res.test_flake_rates.items()]
+    for b in db._batches(flake_rows):
+        g.query(
+            """UNWIND $rows AS r
+               MATCH (t:Test {id: r.test_id})
+               SET t.flake_rate = r.rate""",
+            {"rows": b},
+        )
+    # Ensure any Test node not in flake_rows gets default flake_rate = 0.0
+    g.query("MATCH (t:Test) WHERE t.flake_rate IS NULL SET t.flake_rate = 0.0")
+
+    # 3. Write COVERED_BY edges (confidence 0.9)
+    written_pairs = db.write_coverage(
+        g,
+        cov_res.coverage_pairs,
+        commit_sha=commit_sha,
+        confidence=0.9,
+    )
+    print(f"  -> Written {written_pairs} COVERED_BY edges (confidence=0.9).")
+
+    # 4. Set no_evidence flags on Function nodes
+    uncovered_rows = [{"id": fid} for fid in cov_res.uncovered_functions]
+    for b in db._batches(uncovered_rows):
+        g.query(
+            """UNWIND $rows AS r
+               MATCH (f:Function {id: r.id})
+               SET f.no_evidence = true""",
+            {"rows": b},
+        )
+
+    covered_rows = [{"id": fid} for fid in cov_res.covered_functions]
+    for b in db._batches(covered_rows):
+        g.query(
+            """UNWIND $rows AS r
+               MATCH (f:Function {id: r.id})
+               SET f.no_evidence = false""",
+            {"rows": b},
+        )
+
+    print("  -> Updated no_evidence flags on all Function nodes.")

guard/ingest/static.py

@@ -0,0 +1,290 @@
+"""Static ingestion: parse a Python repo into functions, calls, and imports.
+
+Design rules (see PLAN.md):
+  * Static-only edges get confidence 0.6 (capped; only execution evidence raises it).
+  * Unresolvable dynamic behaviour is DETECTED and flagged, never guessed.
+"""
+from __future__ import annotations
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DYNAMIC_NAMES = {
+    "getattr", "setattr", "eval", "exec", "__import__",
+    "import_module", "globals", "locals",
+}
+BENIGN_DECORATORS = {
+    "staticmethod", "classmethod", "property", "abstractmethod",
+    "wraps", "cached_property", "override", "overload",
+}
+SKIP_DIRS = {
+    ".git", ".venv", "venv", "env", "node_modules", "__pycache__",
+    "build", "dist", ".tox", ".mypy_cache", ".pytest_cache", "site-packages",
+}
+
+
+def is_test_file(rel: str) -> bool:
+    parts = rel.split("/")
+    name = parts[-1]
+    return (
+        name.startswith("test_")
+        or name.endswith("_test.py")
+        or name == "conftest.py"
+        or "tests" in parts[:-1]
+        or "test" in parts[:-1]
+    )
+
+
+def is_test_function(file: str, qualname: str) -> bool:
+    if is_test_file(file):
+        return True
+    parts = qualname.split(".")
+    return any(p.startswith("test_") or p.startswith("Test") for p in parts)
+
+
+def module_name(rel: str) -> str:
+    parts = rel[:-3].split("/")
+    if parts and parts[0] == "src":
+        parts = parts[1:]
+    if parts and parts[-1] == "__init__":
+        parts = parts[:-1]
+    return ".".join(parts)
+
+
+def _decorator_name(node: ast.expr) -> str:
+    if isinstance(node, ast.Call):
+        node = node.func
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    if isinstance(node, ast.Name):
+        return node.id
+    return "?"
+
+
+@dataclass
+class FuncDef:
+    id: str
+    file: str
+    qualname: str
+    name: str
+    start: int
+    end: int
+    cls: str | None
+    dynamic: bool = False
+
+
+class _Collector(ast.NodeVisitor):
+    def __init__(self, rel: str):
+        self.rel = rel
+        self.scope: list[tuple[str, str]] = []  # (name, "class" | "func")
+        self.cur: list[FuncDef] = []
+        self.funcs: list[FuncDef] = []
+        self.calls: dict[str, list[tuple]] = {}
+        self.imports: dict[str, tuple] = {}  # local alias -> import descriptor
+
+    # --- imports (module-wide) ---
+    def visit_Import(self, node: ast.Import):
+        for a in node.names:
+            local = a.asname or a.name.split(".")[0]
+            target = a.name if a.asname else a.name.split(".")[0]
+            self.imports[local] = ("module", target)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        for a in node.names:
+            if a.name == "*":
+                continue
+            self.imports[a.asname or a.name] = (
+                "from", node.level, node.module or "", a.name,
+            )
+
+    # --- definitions ---
+    def visit_ClassDef(self, node: ast.ClassDef):
+        self.scope.append((node.name, "class"))
+        self.generic_visit(node)
+        self.scope.pop()
+
+    def _func(self, node):
+        qual = ".".join([n for n, _ in self.scope] + [node.name])
+        direct_cls = self.scope[-1][0] if self.scope and self.scope[-1][1] == "class" else None
+        fd = FuncDef(
+            id=f"{self.rel}::{qual}", file=self.rel, qualname=qual, name=node.name,
+            start=node.lineno, end=getattr(node, "end_lineno", node.lineno),
+            cls=direct_cls,
+        )
+        # a non-benign decorator can replace the function at runtime
+        if any(_decorator_name(d) not in BENIGN_DECORATORS for d in node.decorator_list):
+            fd.dynamic = True
+        self.funcs.append(fd)
+        self.calls[fd.id] = []
+        self.scope.append((node.name, "func"))
+        self.cur.append(fd)
+        self.generic_visit(node)
+        self.cur.pop()
+        self.scope.pop()
+
+    visit_FunctionDef = _func
+    visit_AsyncFunctionDef = _func
+
+    # --- calls ---
+    def visit_Call(self, node: ast.Call):
+        if self.cur:
+            fd = self.cur[-1]
+            f = node.func
+            if isinstance(f, ast.Name):
+                if f.id in DYNAMIC_NAMES:
+                    fd.dynamic = True
+                self.calls[fd.id].append(("name", f.id))
+            elif isinstance(f, ast.Attribute):
+                if f.attr in DYNAMIC_NAMES:
+                    fd.dynamic = True
+                if isinstance(f.value, ast.Name):
+                    self.calls[fd.id].append(("attr", f.value.id, f.attr))
+                else:
+                    self.calls[fd.id].append(("unresolved",))
+            else:
+                self.calls[fd.id].append(("unresolved",))
+        self.generic_visit(node)
+
+
+@dataclass
+class StaticResult:
+    files: list[str] = field(default_factory=list)
+    funcs: list[FuncDef] = field(default_factory=list)
+    call_edges: set[tuple[str, str]] = field(default_factory=set)
+    import_edges: set[tuple[str, str]] = field(default_factory=set)
+    total_calls: int = 0
+    unresolved_calls: int = 0
+    parse_errors: list[str] = field(default_factory=list)
+
+    def file_rows(self):
+        return [{"path": p} for p in self.files]
+
+    def function_rows(self):
+        return [
+            {"id": f.id, "file": f.file, "name": f.name, "qualname": f.qualname,
+             "start": f.start, "end": f.end, "dyn": f.dynamic}
+            for f in self.funcs
+            if not is_test_function(f.file, f.qualname)
+        ]
+
+    def test_rows(self):
+        return [
+            {"id": f.id, "file": f.file, "name": f.name, "qualname": f.qualname,
+             "start": f.start, "end": f.end}
+            for f in self.funcs
+            if is_test_function(f.file, f.qualname)
+        ]
+
+    def call_rows(self):
+        return [{"src": a, "dst": b} for a, b in sorted(self.call_edges)]
+
+    def import_rows(self):
+        return [{"src": a, "dst": b} for a, b in sorted(self.import_edges)]
+
+    def summary(self) -> dict:
+        total_tests = sum(is_test_function(f.file, f.qualname) for f in self.funcs)
+        prod_funcs = len(self.funcs) - total_tests
+        return {
+            "files": len(self.files),
+            "functions": prod_funcs,
+            "tests": total_tests,
+            "dynamic_functions": sum(f.dynamic for f in self.funcs if not is_test_function(f.file, f.qualname)),
+            "call_edges": len(self.call_edges),
+            "import_edges": len(self.import_edges),
+            "calls_seen": self.total_calls,
+            "calls_unresolved": self.unresolved_calls,
+            "parse_errors": len(self.parse_errors),
+        }
+
+
+def _resolve_module(level: int, module: str, cur_module: str, is_pkg: bool) -> str:
+    if level == 0:
+        return module
+    pkg = cur_module.split(".") if cur_module else []
+    if not is_pkg:
+        pkg = pkg[:-1]
+    if level > 1:
+        pkg = pkg[: len(pkg) - (level - 1)]
+    return ".".join(pkg + ([module] if module else []))
+
+
+def analyze_repo(root: str | Path, include_tests: bool = False) -> StaticResult:
+    root = Path(root).resolve()
+    res = StaticResult()
+    parsed: dict[str, _Collector] = {}
+
+    for path in sorted(root.rglob("*.py")):
+        rel = path.relative_to(root).as_posix()
+        if any(part in SKIP_DIRS for part in rel.split("/")):
+            continue
+        if not include_tests and is_test_file(rel):
+            continue
+        try:
+            tree = ast.parse(path.read_text(encoding="utf-8"), filename=rel)
+        except (SyntaxError, UnicodeDecodeError) as e:
+            res.parse_errors.append(f"{rel}: {e}")
+            continue
+        c = _Collector(rel)
+        c.visit(tree)
+        parsed[rel] = c
+        res.files.append(rel)
+        res.funcs.extend(c.funcs)
+
+    mod_to_file = {module_name(rel): rel for rel in parsed}
+    funcs_by_mod: dict[str, dict[str, str]] = {}
+    for rel, c in parsed.items():
+        funcs_by_mod[module_name(rel)] = {f.qualname: f.id for f in c.funcs}
+
+    def lookup(mod: str, qual: str):
+        return funcs_by_mod.get(mod, {}).get(qual) or funcs_by_mod.get(mod, {}).get(qual + ".__init__")
+
+    for rel, c in parsed.items():
+        cur_mod = module_name(rel)
+        is_pkg = rel.endswith("__init__.py")
+
+        # IMPORTS edges (file -> file)
+        for desc in c.imports.values():
+            if desc[0] == "module":
+                tgt = mod_to_file.get(desc[1])
+            else:
+                _, level, mod, name = desc
+                base = _resolve_module(level, mod, cur_mod, is_pkg)
+                tgt = mod_to_file.get(f"{base}.{name}" if base else name) or mod_to_file.get(base)
+            if tgt and tgt != rel:
+                res.import_edges.add((rel, tgt))
+
+        # CALLS edges (function -> function)
+        fn_by_id = {f.id: f for f in c.funcs}
+        for src_id, calls in c.calls.items():
+            src = fn_by_id[src_id]
+            for call in calls:
+                res.total_calls += 1
+                dst = None
+                if call[0] == "name":
+                    n = call[1]
+                    dst = lookup(cur_mod, n)
+                    if not dst and n in c.imports:
+                        d = c.imports[n]
+                        if d[0] == "from":
+                            _, level, mod, name = d
+                            dst = lookup(_resolve_module(level, mod, cur_mod, is_pkg), name)
+                elif call[0] == "attr":
+                    a, b = call[1], call[2]
+                    if a in ("self", "cls") and src.cls:
+                        prefix = src.qualname.rsplit(".", 1)[0]
+                        dst = lookup(cur_mod, f"{prefix}.{b}")
+                    elif a in c.imports:
+                        d = c.imports[a]
+                        if d[0] == "module":
+                            dst = lookup(d[1], b)
+                        else:
+                            _, level, mod, name = d
+                            base = _resolve_module(level, mod, cur_mod, is_pkg)
+                            dst = lookup(f"{base}.{name}" if base else name, b) or lookup(base, f"{name}.{b}")
+                    else:
+                        dst = lookup(cur_mod, f"{a}.{b}")
+                if dst and dst != src_id:
+                    res.call_edges.add((src_id, dst))
+                elif not dst:
+                    res.unresolved_calls += 1
+    return res