codeanalyzer-python 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codeanalyzer/neo4j/project.py

@@ -47,7 +47,7 @@ from codeanalyzer.schema import (
     PyModule,
     PyVariableDeclaration,
 )
-from codeanalyzer.schema.py_schema import PyCallsite
+from codeanalyzer.schema.py_schema import PyDecorator
 
 
 def project(app: PyApplication, app_name: str, sig_to_id: dict,
@@ -98,7 +98,7 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
 
     # Level-3 CPG overlay: each callable's v2 body/cfg/cdg/ddg. Idempotent under
     # MERGE — a no-op when no callable carries L3 fields (levels 1/2).
-    _project_program_graphs(b, app)
+    _project_program_graphs(b, app, externals, sig_to_id)
 
     return b.finish()
 
@@ -109,7 +109,7 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
 
 
 def _global_ordinal(callable_id: str, local_key: str) -> str:
-    """The globally-unique PyCFGNode merge key for a callable's body node: the
+    """The globally-unique PyBodyNode merge key for a callable's body node: the
     callable's ``can://`` id joined to its LOCAL body key with a single ``@``.
     The synthetic bookends already carry the leading ``@`` (``"@entry"``/
     ``"@exit"``); real statements are bare ``"line:col"`` and gain the ``@``.
@@ -124,18 +124,20 @@ def _global_ordinal(callable_id: str, local_key: str) -> str:
     )
 
 
