cg-code-graph 0.23.11__tar.gz → 0.23.12__tar.gz

{cg_code_graph-0.23.11/cg_code_graph.egg-info → cg_code_graph-0.23.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.11
+Version: 0.23.12
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/__init__.py

@@ -1,2 +1,2 @@
 """code-graph: deterministic code knowledge graph (beta)."""
-__version__ = "0.23.11"
+__version__ = "0.23.12"

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/core/model.py

@@ -71,6 +71,7 @@ EDGE_KINDS: dict[str, tuple[bool, str]] = {
     "ACCESSES_FIELD": (True, "code reads/writes a struct/class field or enum variant"),
     "READS_PROP": (True, "code reads a stored property (field node: Swift `var x`, `@State`, `@Published`)"),
     "WRITES_PROP": (True, "code writes a stored property (assignment, compound assignment)"),
+    "SHARES_STORAGE": (False, "two stored properties persist under the same @AppStorage / @SceneStorage key"),
     "USES_VALUE": (True, "code refers to an enum case, a constant, a static/global variable or an object-like macro"),
     "REGISTERS_CALLBACK": (False, "function builds a callback URL for one of the app's own routes and registers it with an external party (attrs.body_key, endpoint)"),
     "REFERENCES_FN": (True, "code/data takes a function as a value (callback, dispatch table, handler registration)"),

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/core/plugin.py

@@ -88,7 +88,10 @@ class GraphBuilder:
         g = self.current_gate
         if g and g.get("src") != src:
             g = None  # only references made by the gated function itself carry the gate
-        key = (src, dst, kind, file, line, g["gate"] if g else None)
+        gate = g["gate"] if g else None
+        # a second branch of the same call on one line is its own edge (#235)
+        br = attrs.get("branch")
+        key = (src, dst, kind, file, line, gate, br) if br else (src, dst, kind, file, line, gate)
         if key in self.edges:
             return
         if g:

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/plugins/java/exact.py

@@ -57,6 +57,14 @@ _ANON_SEG = re.compile(r"^\$?anon\d*$")
 _ACCESSOR = re.compile(r"^(get|set|is)([A-Z]\w*)$")
 
 
+def _accessor_kind(symbol: str) -> str | None:
+    dd = scipread.descriptors(symbol)
+    if not dd or not dd[1]:
+        return None
+    m = _ACCESSOR.fullmatch(dd[1][-1][0])
+    return m.group(1) if m else None
+
+
 def is_anon_id(nid: str) -> bool:
     """True when a mapped id still contains a scip-java anonymous type segment (`$anon`)."""
     return any(_ANON_SEG.match(part) for part in nid.split(":", 1)[-1].split("."))
@@ -105,35 +113,25 @@ def bind_java_symbol(symbol: str, nodes, file: str, line: int) -> tuple[str, str
     return nid, kind
 
 
-def kotlin_accessor_target(symbol: str, nodes) -> tuple[str, str] | None:
-    """`(kotlin node id, edge kind)` for a JVM accessor call (`getX` / `setX` / `isX`).
-
-    `Widget#getName().` is `field:demo.Widget.name` with `READS_PROP`. `setX` is `WRITES_PROP`.
-    A custom accessor that is already a Kotlin method node is `CALLS`.
-    """
-    dd = scipread.descriptors(symbol)
-    if not dd or not dd[1]:
-        return None
-    names = [n for n in dd[1] if n[1] != ")"]
-    if not names or names[-1][1] != "(":
-        return None
-    m = _ACCESSOR.fullmatch(names[-1][0])
-    if not m:
-        return None
-    kind, raw = m.group(1), m.group(2)
+def _property_names(kind: str, raw: str) -> list[str]:
     prop = raw[:1].lower() + raw[1:]
-    owner = ".".join([n for n, s in names if s == "/"] + [n for n, s in names[:-1] if s == "#"])
-    if not owner:
-        return None
-    props = [prop]
+    names = [prop]
     if kind == "is":
-        props.append("is" + raw)
-    edge = "WRITES_PROP" if kind == "set" else "READS_PROP"
+        names.append("is" + raw)
+    return names
+
+
+def _owner_of(names: list[tuple[str, str]]) -> str:
+    return ".".join([n for n, s in names if s == "/"] + [n for n, s in names if s == "#"])
+
+
+def _find_kotlin_property(nodes, owner: str, props: list[str]) -> tuple[str, str] | None:
+    """`(node id, READS_PROP | CALLS)` for a stored field or a custom property node."""
     for p in props:
         fid = f"field:{owner}.{p}"
         node = nodes.get(fid)
         if node is not None and node.lang == "kotlin" and node.kind == "field":
-            return fid, edge
+            return fid, "READS_PROP"
     for p in props:
         for n in nodes.values():
             if (n.lang == "kotlin" and n.attrs.get("property") and (n.fqn or "").rsplit(".", 1)[0] == owner
@@ -142,6 +140,57 @@ def kotlin_accessor_target(symbol: str, nodes) -> tuple[str, str] | None:
     return None
 
 
+def kotlin_property_ref(symbol: str, nodes, spelling: str | None = None) -> tuple[str, str] | None:
+    """`(node id, edge kind)` for a property term (`Cart#label.`) or accessor (`getLabel().` / `setItems().` / `isReady().`).
+
+    A stored property is `READS_PROP` (`WRITES_PROP` for `setX`). A custom accessor node is `CALLS`.
+    `spelling` is the identifier at the occurrence: when it is the property (`label`, `items`) the
+    reference is a property use. When it is the accessor name itself (`getShapes`) this returns None,
+    so a declared `fun getShapes()` stays a call. Java passes no spelling and matches `getLabel`.
+    """
+    dd = scipread.descriptors(symbol)
+    if not dd or not dd[1]:
+        return None
+    names = [n for n in dd[1] if n[1] != ")"]
+    if not names:
+        return None
+    last, suf = names[-1]
+    if suf == ".":
+        props, write = [last], False
+    elif suf == "(":
+        m = _ACCESSOR.fullmatch(last)
+        if not m:
+            return None
+        kind, raw = m.group(1), m.group(2)
+        props, write = _property_names(kind, raw), kind == "set"
+    else:
+        return None
+    if spelling is not None and spelling not in props:
+        return None
+    owner = _owner_of(names[:-1])
+    if not owner:
+        return None
+    found = _find_kotlin_property(nodes, owner, props)
+    if found is None:
+        return None
+    nid, edge = found
+    if edge == "READS_PROP" and write:
+        return nid, "WRITES_PROP"
+    return nid, edge
+
+
+def kotlin_accessor_target(symbol: str, nodes) -> tuple[str, str] | None:
+    """`(kotlin node id, edge kind)` for a JVM accessor call (`getX` / `setX` / `isX`).
+
+    `Widget#getName().` is `field:demo.Widget.name` with `READS_PROP`. `setX` is `WRITES_PROP`.
+    A custom accessor that is already a Kotlin method node is `CALLS`.
+    """
+    dd = scipread.descriptors(symbol)
+    if not dd or not dd[1] or dd[1][-1][1] != "(":
+        return None
+    return kotlin_property_ref(symbol, nodes)
+
+
 class ExactLayer:
     def __init__(self, plugin):
         self.p = plugin
@@ -222,7 +271,16 @@ class ExactLayer:
                         st["scip_refs_external"] = st.get("scip_refs_external", 0) + 1
                     continue
                 if dst is None:
-                    if kotlin_accessor_target(o.symbol, self.b.nodes):
+                    acc = kotlin_accessor_target(o.symbol, self.b.nodes)
+                    if acc is not None:
+                        src = self._owner(owners, rel, o.line + 1)
+                        if src is not None and src != acc[0]:
+                            extra = {"binding": "kotlin-accessor"}
+                            if acc[1] == "CALLS":
+                                extra["property"] = "write" if _accessor_kind(o.symbol) == "set" else "read"
+                            self.b.add_edge(src, acc[0], acc[1], rel, o.line + 1, EXACT, source="scip", **extra)
+                            if acc[1] == "CALLS":
+                                exact.add((src, acc[0], "CALLS"))
                         continue
                     st["scip_refs_external"] = st.get("scip_refs_external", 0) + 1
                     continue

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/plugins/kotlin/exact.py

@@ -38,6 +38,7 @@ from pathlib import Path
 
 from ...core.model import EXACT, HEURISTIC
 from ...core.env import get as cg_env
+from ..java.exact import _accessor_kind, kotlin_property_ref
 from ..native import runner, scipread
 
 BUILD_FILES = ("build.gradle.kts", "build.gradle", "settings.gradle.kts", "settings.gradle", "pom.xml")
@@ -443,10 +444,13 @@ class ExactLayer:
         owners.update(jowners)
         for rel, doc in list(kdocs.items()) + list(jdocs.items()):
             java = rel in jdocs
-            # a property access `x.pets` is reported as the term `C#pets.` plus the synthetic accessor `C#getPets().`,
-            # which collides with a declared `fun getPets()`: accessors at a property reference are not calls
+            # a property access `x.pets` is the term `C#pets.` plus synthetic `getPets().` / `setPets().` at the
+            # property's spelling. That accessor symbol collides with a declared `fun getPets()`. Map the spelling
+            # to the property node; a call that spells `getPets` stays a call (#105).
             prop_at = {(o.line, o.col) for o in doc.occs if not (o.roles & scipread.DEFINITION)
                        and o.symbol.endswith(".") and not o.symbol.endswith(").")}
+            handled = set() if java else self._map_kotlin_properties(rel, doc, owners, st)
+            prop_at |= handled
             for o in doc.occs:
                 if o.roles & scipread.DEFINITION:
                     continue
@@ -473,7 +477,10 @@ class ExactLayer:
                         if acc is not None:
                             src = self._owner(owners, rel, o.line + 1)
                             if src is not None and src != acc[0]:
-                                self._upgrade(src, acc[0], acc[1], rel, o.line + 1)
+                                extra = {"binding": "kotlin-accessor"}
+                                if acc[1] == "CALLS":
+                                    extra["property"] = "write" if _accessor_kind(o.symbol) == "set" else "read"
+                                self._mark_exact(src, acc[0], acc[1], rel, o.line + 1, **extra)
                                 st["java"]["references"] += 1
                             continue
                     kind = "CALLS"
@@ -508,6 +515,7 @@ class ExactLayer:
             "recall": round(agree / len(exact), 3) if exact else None,
             # candidate edges (receiver type unknown, one per same-name method, #83) are compared on their own
             "candidate_edges": len(self.candidates), "candidate_agree": len(self.candidates & exact)}
+        self._drop_heuristic_properties(covered)
         rep = getattr(self.p, "file_report", None) or {}
         seen = set(getattr(self.p, "_seen_files", None) or rep.get("seen") or covered)
         st["scip_files"] = len({f for f in covered & seen if f.endswith(".kt")})
@@ -517,15 +525,108 @@ class ExactLayer:
         from ..java.exact import kotlin_accessor_target
         return kotlin_accessor_target(symbol, self.b.nodes)
 
-    def _upgrade(self, src: str, dst: str, kind: str, file: str, line: int) -> None:
-        """Replace a heuristic property edge in a covered file with the exact accessor edge."""
+    def _mark_exact(self, src: str, dst: str, kind: str, file: str, line: int, **attrs) -> None:
+        """Upgrade a syntax-layer property edge, or add the exact one."""
         key = (src, dst, kind, file, line, None)
         e = self.b.edges.get(key)
         if e is not None:
             e.confidence = EXACT
             e.attrs["source"] = "scip"
+            e.attrs.update(attrs)
             return
-        self.b.add_edge(src, dst, kind, file, line, EXACT, source="scip", binding="kotlin-accessor")
+        self.b.add_edge(src, dst, kind, file, line, EXACT, source="scip", **attrs)
+
+    def _map_kotlin_properties(self, rel: str, doc, owners: dict, st: dict) -> set:
+        """Property term and synthetic accessor occurrences at one spelling become exact read / write edges."""
+        buckets = defaultdict(list)
+        for o in doc.occs:
+            if o.roles & scipread.DEFINITION:
+                continue
+            buckets[(o.line, o.col)].append(o)
+        handled = set()
+        for (line, col), occs in buckets.items():
+            spell = self._spelling(rel, line, col)
+            if not spell:
+                continue
+            ref = None
+            for o in occs:
+                ref = kotlin_property_ref(o.symbol, self.b.nodes, spelling=spell)
+                if ref is not None:
+                    break
+            if ref is None:
+                continue
+            src = self._owner(owners, rel, line + 1)
+            handled.add((line, col))
+            if src is None or src == ref[0]:
+                continue
+            self._emit_kotlin_property(src, ref[0], rel, line, col, spell)
+            st["scip_property_edges"] = st.get("scip_property_edges", 0) + 1
+        return handled
+
+    def _emit_kotlin_property(self, src: str, dst: str, rel: str, line: int, col: int, spell: str) -> None:
+        node = self.b.nodes.get(dst)
+        if node is None:
+            return
+        mode = self._mode_at(rel, line, col, spell)
+        if node.kind == "field":
+            kinds = {"read": ("READS_PROP",), "write": ("WRITES_PROP",),
+                     "read_write": ("READS_PROP", "WRITES_PROP")}[mode]
+            for kind in kinds:
+                self._mark_exact(src, dst, kind, rel, line + 1)
+            return
+        acc = set(node.attrs.get("accessors") or [])
+        if mode == "write" and not ({"set", "delegate"} & acc):
+            mode = "read"
+        elif mode == "read_write" and not ({"set", "delegate"} & acc):
+            mode = "read"
+        self._mark_exact(src, dst, "CALLS", rel, line + 1, property=mode)
+
+    def _spelling(self, rel: str, line: int, col: int) -> str | None:
+        kf = getattr(self.p, "_kf_by_rel", {}).get(rel)
+        if kf is None or line < 0:
+            return None
+        lines = kf.src.splitlines()
+        if line >= len(lines):
+            return None
+        raw = lines[line]
+        if isinstance(raw, str):
+            raw = raw.encode()
+        if col < 0 or col >= len(raw):
+            return None
+        m = re.match(rb"[A-Za-z_][A-Za-z0-9_]*", raw[col:])
+        return m.group(0).decode() if m else None
+
+    def _mode_at(self, rel: str, line: int, col: int, spell: str) -> str:
+        """`read`, `write` (`name =`), or `read_write` (`+=`, `++`, `--`). scip-java emits get and set together."""
+        kf = getattr(self.p, "_kf_by_rel", {}).get(rel)
+        if kf is None or line < 0:
+            return "read"
+        lines = kf.src.splitlines()
+        if line >= len(lines):
+            return "read"
+        raw = lines[line]
+        if isinstance(raw, str):
+            raw = raw.encode()
+        if col < 0 or col + len(spell) > len(raw):
+            return "read"
+        after = raw[col + len(spell):]
+        before = raw[:col]
+        if re.match(br"\s*(\+\+|--)", after) or re.search(br"(\+\+|--)\s*$", before):
+            return "read_write"
+        if re.match(br"\s*[-+*/%]=", after):
+            return "read_write"
+        if re.match(br"\s*=(?!=)", after):
+            return "write"
+        return "read"
+
+    def _drop_heuristic_properties(self, covered: set) -> None:
+        """Covered Kotlin files keep the exact property edges, not the heuristic accessor calls."""
+        for key, e in list(self.b.edges.items()):
+            if e.confidence != HEURISTIC or e.file not in covered or not e.attrs.get("property"):
+                continue
+            n = self.b.nodes.get(e.src)
+            if n is not None and n.lang == "kotlin":
+                del self.b.edges[key]
 
     def _jvm_name_facade(self, symbol: str, sym: dict) -> str | None:
         """`pkg/JvmName#fn().` → the top-level `pkg/fn().` when `JvmName` is a Kotlin file's JVM facade."""
@@ -626,7 +727,7 @@ class ExactLayer:
             if e.confidence != HEURISTIC or e.file not in covered:
                 continue
             if e.attrs.get("property"):
-                continue      # property reads / writes (#89): scip-java reports them as accessors, not mapped yet
+                continue      # compared on their own; exact property edges replace them after mapping (#105)
             if e.kind == "REFERENCES_FN" and e.attrs.get("how") == "callback":
                 n = self.b.nodes.get(e.src)
                 if n is not None and n.lang == "kotlin":

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/plugins/kotlin/plugin.py

@@ -312,7 +312,7 @@ class KotlinPlugin(LanguagePlugin):
         self.members: dict[str, dict[str, list[Decl]]] = defaultdict(lambda: defaultdict(list))
         self.calls: list[tuple] = []
         self.unresolved_calls: list[tuple] = []          # (owner_id, name, receiver, line, file obj, decl)
-        self.call_branch: dict = {}           # (owner_id, line, name) -> {branch, branch_line} (#88)
+        self.call_branch: dict = defaultdict(list)  # (owner, line, name) -> branches in source order (#88, #235)
         self.call_default: dict = {}          # (owner_id, line, name) -> parameter whose default holds the call (#212)
         self.call_args: dict = {}             # (owner_id, line, name) -> (positional count, named labels, trailing lambda)
         self.fn_params: dict = {}             # function id -> [(name, has default, function type)]
@@ -322,6 +322,8 @@ class KotlinPlugin(LanguagePlugin):
         self.props_by_name: dict[str, list[Decl]] = defaultdict(list)
         self.prop_members: dict[str, dict[str, list[Decl]]] = defaultdict(lambda: defaultdict(list))
         self.prop_at: dict[tuple, Decl] = {}                               # (file, start byte) -> decl
+        # interface / abstract `val` with no accessor: a node only when an override has one (#105)
+        self.abstract_props: dict[str, dict[str, tuple]] = defaultdict(dict)
         self.locals: dict[tuple, list] = {}                                # (file, enclosing id) -> local functions
         self.stored_names: set[str] = set()                                # plain stored properties / ctor vals
         # stored properties of a class / enum are `field:<Type>.<name>` nodes with READS_PROP / WRITES_PROP (#88)
@@ -422,8 +424,8 @@ class KotlinPlugin(LanguagePlugin):
         mode = self._exact(project, files)
         st["mode"] = mode
         for k in ("exact_vs_heuristic", "scip_documents", "scip_files", "scip_defs_matched", "scip_defs_unmatched",
-                  "scip_defs_unmatched_samples", "scip_references", "scip_refs_external", "java", "scip",
-                  "interop_kotlin_to_java", "calls_resolved", "calls_unresolved"):
+                  "scip_defs_unmatched_samples", "scip_property_edges", "scip_references", "scip_refs_external", "java",
+                  "scip", "interop_kotlin_to_java", "calls_resolved", "calls_unresolved"):
             if k in self.st:
                 st[k] = self.st[k]
 
@@ -447,7 +449,7 @@ class KotlinPlugin(LanguagePlugin):
             except Exception as e:          # a corrupt / foreign index must not lose the heuristic graph
                 info["status"] = f"SCIP import failed ({type(e).__name__}: {e})"
             for k in ("exact_vs_heuristic", "scip_documents", "scip_files", "scip_defs_matched", "scip_defs_unmatched",
-                      "scip_defs_unmatched_samples",
+                      "scip_defs_unmatched_samples", "scip_property_edges",
                       "scip_references", "scip_refs_external", "java"):
                 if k in sst:
                     self.st[k] = sst[k]
@@ -595,6 +597,10 @@ class KotlinPlugin(LanguagePlugin):
                                                or self.t(x) in ("val", "var")), "val")
                                     if kk in ("class", "enum") and not self._is_constant(d, dc):
                                         self._field(dc, nm_, kw, kf, d)
