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

{cg_code_graph-0.23.10/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.10
+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.10 → 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.10"
+__version__ = "0.23.12"

{cg_code_graph-0.23.10 → cg_code_graph-0.23.12}/cg_code_graph/cli.py

@@ -317,7 +317,8 @@ def main(argv=None):
     p.add_argument("--json", action="store_true"); p.add_argument("--tests", action="store_true", help="include test code")
     p = sub.add_parser("roundtrip", help="heuristic: writes of a stored property `Type.prop` through a lossy transform, "
                                          "read back to seed UI state (#88)")
-    p.add_argument("spec"); p.add_argument("--db", required=True); p.add_argument("--json", action="store_true")
+    p.add_argument("spec", nargs="?"); p.add_argument("--db", required=True); p.add_argument("--json", action="store_true")
+    p.add_argument("--all", action="store_true", help="every stored property in one pass: only the round trips")
     p.add_argument("--tests", action="store_true", help="include test code's reads and writes")
     p = sub.add_parser("viz-plan", help="self-contained HTML overlay of a plan on the real graph")
     p.add_argument("name"); p.add_argument("--db", required=True); p.add_argument("-o", "--out", required=True); p.add_argument("--plans-dir")
@@ -769,8 +770,14 @@ def main(argv=None):
         print(json.dumps(res, indent=1) if a.json else LA.render(res))
     elif a.cmd == "roundtrip":
         from . import roundtrip as RT
-        res = RT.roundtrip(st, a.spec, include_tests=a.tests)
-        print(RT.to_json(res) if a.json else RT.render(res))
+        if a.all or not a.spec:
+            if not a.all:
+                sys.exit("cg roundtrip: give a property `Type.prop`, or --all")
+            res = RT.roundtrip_all(st, include_tests=a.tests)
+            print(RT.to_json(res) if a.json else RT.render_all(res))
+        else:
+            res = RT.roundtrip(st, a.spec, include_tests=a.tests)
+            print(RT.to_json(res) if a.json else RT.render(res))
     elif a.cmd in ("writers", "readers"):
         groups = Q.access(st, a.spec, a.cmd, a.connection)
         rows = [r for g in groups for r in g["rows"]]

{cg_code_graph-0.23.10 → 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.10 → 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.10 → cg_code_graph-0.23.12}/cg_code_graph/lint_async.py

@@ -61,6 +61,24 @@ def _input_dependent(text: str) -> bool:
     t = re.sub(r"(?<![\w$])[A-Za-z_$][\w$]*\s*(?:<[^<>]*>)?\s*\(", " (", t)  # call names
     ids = re.findall(r"(?<![\w$])[A-Za-z_$][\w$]*", t)
     return any(i.startswith("SELFREF_") or (i not in KEYWORDS and not i[0].isupper()) for i in ids)
+_SUSP: dict = {}          # file -> lines with a call of a Kotlin `suspend` function (an await point with no marker)
+
+
+def _load_suspend(st: GraphStore) -> None:
+    """A plain call of a project `suspend` function inside `launch { }` (`val x = repo.load()`) suspends like
+    `.await()`: the indexed CALLS edges to nodes marked `suspend` give those lines."""
+    _SUSP.clear()
+    for r in st.q("""SELECT e.file, e.line FROM edges e JOIN nodes n ON n.id = e.dst
+                     WHERE e.kind = 'CALLS' AND n.attrs LIKE '%"suspend": true%' AND e.file IS NOT NULL"""):
+        _SUSP.setdefault(r["file"], set()).add(r["line"])
+
+
+def _aw(t: str, file: str | None = None, line: int | None = None) -> bool:
+    """Is there an await point in this line of source: a marker (`await`, `.await()`, `withContext`, `delay`) or,
+    in Kotlin, a call of a `suspend` function?"""
+    return bool(AWAIT_RE.search(t)) or (line is not None and line in _SUSP.get(file, ()))
+
+
 TEST_PATH_RE = re.compile(r"(?:^|/)(?:tests?|__tests__|spec|testing|fixtures?|factories|Tests|UITests)/|"
                           r"[._-](?:test|spec)s?\.\w+:|Tests?\.swift:|Test\.kt:|(?:^|/)test_\w+\.py:")
 
@@ -104,6 +122,7 @@ def _opener(ls: list[str], line: int, lo: int):
 
 
 def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -> list[dict]:
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     fields = {r["id"]: json.loads(r["attrs"] or "{}") for r in st.q("SELECT id, attrs FROM nodes WHERE kind IN ('field','property')")}
@@ -122,7 +141,8 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
             continue
         kind, o = op
         body = ls[o - 1:r["line"] - 1]
-        aw = next((o + i for i, t in enumerate(body) if AWAIT_RE.search(t if i else t[t.find("{") + 1:] if "{" in t else t)), None)
+        aw = next((o + i for i, t in enumerate(body) if _aw(t if i else t[t.find("{") + 1:] if "{" in t else t,
+                                                           r["file"], o + i if i else None)), None)
         if aw is None:
             continue
         before = "\n".join(ls[o - 1:aw - 1]) + "\n" + ls[aw - 1].split("await")[0]
@@ -131,7 +151,10 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
         if GUARD_RE.search(after) or SINGLE_FLIGHT_RE.search(ls[o - 1]):
             continue
         aw_line = ls[aw - 1]
-        k = max(aw_line.find("await"), 0)
+        k = aw_line.find("await")
+        if k < 0:                                  # a Kotlin suspend call: the request is the right-hand side
+            m = re.search(r"(?<![=!<>])=(?!=)", aw_line)
+            k = m.end() if m else 0
         stmt, depth = [], 0
         for i in range(aw - 1, min(len(ls), aw + 5)):
             x = ls[i][k:] if i == aw - 1 else ls[i]
@@ -144,10 +167,10 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
         # the written value must come from the awaited result: a name bound on the await line (or derived from one
         # after it), or the await itself on the write line; a loading flag reset after the await is not a stale result
         res_vars = set()
-        for t in ls[aw - 1:r["line"] - 1]:
+        for j, t in enumerate(ls[aw - 1:r["line"] - 1]):
             m = DECL_RE.search(t) or re.search(r"^\s*(?:self\.)?([A-Za-z_$][\w$]*)\s*=(?!=)", t)
             nm = m and (m.group(1) or (m.group(2) if m.lastindex and m.lastindex >= 2 else None))
-            if nm and (AWAIT_RE.search(t) or any(re.search(rf"(?<![\w$.]){re.escape(v)}\b", t.split("=", 1)[-1]) for v in res_vars)):
+            if nm and (_aw(t, r["file"], aw + j) or any(re.search(rf"(?<![\w$.]){re.escape(v)}\b", t.split("=", 1)[-1]) for v in res_vars)):
                 res_vars.add(nm)
         wl = ls[r["line"] - 1]
         if r["line"] - 1 == aw - 1:
@@ -182,7 +205,8 @@ LIFECYCLE_RE = re.compile(r"\.onAppear\b|\bonAppear\s*\(|\.task\s*[({]|\bonMount
 CALLBACK_RE = re.compile(r"\.sink\s*\{|\.onReceive\s*\(|\.subscribe\s*[({]|\.collect(?:Latest)?\s*\{|\.observe\w*\s*\(|"
                          r"\bcompletion(?:Handler)?\s*:\s*\{|\{\s*\[?\s*(?:weak|unowned)\s+self\s*\]?|\.then\s*\(|\.on\s*\(\s*['\"]")
 LITERAL_RHS_RE = re.compile(r"(?<![=!<>])=\s*(?:\[\s*\]|\[:\]|\{\s*\}|nil|null|None|undefined|0(?:\.0+)?[fFdDL]?|false|False|true|True|"
-                            r"''|\"\"|emptyList\(\)|emptyMap\(\)|mutableListOf\(\)|\.init\(\)|\w+\(\)|\.\w+)\s*;?\s*$")
+                            r"''|\"\"|emptyList\(\)|emptyMap\(\)|mutableListOf\(\)|\.init\(\)|\w+\(\)|\.\w+|"
+                            r"[A-Z]\w*(?:\.[A-Z]\w*)+(?:\(\))?)\s*;?\s*$")     # a sentinel: `AsyncData.Loading()`, `UiState.Idle`
 LITERAL_ARG_RE = re.compile(r"\(\s*(?:nil|null|None|undefined|true|false|True|False|-?\d+(?:\.\d+)?|'[^']*'|\"[^\"]*\"|\[\s*\]|\{\s*\})\s*\)\s*;?\s*$")
 INIT_NAMES = {"init", "__init__", "constructor", "<init>", "viewDidLoad", "onCreate", "initState", "mounted", "created", "setup"}
 
@@ -198,7 +222,7 @@ def _lifecycle(st, ls, r, node) -> str | None:
     """Is this write lifecycle code: an initializer with a real (non-default) value, or code directly inside
     onAppear / .task (before any await) / onMounted / LaunchedEffect / useEffect / viewDidLoad?"""
     t = ls[r["line"] - 1]
-    if AWAIT_RE.search(t):
+    if _aw(t, r["file"], r["line"]):
         return None
     nm = ((node["name"] if node is not None else "") or "").split(".")[-1]
     if nm in INIT_NAMES or (node is not None and node["kind"] == "class"):
@@ -212,7 +236,7 @@ def _lifecycle(st, ls, r, node) -> str | None:
     lo = max(1, r["line"] - 6)
     for i in range(r["line"], lo - 1, -1):
         x = ls[i - 1]
-        if i < r["line"] and AWAIT_RE.search(x):
+        if i < r["line"] and _aw(x, r["file"], i):
             return None
         m = LIFECYCLE_RE.search(x)
         if m:
@@ -225,7 +249,8 @@ def _async_callback(ls, r, lo) -> str | None:
     op = _opener(ls, r["line"], lo)
     if op is not None:
         body = ls[op[1] - 1:r["line"] - 1]
-        if any(AWAIT_RE.search(x) for x in body[1:]) or AWAIT_RE.search(body[0][body[0].find("{") + 1:] if body else ""):
+        if any(_aw(x, r["file"], op[1] + j) for j, x in enumerate(body) if j) or \
+                (body and AWAIT_RE.search(body[0][body[0].find("{") + 1:])):
             return f"after await in {op[0]}"
     for i in range(r["line"] - 1, max(lo, r["line"] - 8) - 1, -1):
         m = CALLBACK_RE.search(ls[i - 1]) if i >= 1 else None
@@ -235,6 +260,7 @@ def _async_callback(ls, r, lo) -> str | None:
 
 
 def two_writers(st: GraphStore, include_tests: bool = False) -> list[dict]:
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     rows = st.q("""SELECT e.src, e.dst, e.file, e.line, e.attrs, n.line AS fl FROM edges e JOIN nodes n ON n.id = e.src
@@ -361,6 +387,14 @@ def incomplete_cache_key(st: GraphStore, include_tests: bool = False) -> list[di
         sig = "\n".join(body[:3])
         sig = sig[sig.find("("):] if "(" in sig else ""
         params = _idents(_split_args(sig[1:]) and ",".join(re.sub(r"[:=].*", "", a, flags=re.S) for a in _split_args(sig[1:])) or "")
+        # instance fields used without `self.` / `this.` (Swift, Kotlin): the READS_PROP edges bind them
+        own = {e["dst"].rsplit(".", 1)[-1] for e in st.q("SELECT dst, attrs FROM edges WHERE kind = 'READS_PROP' AND src = ?",
+                                                         (fn["id"],))
+               if json.loads(e["attrs"] or "{}").get("receiver") in (None, "self", "this")}
+        text = "\n".join(body)
+        # ... unless the field is an object the function calls (`client.get(…)`, `mediaLoader.load(…)`): a dependency,
+        # not an input of the cached value
+        own = {f for f in own if not re.search(rf"(?<![\w$.]){re.escape(f)}\s*[?!]?\.\s*\w+\s*[({{]", text)}
         assigns: dict = {}
         for off, t in enumerate(body):
             m = re.search(r"\b(?:let|var|val|const)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=(?!=)(.*)|^\s*([a-z_$][\w$]*)\s*=(?!=)(.*)", t)
@@ -384,8 +418,10 @@ def incomplete_cache_key(st: GraphStore, include_tests: bool = False) -> list[di
                 vb = val.strip().rstrip(";")
                 if re.fullmatch(r"[A-Za-z_$][\w$]*", vb) and vb not in assigns:
                     continue                    # `put(key, value)` passes a value through; nothing is computed here
-                kids = _expand(_idents(key), assigns)
-                vids = _expand(_idents(val), assigns) - {vb}
+                bare = lambda ids: {f"self_{i}" if i in own and i not in params and i not in assigns else i  # noqa: E731
+                                    for i in ids}
+                kids = bare(_expand(_idents(key), assigns))
+                vids = bare(_expand(_idents(val), assigns)) - {vb}
                 setter = re.match(r"(?:set|put|insert|store|save|cache|add|update|write|remember|record)(?![a-z])",
                                   (fn["fqn"] or "").split(".")[-1].split("(")[0])
                 inputs = {i for i in vids if (i in params and not setter and not PAYLOAD_RE.fullmatch(i.lstrip("$")))
@@ -421,6 +457,7 @@ def echo_suppression(st: GraphStore, include_tests: bool = False, patterns: list
     programmatic writes of some state so the change observer, which checks the guard and returns early, does not
     echo them back. Reports state of that pattern that is also written from an async path / callback *without*
     setting the guard: that write reaches the observer and is sent back (a loop or a clobbered edit)."""
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     guards = [r["id"] for r in st.q("SELECT id, name FROM nodes WHERE kind = 'field'") if GUARD_FIELD_RE.fullmatch((r["name"] or "").rsplit(".", 1)[-1].replace("_", ""))]

{cg_code_graph-0.23.10 → cg_code_graph-0.23.12}/cg_code_graph/mcp_server.py

@@ -877,13 +877,16 @@ def _access_text(st, spec: str, what: str, limit: int, connection: str | None =
 
 
 @tool
-def roundtrip(prop: str, include_tests: bool = False) -> str:
+def roundtrip(prop: str = "", include_tests: bool = False) -> str:
     """Heuristic (#88): does a stored property `Type.prop` round-trip through a lossy transform? Each write site with
     the lossy call it passes through (clamp, min/max, round, truncating casts, `fit*`, `.cg.yaml` `lossy:` names,
     `@cg-lossy` functions; within the function plus one hop through direct callers), each read site that seeds UI
     state (init, onAppear, remember, useState(initial), mounted), and un-narrowed ranges drawn next to such a read.
-    Findings are heuristic evidence with file:line, not proof."""
+    Findings are heuristic evidence with file:line, not proof. An empty `prop` (or `*`) checks every stored property
+    in one pass and lists only the round trips."""
     from . import roundtrip as RT
+    if prop.strip() in ("", "*"):
+        return RT.render_all(RT.roundtrip_all(_st(), include_tests=include_tests))
     return RT.render(RT.roundtrip(_st(), prop, include_tests=include_tests))
 
 

{cg_code_graph-0.23.10 → 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.10 → 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":