-def _cfg_ref(callable_id: str, local_key: str) -> NodeRef:
-    return NodeRef("PyCFGNode", "id", _global_ordinal(callable_id, local_key))
+def _body_ref(callable_id: str, local_key: str) -> NodeRef:
+    return NodeRef("PyBodyNode", "id", _global_ordinal(callable_id, local_key))
 
 
-def _project_program_graphs(b: RowBuilder, app: PyApplication) -> None:
+def _project_program_graphs(
+    b: RowBuilder, app: PyApplication, externals: dict, sig_to_id: dict
+) -> None:
     """Level-3 CPG overlay, projected off each callable's v2 ``body``/``cfg``/
     ``cdg``/``ddg`` (populated by ``emit_l3_body`` at ``-a 3``; empty otherwise).
 
-    Node label ``PyCFGNode`` (merge key ``id`` = the GLOBAL ordinal
+    Node label ``PyBodyNode`` (merge key ``id`` = the GLOBAL ordinal
     ``<callable can:// id>@<local body key>`` — identical to the JSON body key
     prefixed with the callable id, so the two projections agree). Edges:
-    ``PY_HAS_CFG_NODE`` from the owning callable, ``PY_CFG_NEXT`` (prop ``kind``)
+    ``PY_HAS_BODY_NODE`` from the owning callable, ``PY_CFG_NEXT`` (prop ``kind``)
     over the CFG, ``PY_CDG`` over control dependence, and ``PY_DDG`` (props
     ``var``/``prov``) over data dependence. The vocabulary is cross-language in
     shape but PY_-namespaced like every other row family, so a multi-language
@@ -149,7 +151,7 @@ def _project_program_graphs(b: RowBuilder, app: PyApplication) -> None:
     each callable's transitive pass-throughs (LOCAL ids → global refs), and the
     app-level ``PY_PARAM_IN``/``PY_PARAM_OUT`` edges connect actual↔formal
     vertices across callables (endpoints are already GLOBAL ordinals matching the
-    emitted ``PyCFGNode`` keys). All idempotent under MERGE — no-ops below L4."""
+    emitted ``PyBodyNode`` keys). All idempotent under MERGE — no-ops below L4."""
     from codeanalyzer.semantic_analysis.call_graph import _walk_module_callables
 
     for file_key, mod in app.symbol_table.items():
@@ -163,7 +165,7 @@ def _project_program_graphs(b: RowBuilder, app: PyApplication) -> None:
                 # their owning callsite (``parent``) instead of span lines; both
                 # are None on ordinary statement nodes and pruned away there.
                 ref = b.node(
-                    ["PyCFGNode"],
+                    ["PyBodyNode"],
                     "id",
                     _global_ordinal(c.id, local_key),
                     prune(
@@ -173,23 +175,43 @@ def _project_program_graphs(b: RowBuilder, app: PyApplication) -> None:
                             "end_line": span.end[0] if span else None,
                             "var": node.of,
                             "call_node": node.parent,
+                            # Call-site detail (#120). The JSON emits one node per
+                            # call site; the graph now does too, instead of a
+                            # separate :PyCallSite under a third id scheme.
+                            "method_name": node.method_name,
+                            "receiver_expr": node.receiver_expr,
+                            "receiver_type": node.receiver_type,
+                            "return_type": node.return_type,
+                            "is_constructor_call": node.is_constructor_call,
+                            "arguments_json": _stringify_if(node.arguments),
                             "_module": file_key,
                         }
                     ),
                 )
-                b.edge("PY_HAS_CFG_NODE", owner, ref)
+                b.edge("PY_HAS_BODY_NODE", owner, ref)
+                if node.kind == "call" and node.callee:
+                    # `callee` is ALREADY a resolved can:// id (a declared callable
+                    # or an @external home), so it must not go through
+                    # `_symbol_ref`, which expects a dotted signature and would
+                    # fall back to matching a `signature` property against an id --
+                    # emitting an edge that matches nothing at load time.
+                    b.edge(
+                        "PY_RESOLVES_TO",
+                        ref,
+                        _call_endpoint(b, node.callee, externals, sig_to_id),
+                    )
             for e in c.cfg or []:
                 # kind-discriminated: a conditional's true/false pair between one
                 # endpoint pair must stay two relationships, not one MERGE.
                 b.edge(
                     "PY_CFG_NEXT",
-                    _cfg_ref(c.id, e.src),
-                    _cfg_ref(c.id, e.dst),
+                    _body_ref(c.id, e.src),
+                    _body_ref(c.id, e.dst),
                     {"kind": e.kind},
                     key=e.kind,
                 )
             for e in c.cdg or []:
-                b.edge("PY_CDG", _cfg_ref(c.id, e.src), _cfg_ref(c.id, e.dst))
+                b.edge("PY_CDG", _body_ref(c.id, e.src), _body_ref(c.id, e.dst))
             for e in c.ddg or []:
                 # (var, prov)-discriminated: the DDG legitimately carries several
                 # edges between one statement pair (one per variable, and the
@@ -197,32 +219,32 @@ def _project_program_graphs(b: RowBuilder, app: PyApplication) -> None:
                 # them and silently drops dependences.
                 b.edge(
                     "PY_DDG",
-                    _cfg_ref(c.id, e.src),
-                    _cfg_ref(c.id, e.dst),
+                    _body_ref(c.id, e.src),
+                    _body_ref(c.id, e.dst),
                     prune({"var": e.var, "prov": list(e.prov) if e.prov else None}),
                     key=f"{e.var or ''}|{','.join(e.prov or [])}",
                 )
             # L4 intraprocedural summaries (transitive actual_in → actual_out
-            # pass-throughs); LOCAL ids resolved to global PyCFGNode refs.
+            # pass-throughs); LOCAL ids resolved to global PyBodyNode refs.
             for e in c.summary or []:
-                b.edge("PY_SUMMARY", _cfg_ref(c.id, e.src), _cfg_ref(c.id, e.dst))
+                b.edge("PY_SUMMARY", _body_ref(c.id, e.src), _body_ref(c.id, e.dst))
 
     # L4 interprocedural parameter passing, emitted once at the app scope. The
     # endpoints are ALREADY global ordinals (emit_l4 resolved them through the
-    # endpoint functions' identity maps), so they land on the very PyCFGNode ids
+    # endpoint functions' identity maps), so they land on the very PyBodyNode ids
     # projected above — a formal_in global id equals _global_ordinal(callee.id,
     # "@formal_in:0"). No dangling references.
     for e in app.param_in or []:
         b.edge(
             "PY_PARAM_IN",
-            NodeRef("PyCFGNode", "id", e.src),
-            NodeRef("PyCFGNode", "id", e.dst),
+            NodeRef("PyBodyNode", "id", e.src),
+            NodeRef("PyBodyNode", "id", e.dst),
         )
     for e in app.param_out or []:
         b.edge(
             "PY_PARAM_OUT",
-            NodeRef("PyCFGNode", "id", e.src),
-            NodeRef("PyCFGNode", "id", e.dst),
+            NodeRef("PyBodyNode", "id", e.src),
+            NodeRef("PyBodyNode", "id", e.dst),
         )
 
 
@@ -369,6 +391,9 @@ def _project_class(
     )
     b.edge(parent_rel, parent, ref)
 
+    for d in cl.decorators or []:
+        _project_decorator(b, ref, d)
+
     for base in cl.base_classes or []:
         if base:
             b.edge_to_symbol("PY_EXTENDS", ref, _symbol_ref(base, externals, sig_to_id))
@@ -397,19 +422,6 @@ def _project_callable(
     for d in c.decorators or []:
         _project_decorator(b, ref, d)
 
-    for s in c.call_sites or []:
-        # Key off the relative file (a call site lives in its callable's file) so ids stay portable.
-        cs_id = (
-            f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
-        )
-        cs = b.node(["PyCallSite"], "id", cs_id, _call_site_props(s, file_key))
-        b.edge("PY_HAS_CALLSITE", ref, cs)
-        if s.callee_signature:
-            b.edge_to_symbol(
-                "PY_RESOLVES_TO", cs,
-                _symbol_ref(s.callee_signature, externals, sig_to_id),
-            )
-
     for v in c.local_variables or []:
         _project_variable(b, file_key, ref, c.signature, v)
     for ic in (c.callables or {}).values():
@@ -439,9 +451,36 @@ def _project_variable(
     b.edge("PY_DECLARES_VAR", owner, ref)
 
 
-def _project_decorator(b: RowBuilder, on: NodeRef, decorator: str) -> None:
-    dec = b.node(["PyDecorator"], "name", decorator, {"name": decorator})
-    b.edge("PY_DECORATED_BY", on, dec)
+def _project_decorator(b: RowBuilder, on: NodeRef, decorator: PyDecorator) -> None:
+    """Project one decorator application (#128).
+
+    The merge key is the resolved ``qualified_name`` when Jedi supplies one, so
+    ``@lru_cache`` and ``@lru_cache(maxsize=128)`` land on one node instead of two,
+    and two spellings of one decorator stop being separate nodes. Unresolved
+    decorators fall back to the written spelling. Per-application facts (the
+    arguments) ride on the relationship, not the shared node -- ``:PyDecorator``
+    has no ``_module`` and is never pruned, so anything application-specific on it
+    would accumulate across every project in the database.
+    """
+    key = decorator.qualified_name or decorator.name
+    dec = b.node(
+        ["PyDecorator"],
+        "name",
+        key,
+        {"name": key, "qualified_name": decorator.qualified_name or ""},
+    )
+    b.edge(
+        "PY_DECORATED_BY",
+        on,
+        dec,
+        {
+            "expression": decorator.expression or "",
+            "positional_arguments": list(decorator.positional_arguments or []),
+            "keyword_arguments_json": json.dumps(
+                dict(decorator.keyword_arguments or {}), sort_keys=True
+            ),
+        },
+    )
 
 
 # ----------------------------------------------------------------------------------------------
@@ -482,10 +521,13 @@ def _class_props(cl: PyClass, file_key: str, source: str) -> Props:
             "name": cl.name,
             "code": _span_code(source, cl.span),
             "base_classes": list(cl.base_classes or []),
+            "decorators": [d.qualified_name or d.name for d in (cl.decorators or [])],
             "docstring": _docstring_of(cl.comments),
             "start_line": cl.start_line,
             "end_line": cl.end_line,
             "_module": file_key,
+            "is_entrypoint": bool(cl.entrypoints),
+            "entrypoint_frameworks": sorted({e.framework for e in (cl.entrypoints or [])}),
         }
     )
 
@@ -504,10 +546,13 @@ def _callable_props(c: PyCallable, file_key: str, source: str) -> Props:
             "start_line": c.start_line,
             "end_line": c.end_line,
             "docstring": _docstring_of(c.comments),
-            "decorators": list(c.decorators or []),
+            "decorators": [d.qualified_name or d.name for d in (c.decorators or [])],
+            "modifiers": list(c.modifiers or []),
             "parameters_json": _stringify_if(c.parameters),
             "accessed_symbols_json": _stringify_if(c.accessed_symbols),
             "_module": file_key,
+            "is_entrypoint": bool(c.entrypoints),
+            "entrypoint_frameworks": sorted({e.framework for e in (c.entrypoints or [])}),
         }
     )
 
@@ -542,26 +587,6 @@ def _variable_props(v: PyVariableDeclaration, var_id: str, file_key: str) -> Pro
     )
 
 
-def _call_site_props(s: PyCallsite, file_key: str) -> Props:
-    cs_id = f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
-    return prune(
-        {
-            "id": cs_id,
-            "method_name": s.method_name,
-            "receiver_expr": s.receiver_expr,
-            "receiver_type": s.receiver_type,
-            "argument_types": list(s.argument_types or []),
-            "arguments_json": _stringify_if(s.arguments),
-            "return_type": s.return_type,
-            "callee_signature": s.callee_signature,
-            "is_constructor_call": s.is_constructor_call,
-            "start_line": s.start_line,
-            "start_column": s.start_column,
-            "end_line": s.end_line,
-            "end_column": s.end_column,
-            "_module": file_key,
-        }
-    )
 
 
 def _call_edge_props(weight: int, prov: List[str]) -> Props:

codeanalyzer/neo4j/schema.py

@@ -101,9 +101,12 @@ NODE_LABELS: List[NodeLabel] = [
             "name": "string",
             "code": "string",
             "base_classes": "string[]",
+            "decorators": "string[]",
             "docstring": "string",
             **_SPAN,
             "_module": "string",
+            "is_entrypoint": "boolean",
+            "entrypoint_frameworks": "string[]",
         },
     ),
     NodeLabel(
@@ -122,9 +125,12 @@ NODE_LABELS: List[NodeLabel] = [
             **_SPAN,
             "docstring": "string",
             "decorators": "string[]",
+            "modifiers": "string[]",
             "parameters_json": "string",
             "accessed_symbols_json": "string",
             "_module": "string",
+            "is_entrypoint": "boolean",
+            "entrypoint_frameworks": "string[]",
         },
     ),
     NodeLabel(
@@ -138,28 +144,7 @@ NODE_LABELS: List[NodeLabel] = [
         "PyDecorator",
         "PyDecorator",
         "name",
-        {"name": "string"},
-    ),
-    NodeLabel(
-        "PyCallSite",
-        "PyCallSite",
-        "id",
-        {
-            "id": "string",
-            "method_name": "string",
-            "receiver_expr": "string",
-            "receiver_type": "string",
-            "argument_types": "string[]",
-            "arguments_json": "string",
-            "return_type": "string",
-            "callee_signature": "string",
-            "is_constructor_call": "boolean",
-            "start_line": "integer",
-            "start_column": "integer",
-            "end_line": "integer",
-            "end_column": "integer",
-            "_module": "string",
-        },
+        {"name": "string", "qualified_name": "string"},
     ),
     NodeLabel(
         "PyAttribute",
@@ -196,14 +181,22 @@ NODE_LABELS: List[NodeLabel] = [
     # another's. `id` = "<signature>#<node_id>"; parameter-passing nodes
     # (formal/actual in/out) ride the same label with `var`/`call_node`.
     NodeLabel(
-        "PyCFGNode",
-        "PyCFGNode",
+        "PyBodyNode",
+        "PyBodyNode",
         "id",
         {
             "id": "string",
             "kind": "string",
             "var": "string",
             "call_node": "string",
+            # Call-site detail (#120): the graph emits one node per call site,
+            # matching analysis.json, instead of a separate :PyCallSite.
+            "method_name": "string",
+            "receiver_expr": "string",
+            "receiver_type": "string",
+            "return_type": "string",
+            "is_constructor_call": "boolean",
+            "arguments_json": "string",
             **_SPAN,
             "_module": "string",
         },
@@ -219,8 +212,7 @@ REL_TYPES: List[RelType] = [
     RelType("PY_HAS_METHOD", ["PyClass"], ["PyCallable"]),
     RelType("PY_HAS_ATTRIBUTE", ["PyClass"], ["PyAttribute"]),
     RelType("PY_DECLARES_VAR", ["PyModule", "PyCallable"], ["PyVariable"]),
-    RelType("PY_HAS_CALLSITE", ["PyCallable"], ["PyCallSite"]),
-    RelType("PY_RESOLVES_TO", ["PyCallSite"], ["PyCallable", "PyExternal"]),
+    RelType("PY_RESOLVES_TO", ["PyBodyNode"], ["PyCallable", "PyExternal"]),
     RelType(
         "PY_CALLS",
         ["PyCallable", "PyExternal"],
@@ -234,21 +226,30 @@ REL_TYPES: List[RelType] = [
         ["PyModule", "PyPackage"],
         {"spellings": "string[]", "imported_names": "string[]", "aliases": "string[]"},
     ),
-    RelType("PY_DECORATED_BY", ["PyCallable"], ["PyDecorator"]),
+    RelType(
+        "PY_DECORATED_BY",
+        ["PyCallable", "PyClass"],
+        ["PyDecorator"],
+        {
+            "expression": "string",
+            "positional_arguments": "string[]",
+            "keyword_arguments_json": "string",
+        },
+    ),
     # Level-3 CPG overlay (-a 3 only): the cross-language dataflow vocabulary,
     # PY_-namespaced so per-language SDK backends can scope their queries.
-    RelType("PY_HAS_CFG_NODE", ["PyCallable"], ["PyCFGNode"]),
+    RelType("PY_HAS_BODY_NODE", ["PyCallable"], ["PyBodyNode"]),
     # ``_k`` is the relationship-identity discriminant (internal, underscore-
     # prefixed like ``_module``): PY_CFG_NEXT merges per ``kind`` (a conditional's
     # true/false pair), PY_DDG per ``(var, prov)`` (one dependence per variable,
     # and the ssa/points-to split) — a plain endpoint-pair MERGE would collapse
     # legitimately-distinct edges.
-    RelType("PY_CFG_NEXT", ["PyCFGNode"], ["PyCFGNode"], {"kind": "string", "_k": "string"}),
-    RelType("PY_CDG", ["PyCFGNode"], ["PyCFGNode"]),
-    RelType("PY_DDG", ["PyCFGNode"], ["PyCFGNode"], {"var": "string", "prov": "string[]", "_k": "string"}),
-    RelType("PY_PARAM_IN", ["PyCFGNode"], ["PyCFGNode"], {"var": "string"}),
-    RelType("PY_PARAM_OUT", ["PyCFGNode"], ["PyCFGNode"], {"var": "string"}),
-    RelType("PY_SUMMARY", ["PyCFGNode"], ["PyCFGNode"]),
+    RelType("PY_CFG_NEXT", ["PyBodyNode"], ["PyBodyNode"], {"kind": "string", "_k": "string"}),
+    RelType("PY_CDG", ["PyBodyNode"], ["PyBodyNode"]),
+    RelType("PY_DDG", ["PyBodyNode"], ["PyBodyNode"], {"var": "string", "prov": "string[]", "_k": "string"}),
+    RelType("PY_PARAM_IN", ["PyBodyNode"], ["PyBodyNode"], {"var": "string"}),
+    RelType("PY_PARAM_OUT", ["PyBodyNode"], ["PyBodyNode"], {"var": "string"}),
+    RelType("PY_SUMMARY", ["PyBodyNode"], ["PyBodyNode"]),
 ]
 
 

codeanalyzer/options/__init__.py

@@ -1,3 +1,3 @@
-from .options import AnalysisOptions, EmitTarget, OutputFormat, ShardStrategy
+from .options import AnalysisOptions, EmitTarget
 
-__all__ = ["AnalysisOptions", "EmitTarget", "OutputFormat", "ShardStrategy"]
+__all__ = ["AnalysisOptions", "EmitTarget"]

codeanalyzer/options/options.py

@@ -1,14 +1,9 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 from enum import Enum
 
 
-class OutputFormat(str, Enum):
-    JSON = "json"
-    MSGPACK = "msgpack"
-
-
 class EmitTarget(str, Enum):
     """Output target selected by ``--emit``.
 
@@ -23,25 +18,10 @@ class EmitTarget(str, Enum):
     SCHEMA = "schema"
 
 
-class ShardStrategy(str, Enum):
-    """How ``--pycg-shard`` groups files into shards (level 2 only).
-
-    - ``jedi``    : partition the Jedi module-dependency graph (strongly-
-                    connected-component condensation + Louvain) so tightly-
-                    coupled modules co-compute and few call edges are severed
-                    between shards. Import cycles are never split.
-    - ``package`` : legacy one-shard-per-package-directory grouping.
-    """
-
-    JEDI = "jedi"
-    PACKAGE = "package"
-
-
 @dataclass
 class AnalysisOptions:
     input: Path
     output: Optional[Path] = None
-    format: OutputFormat = OutputFormat.JSON
     emit: EmitTarget = EmitTarget.JSON
     app_name: Optional[str] = None
     neo4j_uri: Optional[str] = None
@@ -61,8 +41,4 @@ class AnalysisOptions:
     cache_dir: Optional[Path] = None
     clear_cache: bool = False
     verbosity: int = 0
-    pycg_shard: bool = False
-    pycg_shard_ceiling: int = 100
-    pycg_shard_timeout: int = 120
-    pycg_shard_strategy: ShardStrategy = ShardStrategy.JEDI
-    pycg_max_iter: int = 50
+    entrypoint_rules: Tuple[Path, ...] = ()

codeanalyzer/schema/__init__.py

@@ -62,6 +62,31 @@ if not PYDANTIC_V2:
     )
     Analysis.update_forward_refs(PyApplication=PyApplication)
     
