cg-code-graph 0.23.3__tar.gz → 0.23.4__tar.gz

{cg_code_graph-0.23.3/cg_code_graph.egg-info → cg_code_graph-0.23.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.3
+Version: 0.23.4
 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.3 → cg_code_graph-0.23.4}/cg_code_graph/__init__.py

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

{cg_code_graph-0.23.3 → cg_code_graph-0.23.4}/cg_code_graph/mcp_server.py

@@ -785,6 +785,8 @@ def _prop_lines(rows: list, limit: int) -> list[str]:
     for r in rows[:limit]:
         a = r.get("attrs") or {}
         ex = " ".join(f"{k}={a[k]}" for k in ("receiver", "accessor", "storage") if k in a)
+        if a.get("variant_platforms"):        # one of a property's per-platform declarations (#219)
+            ex = f"{ex} platforms={','.join(a['variant_platforms'])}".strip()
         ek = ",".join(sorted(r["entry_kinds"])) or "-"
         out.append(f"  {'[test] ' if r.get('test') else ''}{r['fqn']}  @{os.path.basename(r['file'] or '?')}:{r['line']}"
                    f"  {ex}  entries: {ek}")

{cg_code_graph-0.23.3 → cg_code_graph-0.23.4}/cg_code_graph/platforms.py

@@ -995,7 +995,7 @@ def _alt_groups(builder, nvals: dict) -> dict[str, list[str]]:
     """Rust / C / C++ / Swift alternative definitions of one symbol (one per `cfg` / `#if` branch), keyed by _vkey."""
     alts: dict[str, list[str]] = defaultdict(list)
     for nid, n in builder.nodes.items():
-        if n.lang in ("rust", "c", "cpp", "swift") and n.kind in ALT_KINDS:
+        if n.lang in ("rust", "c", "cpp", "swift") and n.kind in ALT_KINDS or n.lang == "swift" and n.kind == "field":
             alts[_vkey(nid, n, nvals)].append(nid)
     # a static C function and a macro / function of the same name visible in its file are variants too
     for k in [k for k in alts if k.startswith("c-fn:") and "#" in k]:

{cg_code_graph-0.23.3 → cg_code_graph-0.23.4}/cg_code_graph/plugins/swift/plugin.py

@@ -492,6 +492,8 @@ class SwiftPlugin(LanguagePlugin):
         self.stored_names: set[str] = set()      # names of plain stored properties anywhere in the project
         self.stored_in: dict[str, set[str]] = defaultdict(set)    # type fqn -> its stored property names
         self.fields: dict[str, dict[str, str]] = defaultdict(dict)  # type fqn -> stored instance property -> field id
+        self._vfields: dict[tuple, str] = {}      # (type decl id, stored property) -> field id of that `#if` variant
+        self._field_owner: dict[str, str | None] = {}     # field id -> the variant type declaring it (#219)
         self.field_names: set[str] = set()
         self.mutating_names: set[str] = set()
         self.branch_of: dict[tuple, dict] = {}     # (owner, line, type name) -> enclosing branch of a construction
