fix(dataflow): key L3 body + intra-callable edges by local id (canonical); keep global_id for neo4j

Author: rahlk

codeanalyzer/dataflow/builder.py

@@ -204,14 +204,14 @@ def emit_l3_body(
     :func:`build_function_pdgs` (syntactic oracle), this writes onto the
     matching ``PyCallable`` in ``app``'s symbol table:
 
-    * ``body`` — one node per CFG node, keyed by its ordinal id
-      (``<can:// id>@entry``/``@exit`` for the synthetic bookends,
-      ``<can:// id>@line:col`` for real statements). A statement position an
-      L1 pass already materialized as a ``call`` node keeps its ``call`` kind
-      and L2-resolved ``callee``; it is only re-keyed onto its ordinal id (so
-      the edge lists resolve to it and it is not duplicated) and given the
-      byte-offset ``span`` L1 could not compute.
-    * ``cfg`` — one ``CfgEdge`` per CFG edge, endpoints as ordinal ids.
+    * ``body`` — one node per CFG node, keyed by its LOCAL id (``"@entry"``/
+      ``"@exit"`` for the synthetic bookends, ``"line:col"`` for real
+      statements — the same key format L1 uses). A statement position an L1
+      pass already materialized as a ``call`` node lands on the SAME local key,
+      so it keeps its ``call`` kind and L2-resolved ``callee`` in place (no
+      re-keying, no duplication) and is only given the byte-offset ``span`` L1
+      could not compute.
+    * ``cfg`` — one ``CfgEdge`` per CFG edge, endpoints as local ids.
     * ``cdg`` — the PDG's control-dependence edges.
     * ``ddg`` — the PDG's syntactic def-use edges, each with ``prov=["ssa"]``
       (no points-to provenance at L3; that is the L4 delta).
@@ -261,50 +261,45 @@ def _span_of(source: str, node) -> Optional["Span"]:
             im = IdentityMap.for_function(callable_id, pdg)
 
             for node in pdg.cfg.nodes:
-                ordinal = im.ordinal(node.id)
+                local = im.local(node.id)
                 if node.id == pdg.cfg.entry_id:
-                    pycallable.body[ordinal] = BodyNode(kind="entry")
+                    pycallable.body[local] = BodyNode(kind="entry")
                     continue
                 if node.id == pdg.cfg.exit_id:
-                    pycallable.body[ordinal] = BodyNode(kind="exit")
+                    pycallable.body[local] = BodyNode(kind="exit")
                     continue
                 span = _span_of(source, node)
-                # An L1 `call` node was keyed by its "line:col"; if this CFG node
-                # sits at the same position, keep that node's `call` kind and
-                # resolved `callee` and merely re-key it onto the ordinal id
-                # (dedup + endpoint resolution), filling any missing span.
-                existing = pycallable.body.get(ordinal)
-                if existing is None:
-                    existing = pycallable.body.pop(
-                        f"{node.start_line}:{node.start_column}", None
-                    )
+                # An L1 `call` node was keyed by its LOCAL "line:col"; this CFG
+                # node at the same position lands on the SAME key, so keep the
+                # node's `call` kind and L2-resolved `callee` in place and just
+                # fill any missing span — never re-key or duplicate it.
+                existing = pycallable.body.get(local)
                 if existing is not None:
                     if existing.span is None and span is not None:
                         existing.span = span
-                    pycallable.body[ordinal] = existing
                     continue
-                pycallable.body[ordinal] = BodyNode(kind=node.kind, span=span)
+                pycallable.body[local] = BodyNode(kind=node.kind, span=span)
 
             if want_cfg:
                 pycallable.cfg = [
                     CfgEdge(
-                        src=im.ordinal(e.source),
-                        dst=im.ordinal(e.target),
+                        src=im.local(e.source),
+                        dst=im.local(e.target),
                         kind=e.kind,
                     )
                     for e in pdg.cfg.edges
                 ]
             if want_pdg:
                 pycallable.cdg = [
-                    CdgEdge(src=im.ordinal(e.source), dst=im.ordinal(e.target))
+                    CdgEdge(src=im.local(e.source), dst=im.local(e.target))
                     for e in pdg.edges
                     if e.type == "CDG"
                 ]
             if want_ddg:
                 pycallable.ddg = [
                     DdgEdge(
-                        src=im.ordinal(e.source),
-                        dst=im.ordinal(e.target),
+                        src=im.local(e.source),
+                        dst=im.local(e.target),
                         var=e.var,
                         prov=["ssa"],
                     )

codeanalyzer/dataflow/identity.py

@@ -1,31 +1,46 @@
-"""Bijection between internal IR node ids (ints, per function) and canonical
-ordinal ids `<callable can:// id>@<tag>` — `@entry`/`@exit` for the synthetic
-CFG bookends, `@line:col` for real statements. Both emitters consume this so
-JSON body-node ids and Neo4j PyCFGNode keys are identical."""
+"""Bijection between internal IR node ids (ints, per function) and their
+canonical ids.
+
+Two forms per node:
+
+* **local** — the intra-callable id used as the ``body`` map key and as every
+  ``cfg``/``cdg``/``ddg`` edge endpoint: ``"@entry"``/``"@exit"`` for the
+  synthetic CFG bookends, ``"line:col"`` for real statements. This matches the
+  key format L1 already uses for ``call`` nodes (see ``schema/l1_body.py``), so
+  an L1 body node and its coinciding CFG node land on the same key and L1 ⊆ L3
+  holds.
+* **global** — ``"<callable can:// id>@<local>"``, the fully addressable id for
+  cross-callable references and the Neo4j PyCFGNode keys (a later task).
+"""
 from __future__ import annotations
 from typing import Dict, Iterable
 
 
 class IdentityMap:
-    def __init__(self, callable_id: str, id_to_ordinal: Dict[int, str]):
+    def __init__(self, callable_id: str, id_to_local: Dict[int, str]):
         self._callable_id = callable_id
-        self._map = id_to_ordinal
+        self._map = id_to_local
 
     @classmethod
     def for_function(cls, callable_id: str, pdg) -> "IdentityMap":
         cfg = pdg.cfg
         m: Dict[int, str] = {}
         for n in cfg.nodes:
             if n.id == cfg.entry_id:
-                m[n.id] = f"{callable_id}@entry"
+                m[n.id] = "@entry"
             elif n.id == cfg.exit_id:
-                m[n.id] = f"{callable_id}@exit"
+                m[n.id] = "@exit"
             else:
-                m[n.id] = f"{callable_id}@{n.start_line}:{n.start_column}"
+                m[n.id] = f"{n.start_line}:{n.start_column}"
         return cls(callable_id, m)
 
-    def ordinal(self, node_id: int) -> str:
+    def local(self, node_id: int) -> str:
+        """Intra-callable id: ``"@entry"``/``"@exit"`` or ``"line:col"``."""
         return self._map[node_id]
 
+    def global_id(self, node_id: int) -> str:
+        """Fully addressable id: ``"<callable-id>@<local>"``."""
+        return f"{self._callable_id}@{self._map[node_id]}"
+
     def node_ids(self) -> Iterable[int]:
         return self._map.keys()

test/test_v2_l3.py

@@ -5,6 +5,7 @@
 from codeanalyzer.dataflow.identity import IdentityMap
 from codeanalyzer.dataflow.syntactic import SyntacticOracle
 from codeanalyzer.schema.assign_ids import assign_ids
+from codeanalyzer.schema.l1_body import populate_l1_body
 from codeanalyzer.schema.py_schema import PyApplication
 from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
 
@@ -21,13 +22,16 @@ def node_by_id(self, i): return self._n[i]
 class _PDG:
     def __init__(self, cfg): self.cfg = cfg
 
-def test_ordinal_ids_for_entry_exit_and_statements():
+def test_local_and_global_ids_for_entry_exit_and_statements():
     nodes = [_Node(0, 1, 0, "entry"), _Node(1, 2, 4, "statement"), _Node(2, 3, 4, "exit")]
     pdg = _PDG(_CFG(nodes, entry_id=0, exit_id=2))
     im = IdentityMap.for_function("can://python/app/m.py/f()", pdg)
-    assert im.ordinal(0) == "can://python/app/m.py/f()@entry"
-    assert im.ordinal(1) == "can://python/app/m.py/f()@2:4"
-    assert im.ordinal(2) == "can://python/app/m.py/f()@exit"
+    # LOCAL ids: intra-callable keys (match l1_body's "line:col" format).
+    assert im.local(0) == "@entry"
+    assert im.local(1) == "2:4"
+    assert im.local(2) == "@exit"
+    # GLOBAL id: fully addressable form for Neo4j / cross-callable use.
+    assert im.global_id(1) == "can://python/app/m.py/f()@2:4"
     assert set(im.node_ids()) == {0, 1, 2}
 
 
@@ -40,19 +44,36 @@ def test_syntactic_oracle_only_identity_aliases():
 
 def test_emit_l3_populates_body_and_cfg(tmp_path: Path):
     f = tmp_path / "m.py"
-    f.write_text("def f(a):\n    b = a\n    return b\n", encoding="utf-8")
+    f.write_text("def f(a):\n    b = a\n    g(b)\n    return b\n", encoding="utf-8")
     mod = SymbolTableBuilder(tmp_path, None).build_pymodule_from_file(f)
     app = PyApplication(symbol_table={"m.py": mod})
     sig_to_id = assign_ids(app, "app")
+    # L1 materializes the `g(b)` call as a LOCAL "line:col" body node; simulate
+    # the L2 callee refinement so we can prove L3 preserves it (no re-key).
+    populate_l1_body(app)
+    fn = next(iter(mod.functions.values()))
+    call_key = "3:4"
+    assert fn.body[call_key].kind == "call"
+    fn.body[call_key].callee = "m.g"
+
     infos, _func_asts = build_function_pdgs(
         app, k=3, oracle_factory=lambda c: SyntacticOracle()
     )
     emit_l3_body(app, infos, sig_to_id, graphs={"cfg", "dfg", "pdg"})
-    fn = next(iter(mod.functions.values()))
-    assert any(k.endswith("@entry") for k in fn.body)
-    assert any(k.endswith("@exit") for k in fn.body)
+
+    # body keys are LOCAL: "@entry"/"@exit" bookends + bare "line:col" stmts,
+    # never the full "<callable-id>@..." form.
+    assert "@entry" in fn.body
+    assert "@exit" in fn.body
+    assert any(k not in ("@entry", "@exit") and ":" in k for k in fn.body)
+    assert not any(k.startswith("can://") for k in fn.body)
+    # the L1 call node is PRESERVED under its local key (not duplicated, not
+    # re-keyed): still kind=="call" with its L2-resolved callee.
+    assert fn.body[call_key].kind == "call"
+    assert fn.body[call_key].callee == "m.g"
+
     assert len(fn.cfg) > 0
-    # every cfg endpoint resolves to a body node id
+    # every cfg endpoint resolves to a (local) body node id
     body_ids = set(fn.body)
     for e in fn.cfg:
         assert e.src in body_ids and e.dst in body_ids