+                                    _anns, pmods = self._annotations(d)
+                                    if kk == "interface" or "abstract" in pmods:
+                                        self.abstract_props[dc.fqn][nm_] = (
+                                            dc, nm_, kf.rel, d.start_point[0] + 1, d.end_point[0] + 1, pmods)
                     self._decls(body, kf, dc, None)
                 self.stored_names.update(types)
             elif ty == "function_declaration":
@@ -1022,6 +1028,8 @@ class KotlinPlugin(LanguagePlugin):
                 self._value_ref(c, kf, owner, decl)
             if (self.props_by_name or self.field_names) and ty in ("navigation_expression", "identifier"):
                 self._prop_ref(c, kf, owner, decl)
+            if (self.props_by_name or self.field_names) and ty == "string_literal":
+                self._template_idents(c, kf, owner, decl)
             if ty == "property_declaration" and (kf.rel, c.start_byte) in self.prop_at:
                 d = self.prop_at[(kf.rel, c.start_byte)]
                 self._refs(c, kf, d.id, d, {"prefix": "", "guards": [], "routing": False})
@@ -1215,10 +1223,8 @@ class KotlinPlugin(LanguagePlugin):
             self.call_args[(owner, line, name)] = (None if spread else len(vas) - len(named), named, lam is not None)
         elif lam is not None:
             self.call_args[(owner, line, name)] = (0, set(), True)