@@ -929,9 +931,18 @@ class SwiftPlugin(LanguagePlugin):
     def _field(self, cls: Decl, nm: str, sf: SFile, c, attrs: list):
         """A stored instance property (`var count = 0`, `@State private var value`, `@Published var items`) is a
         `field:<Type>.<name>` node (#88): reads and writes of it are READS_PROP / WRITES_PROP edges, for `cg readers` /
-        `cg writers Type.prop`. Its property wrapper, if any, is attrs.wrapper."""
-        if nm in self.fields.get(cls.fqn, {}):
-            return
+        `cg writers Type.prop`. Its property wrapper, if any, is attrs.wrapper. The same property declared again in
+        another `#if` branch (in the type, or in a per-branch variant of the type) is a node of its own,
+        `field:<Type>.<name>@<line>` (#219); the platform pass narrows references to the one built where they are."""
+        key = f"{cls.fqn}.{nm}"
+        line = c.start_point[0] + 1
+        prev_id = self.fields.get(cls.fqn, {}).get(nm)
+        if prev_id:
+            pn = self.b.nodes[prev_id]
+            prev = SimpleNamespace(file=pn.file, line=pn.line, owner=self._field_owner.get(prev_id))
+            if not self._branch_variant(prev, sf, c, cls):
+                return
+            key = f"{key}@{line}"
         kw = next((self.t(x).split()[0] for x in c.children if x.type == "value_binding_pattern" and self.t(x).strip()), "var")
         a = {"property": "stored", "binding": "let" if kw == "let" else "var"}
         wrappers = [x for x in attrs if x not in ("MainActor", "objc", "IBOutlet", "IBInspectable", "available", "nonobjc")]
@@ -943,15 +954,16 @@ class SwiftPlugin(LanguagePlugin):
                     a["key"] = m.group(1)
         if sf.test:
             a["test"] = True
-        fid = self.b.add_node("field", f"{cls.fqn}.{nm}", name=nm, fqn=f"{cls.fqn}.{nm}", file=sf.rel,
-                              line=c.start_point[0] + 1, end_line=c.end_point[0] + 1,
+        fid = self.b.add_node("field", key, name=nm, fqn=f"{cls.fqn}.{nm}", file=sf.rel,
+                              line=line, end_line=c.end_point[0] + 1,
                               module=getattr(self.b.nodes.get(cls.id), "module", None), lang="swift", attrs=a)
-        self.b.add_edge(cls.id, fid, "CONTAINS", sf.rel, c.start_point[0] + 1, EXACT)
-        self.fields[cls.fqn][nm] = fid
-        self.field_names.add(nm)
-        if wrappers:          # `_value = State(initialValue: x)`: the wrapper's storage is the same property
-            self.fields[cls.fqn]["_" + nm] = fid
-            self.field_names.add("_" + nm)
+        self.b.add_edge(cls.id, fid, "CONTAINS", sf.rel, line, EXACT)
+        self._field_owner[fid] = self._owner(cls)
+        names = [nm] + (["_" + nm] if wrappers else [])   # `_value = State(initialValue: x)`: the wrapper's storage
+        for x in names:
+            self.fields[cls.fqn].setdefault(x, fid)
+            self._vfields[(cls.id, x)] = fid
+            self.field_names.add(x)
         self.st["stored_property_nodes"] += 1
 
     def _prop_decl(self, c, nm: str, sf: SFile, cls: Decl):
@@ -2303,7 +2315,7 @@ class SwiftPlugin(LanguagePlugin):
         """The field node of a stored property `name` of a type or its superclasses."""
         if cls is None or depth > 6:
             return None
-        fid = self.fields.get(cls.fqn, {}).get(name)
+        fid = self._vfields.get((cls.id, name)) or self.fields.get(cls.fqn, {}).get(name)
         if fid:
             return fid
         for s in cls.supers:

{cg_code_graph-0.23.3 → cg_code_graph-0.23.4}/cg_code_graph/query.py

@@ -1781,6 +1781,8 @@ def prop_fields(st: GraphStore, spec: str) -> list[str]:
     spec = spec[len("property:"):] if spec.startswith("property:") else spec
     if ("." not in spec and "::" not in spec) or spec.startswith(("table:", "column:")):
         return []
+    if "@" in spec:       # `field:Type.prop@<line>`: one per-platform declaration (#219)
+        return [r["id"] for r in st.q("SELECT id FROM nodes WHERE id=? AND kind='field'", (f"field:{spec}",))]
     # PHP: `User.name`, `User::$name`, `App\Models\User::$name` -> the `property:` node (fqn `App\Models\User::$name`)
     cls, _, prop = spec.replace("::$", "::").replace("::", ".").rpartition(".")
     php = f"{cls}::${prop.lstrip('$')}"

{cg_code_graph-0.23.3 → cg_code_graph-0.23.4/cg_code_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.3
+Version: 0.23.4
 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.3 → cg_code_graph-0.23.4}/cg_code_graph.egg-info/SOURCES.txt

@@ -288,6 +288,7 @@ tests/test_issue_210.py
 tests/test_issue_211.py
 tests/test_issue_211_used_at.py
 tests/test_issue_212.py
+tests/test_issue_219.py
 tests/test_java.py
 tests/test_java_exact.py
 tests/test_jobs.py

cg_code_graph-0.23.4/tests/test_issue_219.py

@@ -0,0 +1,125 @@
+"""Swift stored properties declared per `#if` branch: one node each, and reads / writes narrowed by platform (#219)."""
+import sqlite3
+
+import pytest
+
+pytest.importorskip("tree_sitter_swift")
+from cg_code_graph import mcp_server as M  # noqa: E402
+from cg_code_graph.indexer import index_project  # noqa: E402
+
+from test_issue_202 import PBX  # noqa: E402
+
+CANVAS = """\
+import SwiftUI
+
+struct CanvasView {
+#if os(iOS)
+    final class Coordinator {
+        let scale: Double
+        var offset: Double = 0
+        init(scale: Double) { self.scale = scale }
+        func draw() {
+            print(scale)
+            offset = 1
+        }
+    }
+#elseif os(macOS)
+    final class Coordinator {
+        let scale: Double
+        var offset: Double = 0
+        init(scale: Double) { self.scale = scale }
+        func render() {
+            print(scale)
+            offset = 2
+        }
+    }
+#endif
+}
+
+final class Ruler {
+#if os(iOS)
+    var unit: Int = 1
+#else
+    var unit: Int = 2
+#endif
+    var label: String = ""
+
+#if os(macOS)
+    func macTick() {
+        print(unit)
+    }
+#endif
+
+    func tick() {
+        unit = 3
+        label = "x"
+    }
+}
+"""
+
+
+@pytest.fixture(scope="module")
+def graph(tmp_path_factory):
+    tmp = tmp_path_factory.mktemp("i219")
+    root = tmp / "app"
+    (root / "App.xcodeproj").mkdir(parents=True)
+    (root / "Sources" / "App").mkdir(parents=True)
+    (root / "App.xcodeproj" / "project.pbxproj").write_text(PBX, encoding="utf-8")
+    (root / "Sources" / "App" / "CanvasView.swift").write_text(CANVAS, encoding="utf-8")
+    db = tmp / "g.db"
+    index_project(root, db, "canvas")
+    old = M.STATE.get("db")
+    M.STATE["db"] = str(db)
+    yield db
+    M.STATE["db"] = old
+
+
+def _ids(db, kind):
+    con = sqlite3.connect(db)
+    return {r[0] for r in con.execute("SELECT id FROM nodes WHERE kind=?", (kind,))}
+
+
+def _edges(db, dst):
+    con = sqlite3.connect(db)
+    return {(s, k) for s, k in con.execute("SELECT src, kind FROM edges WHERE dst=?", (dst,))}
+
+
+def test_each_branch_field_is_its_own_node(graph):
+    fields = _ids(graph, "field")
+    assert {"field:CanvasView.Coordinator.scale", "field:CanvasView.Coordinator.scale@16",
+            "field:CanvasView.Coordinator.offset", "field:CanvasView.Coordinator.offset@17"} <= fields
+    assert {"field:Ruler.unit", "field:Ruler.unit@31", "field:Ruler.label"} <= fields
+    assert not any(f.startswith("field:Ruler.label@") for f in fields)
+
+
+def test_variant_type_members_bind_their_own_fields(graph):
+    ios, mac = "field:CanvasView.Coordinator.scale", "field:CanvasView.Coordinator.scale@16"
+    assert ("method:CanvasView.Coordinator.draw", "READS_PROP") in _edges(graph, ios)
+    assert ("method:CanvasView.Coordinator.render", "READS_PROP") in _edges(graph, mac)
+    assert ("method:CanvasView.Coordinator.render", "READS_PROP") not in _edges(graph, ios)
+    assert ("method:CanvasView.Coordinator.draw", "READS_PROP") not in _edges(graph, mac)
+    assert ("method:CanvasView.Coordinator.init@18", "WRITES_PROP") in _edges(graph, mac)
+    assert ("method:CanvasView.Coordinator.init@18", "WRITES_PROP") not in _edges(graph, ios)
+    assert ("method:CanvasView.Coordinator.render", "WRITES_PROP") in \
+        _edges(graph, "field:CanvasView.Coordinator.offset@17")
+    assert ("method:CanvasView.Coordinator.render", "WRITES_PROP") not in \
+        _edges(graph, "field:CanvasView.Coordinator.offset")
+
+
+def test_platform_only_method_reads_the_field_built_there(graph):
+    assert ("method:Ruler.macTick", "READS_PROP") in _edges(graph, "field:Ruler.unit@31")
+    assert ("method:Ruler.macTick", "READS_PROP") not in _edges(graph, "field:Ruler.unit")
+
+
+def test_unnarrowed_access_keeps_every_variant(graph):
+    assert ("method:Ruler.tick", "WRITES_PROP") in _edges(graph, "field:Ruler.unit")
+    assert ("method:Ruler.tick", "WRITES_PROP") in _edges(graph, "field:Ruler.unit@31")
+    assert ("method:Ruler.tick", "WRITES_PROP") in _edges(graph, "field:Ruler.label")
+
+
+def test_readers_lists_only_the_platform_branch(graph):
+    out = M.readers("CanvasView.Coordinator.scale")       # every declaration, each site with its platform
+    assert "Coordinator.draw  @CanvasView.swift:10  receiver=self platforms=ios" in out, out
+    assert "Coordinator.render  @CanvasView.swift:20  receiver=self platforms=macos" in out, out
+    out = M.readers("field:CanvasView.Coordinator.scale@16")   # the macOS declaration alone
+    assert "render" in out and "draw" not in out, out