+# Fields the analyzer keeps in memory (and in the cache) but never emits.
+# `call_sites` is the internal record `body{}` call nodes are derived from (#120);
+# emitting both shipped the same fact twice under two identity schemes.
+INTERNAL_ONLY_FIELDS = frozenset({"call_sites"})
+
+
+def strip_internal_only(data):
+    """Recursively drop `INTERNAL_ONLY_FIELDS` from a dumped payload.
+
+    Applied at emit time rather than as a field-level Pydantic `exclude`, because
+    the analysis cache uses the same serializer -- excluding at the field would
+    drop these from the cache as well, and the next warm-cache run would rebuild
+    from a payload with no call sites.
+    """
+    if isinstance(data, dict):
+        return {
+            k: strip_internal_only(v)
+            for k, v in data.items()
+            if k not in INTERNAL_ONLY_FIELDS
+        }
+    if isinstance(data, list):
+        return [strip_internal_only(v) for v in data]
+    return data
+
+
 # Compatibility helpers for Pydantic v1/v2
 def model_dump_json(model, **kwargs):
     """Compatibility helper for JSON serialization."""
@@ -79,6 +104,27 @@ def model_dump_json(model, **kwargs):
             v1_kwargs['separators'] = kwargs['separators']
         return model.json(**v1_kwargs)
 