-        if name[:1].isupper():                      # a constructor or a composable: its branch (#88)
-            br = self._branch(c)
-            if br:
-                self.call_branch[(owner, line, name)] = br
+        if name[:1].isupper():                      # a constructor or a composable: its branch (#88, #235)
+            self.call_branch[(owner, line, name)].append(self._branch(c) or {})
         return False
 
     def _param_defaults(self, fvp) -> list:
@@ -1379,6 +1385,23 @@ class KotlinPlugin(LanguagePlugin):
                     w = "value"                      # `_state.value = x` on a MutableStateFlow / LiveData field
             self.frefs.append((owner, nm, rv, c.start_point[0] + 1, kf, decl, w))
 
+    def _template_idents(self, c, kf: KFile, owner: str, decl: Decl | None):
+        """`$count` inside a string (`"$count of $total"`) reads that name (#235). `${count}` is an identifier
+        node and is visited on its own; `\\$count` is not a template."""
+        raw = self.t(c)
+        if "$" not in raw:
+            return
+        base = c.start_point[0]
+        for m in re.finditer(r"(?<![\\$])\$([A-Za-z_][A-Za-z0-9_]*)(?!\{)", raw):
+            nm = m.group(1)
+            if nm not in self.props_by_name and nm not in self.field_names:
+                continue
+            line = base + raw.count("\n", 0, m.start()) + 1
+            if nm in self.props_by_name:
+                self.reads.append((owner, nm, None, line, kf, decl, "read"))
+            if nm in self.field_names:
+                self.frefs.append((owner, nm, None, line, kf, decl, False))
+
     def _helper_url(self, call_text: str, kf: KFile, builder: bool = False) -> str | None:
         """URL a project helper builds from a literal argument (#99), as a quoted string for `template`:
         `endpoint("items")` with `fun endpoint(p: String) = "$BASE/$p"` (a string result), or with `builder`, a
@@ -1636,6 +1659,8 @@ class KotlinPlugin(LanguagePlugin):
     def _resolve_calls(self):
         self._default_edges, self._default_sites = defaultdict(list), []
         for owner, name, recv, line, kf, decl, acc in self.calls:
+            q = self.call_branch.get((owner, line, name)) if name[:1].isupper() else None
+            br = q.pop(0) if q else {}
             self._data_access(owner, name, recv, line, kf, decl)
             self._how = self._recv = None
             targets = self._targets(name, recv, kf, decl)
@@ -1652,7 +1677,6 @@ class KotlinPlugin(LanguagePlugin):
             if self._how == "candidate":
                 how["candidates"] = len(targets)
                 self.st["call_candidate_edges"] += len(targets)
-            br = self.call_branch.get((owner, line, name), {})
             dp = self.call_default.get((owner, line, name))
             da = {"default_arg": dp} if dp else {}
             for t in targets[:MAX_CANDIDATES if self._how == "candidate" else 3]:
@@ -1997,6 +2021,12 @@ class KotlinPlugin(LanguagePlugin):
                 if recv is None and self._shadowed_local(decl, name, kf):
                     continue
                 fid = self._field_member(cls, name)
+                # `fun Cart.total() = items.size`: the name is the extension receiver's field (#235)
+                if fid is None and decl is not None and decl.receiver:
+                    rc = self._class_of(decl.receiver.split(".")[-1].strip(), kf)
+                    fid = self._field_member(rc, name)
+                    if fid is not None and recv is None:
+                        rt = decl.receiver.split(".")[-1].strip()
             elif recv[0] in ("identifier", "this_expression") or re.fullmatch(r"[\w.]+", rt or ""):
                 rname = rt.split(".")[-1].strip()
                 tyname = decl.types.get(rname) if decl is not None else None
@@ -2010,8 +2040,10 @@ class KotlinPlugin(LanguagePlugin):
             if fid is None or fid == owner:
                 self.st["stored_property_refs_unresolved"] += 1
                 continue
+            shown = rt if recv is None and rt not in (None, "this") else (
+                "this" if recv is None or rt == "this" else rt[:40])
             self.b.add_edge(owner, fid, "WRITES_PROP" if write else "READS_PROP", kf.rel, line, RESOLVED,
-                            receiver="this" if recv is None or rt == "this" else rt[:40],
+                            receiver=shown,
                             **({"via": write} if isinstance(write, str) else {}))
             self.st["stored_property_writes" if write else "stored_property_reads"] += 1
 
@@ -2345,6 +2377,62 @@ class KotlinPlugin(LanguagePlugin):
         own = [d for d in cands if "actual" in d.modifiers and kf.source_set and d.id.endswith(f"@{kf.source_set}")]
         return own or [d for d in cands if "actual" not in d.modifiers] or cands
 
+    def _link_property_overrides(self):
+        """`override val` with a property node implements or overrides the base property (#105).
+
+        An interface or abstract `val` with no accessor has no node until some override has one. The edge is
+        IMPLEMENTED_BY from an interface property and OVERRIDDEN_BY from an abstract or open property.
+        """
+        for d in list(self.decls.values()):
+            if d.id not in self.props or "override" not in d.modifiers or not d.cls:
+                continue
+            cls = self.classes.get(d.cls)
+            if cls is None:
+                continue
+            base = self._nearest_base_prop(cls, d.name)
+            if base is None or base.id == d.id:
+                continue
+            iface = self.b.nodes[f"class:{base.cls}"].attrs.get("kotlin_kind") == "interface" if base.cls else False
+            abstract = "abstract" in (base.modifiers or [])
+            ek = "IMPLEMENTED_BY" if iface else "OVERRIDDEN_BY"
+            if not iface and not abstract and "open" not in (base.modifiers or []) and base.id not in self.props:
+                continue
+            self.b.add_edge(base.id, d.id, ek, d.file, d.line, HEURISTIC)
+
+    def _nearest_base_prop(self, cls: Decl, name: str):
+        seen = set()
+        stack = list(cls.supers)
+        while stack:
+            s = stack.pop(0)
+            sc = self.classes.get(s) or (self.class_short.get(s) or [None])[0]
+            if sc is None or sc.fqn in seen or sc is cls:
+                continue
+            seen.add(sc.fqn)
+            hit = self.prop_members.get(sc.fqn, {}).get(name)
+            if hit:
+                return hit[0]
+            noted = self.abstract_props.get(sc.fqn, {}).get(name)
+            if noted:
+                return self._materialize_abstract_prop(*noted)
+            stack.extend(sc.supers)
+        return None
+
+    def _materialize_abstract_prop(self, cls: Decl, name: str, rel: str, line: int, end: int, mods) -> Decl:
+        existing = self.prop_members.get(cls.fqn, {}).get(name)
+        if existing:
+            return existing[0]
+        fq = f"{cls.fqn}.{name}"
+        dc = Decl(f"method:{fq}", "method", name, fq, rel, line, end, cls.fqn, [], [], set(mods), None, {},
+                  False, line)
+        self.props[dc.id] = {"property": "abstract", "accessors": [], "type": None}
+        self._add_decl(dc, "property", prop=True)
+        self.b.nodes[dc.id].attrs.update(property="abstract", accessors=[])
+        self.props_by_name[name].append(dc)
+        self.prop_members[cls.fqn][name].append(dc)
+        self.st["property_nodes"] += 1
+        self.st["abstract_property_nodes"] = self.st.get("abstract_property_nodes", 0) + 1
+        return dc
+
     def _field_type(self, cls: Decl, name: str, depth=0):
         if name in cls.types:
             return cls.types[name]
@@ -2369,6 +2457,7 @@ class KotlinPlugin(LanguagePlugin):
                         for m in ms:
                             ek = "IMPLEMENTED_BY" if kind == "IMPLEMENTS" or "abstract" in base.modifiers else "OVERRIDDEN_BY"
                             self.b.add_edge(base.id, m.id, ek, m.file, m.line, HEURISTIC)
+        self._link_property_overrides()
         # expect -> actual
         for d in list(self.decls.values()):
             if "actual" in d.modifiers:

{cg_code_graph-0.23.11 → cg_code_graph-0.23.12}/cg_code_graph/plugins/swift/exact.py

@@ -316,7 +316,7 @@ class ExactLayer:
                         continue
                     if prop is not None:
                         acc = {**acc, "property": "read" if accessor_kind.get(o.usr) == "getter" else "write"}
-                    br = self.p.branch_at.get((rel, o.line, self.b.nodes[dst].name), {}) \
+                    br = self._take_branch(rel, o.line, o.col, self.b.nodes[dst].name) \
                         if kind == "INSTANTIATES" else {}
                     da = self.default_args.get((dst, rel, o.line)) if kind == "CALLS" else None
                     self.b.add_edge(src, dst, kind, rel, o.line, EXACT, source="indexstore",
@@ -398,6 +398,28 @@ class ExactLayer:
                     return d.id
         return None
 
+    def _take_branch(self, rel, line, col, name) -> dict:
+        """The construction branch recorded for this occurrence. One branch on the line is that branch.
+        Several are matched by column, each used once (#235)."""
+        items = self.p.branch_at.get((rel, line, name)) or []
+        if not items:
+            return {}
+        if len(items) == 1:
+            return items[0][1]
+        used = self.__dict__.setdefault("_used_br", {})
+        seen = used.setdefault((rel, line, name), set())
+        best_i = best_d = None
+        for i, (c, _br) in enumerate(items):
+            if i in seen:
+                continue
+            d = abs((c or 0) - (col or 0))
+            if best_d is None or d < best_d:
+                best_i, best_d = i, d
+        if best_i is None:
+            return {}
+        seen.add(best_i)
+        return items[best_i][1]
+
     def _owner_type(self, rel, line):
         best = None
         for d in self._all_decls():