+def model_dump(model, **kwargs):
+    """Compatibility helper for dict serialization (v2 model_dump / v1 dict).
+
+    ``mode="json"`` (v2) maps to a json round-trip on v1 so both versions
+    yield JSON-safe primitives.
+    """
+    if PYDANTIC_V2:
+        return model.model_dump(**kwargs)
+    import json as _json
+    mode = kwargs.pop("mode", None)
+    v1_kwargs = {k: v for k, v in kwargs.items() if k in ("exclude_none", "exclude")}
+    if mode == "json":
+        return _json.loads(model.json(**v1_kwargs))
+    return model.dict(**v1_kwargs)
+
+
+def model_copy(model):
+    """Compatibility helper for copying a model (v2 model_copy / v1 copy)."""
+    return model.model_copy() if PYDANTIC_V2 else model.copy()
+
+
 def model_validate_json(model_class, json_data):
     """Compatibility helper for JSON deserialization."""
     if PYDANTIC_V2:
@@ -89,5 +135,7 @@ def model_validate_json(model_class, json_data):
 __all__.extend([
     "PYDANTIC_V2",
     "model_dump_json",
+    "strip_internal_only",
+    "INTERNAL_ONLY_FIELDS",
     "model_validate_json"
 ])

codeanalyzer/schema/l1_body.py

@@ -9,7 +9,17 @@ def _do_callable(source: str, c: PyCallable) -> None:
         span = Span(start=(cs.start_line, cs.start_column),
                     end=(cs.end_line, cs.end_column),
                     bytes=byte_offsets(source, cs.start_line, cs.start_column, cs.end_line, cs.end_column)) if source else None
-        c.body[key] = BodyNode(kind="call", span=span, callee=None)
+        c.body[key] = BodyNode(
+            kind="call",
+            span=span,
+            callee=None,
+            method_name=cs.method_name,
+            receiver_expr=cs.receiver_expr,
+            receiver_type=cs.receiver_type,
+            return_type=cs.return_type,
+            is_constructor_call=cs.is_constructor_call,
+            arguments=list(cs.arguments or []),
+        )
     for ic in (c.callables or {}).values():
         _do_callable(source, ic)
     for icl in (c.types or {}).values():

codeanalyzer/schema/l2_callees.py

@@ -1,36 +1,52 @@
 """L2 refinement: fill each L1 `call` body node's `callee` (null→id) from the
 call site's resolved signature — the one sanctioned value change. A declared
 target becomes its can:// id; an external/library target keeps its dotted
-signature; an unresolved call site leaves `callee` absent."""
+signature; an unresolved call site leaves `callee` absent.
+
+Two resolution sources feed the backfill: Jedi's `callee_signature` on the
+call site itself, and the defuse linker's returned map (keyed by caller
+signature + "line:col"). The linker's resolutions are deliberately NOT written
+into `callee_signature` — the symbol table round-trips through the analysis
+cache, and a persisted resolution would resurface on a warm run as a Jedi
+edge, silently changing provenance."""
 from __future__ import annotations
 from codeanalyzer.schema.py_schema import PyApplication, PyClass, PyCallable
 
 
-def _do_callable(c: PyCallable, sig_to_id: dict) -> None:
+def _do_callable(c: PyCallable, sig_to_id: dict, resolutions: dict) -> None:
     for cs in c.call_sites or []:
-        if cs.callee_signature is None:
-            continue
         key = f"{cs.start_line}:{cs.start_column}"
+        jedi_sig = cs.callee_signature
+        if jedi_sig and jedi_sig.startswith("typing."):
+            # A decorator-typed callable resolved to its annotation, not a
+            # target; the linker's resolution (if any) is the real callee.
+            jedi_sig = None
+        sig = jedi_sig or resolutions.get((c.signature, key))
+        if not sig:
+            continue
         node = c.body.get(key)
         if node is None or node.kind != "call":
             continue
-        node.callee = sig_to_id.get(cs.callee_signature, cs.callee_signature)
+        node.callee = sig_to_id.get(sig, sig)
     for ic in (c.callables or {}).values():
-        _do_callable(ic, sig_to_id)
+        _do_callable(ic, sig_to_id, resolutions)
     for icl in (c.types or {}).values():
-        _do_class(icl, sig_to_id)
+        _do_class(icl, sig_to_id, resolutions)
 
 
-def _do_class(cl: PyClass, sig_to_id: dict) -> None:
+def _do_class(cl: PyClass, sig_to_id: dict, resolutions: dict) -> None:
     for m in (cl.callables or {}).values():
-        _do_callable(m, sig_to_id)
+        _do_callable(m, sig_to_id, resolutions)
     for ic in (cl.types or {}).values():
-        _do_class(ic, sig_to_id)
+        _do_class(ic, sig_to_id, resolutions)
 
 
-def backfill_callees(app: PyApplication, sig_to_id: dict) -> None:
+def backfill_callees(
+    app: PyApplication, sig_to_id: dict, resolutions: dict | None = None
+) -> None:
+    resolutions = resolutions or {}
     for mod in app.symbol_table.values():
         for fn in (mod.functions or {}).values():
-            _do_callable(fn, sig_to_id)
+            _do_callable(fn, sig_to_id, resolutions)
         for cl in (mod.types or {}).values():
-            _do_class(cl, sig_to_id)
+            _do_class(cl, sig_to_id, resolutions)