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

{cg_code_graph-0.23.2/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.2
+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
@@ -18,7 +18,7 @@ Requires-Dist: tree-sitter-c>=0.23
 Requires-Dist: tree-sitter-cpp>=0.23
 Requires-Dist: tree-sitter-kotlin>=1.0
 Requires-Dist: tree-sitter-java>=0.23
-Requires-Dist: tree-sitter-swift<0.7.4,>=0.6
+Requires-Dist: tree-sitter-swift<0.8,>=0.6
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Provides-Extra: watch

{cg_code_graph-0.23.2 → 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.2"
+__version__ = "0.23.4"

{cg_code_graph-0.23.2 → cg_code_graph-0.23.4}/cg_code_graph/cli.py

@@ -733,7 +733,8 @@ def main(argv=None):
             print(Q.connections_line(res["connections"]))
         if not res["callers"] and not res["entry_points"]:
             print(Q.explain_no_callers(st, a.spec, res["targets"], a.min_confidence)); return
-        print(f"callers (transitive): {len(res['callers'])}")
+        nc = res.get("callers_candidate") or 0
+        print(f"callers (transitive): {len(res['callers']) - nc}" + (f" (+{nc} candidate)" if nc else ""))
         caller_names = _impact_labels(res["callers"], lambda c: c.get("fqn") or c["id"], lambda c: c.get("module") or c.get("kind"))
         for c, nm in zip(res["callers"], caller_names):
             loc = f"  @ {c['file']}:{c['line']}" if Q.NATIVE_FILE_RE.search(c.get("file") or "") else ""

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

@@ -601,7 +601,9 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
     dropped_line = [f"not built for {pf}: {', '.join(short(t) for t in dropped[:6])}"] if pf and dropped else []
     out = pline + dropped_line + [f"targets: {', '.join(short(t) for t in r['targets'][:5])}", *via_default, *Q.override_lines(r),
                    *([Q.connections_line(r["connections"])] if r.get("connections") else []),
-                   f"transitive callers: {len(r['callers'])}; entry points: {len(r['entry_points'])}"]
+                   f"transitive callers: {r.get('callers_resolved', len(r['callers']))}"
+                   + (f" (+{r['callers_candidate']} candidate)" if r.get("callers_candidate") else "")
+                   + f"; entry points: {len(r['entry_points'])}"]
     if not r["callers"] and not r["entry_points"]:
         return "\n".join(out + [Q.explain_no_callers(st, method, r["targets"], min_confidence)])
     byk = defaultdict(list)
@@ -619,7 +621,7 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
             out.append(f"  {lab}{Q.CANDIDATE_LABEL if e.get('candidate') else ''}{Q.platform_label(e)}{hop}")
     bymod = defaultdict(list)
     for c in r["callers"]:
-        bymod[c.get("module") or "?"].append(c)
+        bymod[Q.caller_group(c)].append(c)
     dup_lines = []
     for mod in sorted(bymod):
         cs = bymod[mod]
@@ -631,8 +633,10 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
         out.append("same name in one module: " + "; ".join(dup_lines))
     mods = defaultdict(int)
     for c in r["callers"]:
-        mods[c.get("module") or "?"] += 1
-    out.append("\ncallers by module: " + ", ".join(f"{m}×{c}" for m, c in sorted(mods.items(), key=lambda x: -x[1])))
+        if not c.get("candidate"):          # candidates are listed on their own below (#204)
+            mods[Q.caller_group(c)] += 1
+    if mods:
+        out.append("\ncallers by module: " + ", ".join(f"{m}×{c}" for m, c in sorted(mods.items(), key=lambda x: -x[1])))
     gen = [c for c in r["callers"] if c.get("generated")]
     if gen:    # indexed with --include-generated: callers in files a generator writes
         out.append(f"in generated / copied files ({len(gen)}): " + ", ".join(f"{short(c['id'])} [{c['generated']}]" for c in gen[:8])
@@ -648,8 +652,13 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
                                                              for c in vo[:8]) + (f" …+{len(vo) - 8}" if len(vo) > 8 else ""))
     cand = [c for c in r["callers"] if c.get("candidate")]
     if cand or any(e.get("candidate") for e in r["entry_points"]):   # reached through a candidate call edge (#83)
-        out.append(f"candidate callers ({len(cand)}): " + ", ".join(short(c["id"]) for c in cand[:12])
+        out.append(f"candidate callers ({len(cand)}): " + ", ".join(short(c["id"]) + Q.fanout_text(c) for c in cand[:12])
                    + (f" …+{len(cand) - 12}" if len(cand) > 12 else "") + "\n" + Q.CANDIDATE_NOTE)
+    od = [c for c in r["callers"] if c.get("omits_default")]
+    if od:     # calls that leave out a defaulted argument and so run its default (#212)
+        out.append(f"through an omitted default argument ({len(od)}): "
+                   + ", ".join(f"{short(c['id'])} ({c['omits_default']}: of {short(c.get('default_of'))})" for c in od[:8])
+                   + (f" …+{len(od) - 8}" if len(od) > 8 else ""))
     vb = [c for c in r["callers"] if c.get("via_base")]
     if vb:     # calls the base declaration; the target is reached through the override
         out.append(f"via base ({len(vb)}): " + ", ".join(f"{short(c['id'])} -> {c['via_base']}" for c in vb[:8])
@@ -702,12 +711,26 @@ def callers(symbol: str, min_confidence: str = "heuristic", limit: int = 60) ->
     if not rows:
         return head + f"\nno direct callers of {symbol!r} in indexed code (min_confidence={min_confidence}). try: impact() for " \
                       f"entry points, reaches() for every dependent over all edge kinds, node() for its other edges"
-    out = [head, f"direct callers: {len({r['src'] for r in rows})} ({len(rows)} sites)"]
-    for r in rows[:limit]:
+    # one row per call site: a site linked to several per-platform definitions of the target is one site (#201)
+    seen, uniq = set(), []
+    for r in rows:
+        if (r["src"], r["kind"], r["file"], r["line"]) not in seen:
+            seen.add((r["src"], r["kind"], r["file"], r["line"]))
+            uniq.append(r)
+    rows = uniq
+    is_cand = [bool(r["attrs"] and '"binding": "candidate"' in r["attrs"]) for r in rows]
+    res = [r for r, cd in zip(rows, is_cand) if not cd]
+    cands = [r for r, cd in zip(rows, is_cand) if cd]
+    # selector-only candidates (receiver type unknown) are counted apart from resolved callers (#204)
+    out = [head, f"direct callers: {len({r['src'] for r in res})} ({len(res)} sites)"
+           + (f"; candidate callers: {len({r['src'] for r in cands})} ({len(cands)} site{'' if len(cands) == 1 else 's'}, receiver type unknown)"
+              if cands else "")]
+    for r in (res + cands)[:limit]:
         c = "" if r["confidence"] == "exact" else f" ~{r['confidence'][0]}"
         k = "ref" if r["kind"] == "REFERENCES_FN" else r["kind"]
-        cand = Q.CANDIDATE_LABEL if r["attrs"] and '"binding": "candidate"' in r["attrs"] else ""
-        out.append(f"  {short(r['src'])}  {k}@{at((r['file'] or '?') + ':' + str(r['line']))}{c}{cand}")
+        cand = Q.candidate_label(r["attrs"], r["dst"]) if r in cands else ""
+        out.append(f"  {short(r['src'])}  {k}@{at((r['file'] or '?') + ':' + str(r['line']))}{c}{cand}"
+                   + Q.omitted_default_label(r["attrs"]))
     if len(rows) > limit:
         out.append(f"  … +{len(rows) - limit} more (raise limit)")
     return "\n".join(out)
@@ -762,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}")
@@ -1086,7 +1111,8 @@ def node(id_or_symbol: str) -> str:
             for k, v in sorted(byk.items()):
                 if k == "CONTAINS":
                     continue
-                s = "; ".join(f"{short(r['o'])}@{r['line']}{'!g' if r['gate'] else ''}" for r in v[:6])
+                # `<id> :<line>`: a variant id carries its own `@N` (`refreshStatus@24 :12`, #201)
+                s = "; ".join(f"{short(r['o'])} :{r['line']}{'!g' if r['gate'] else ''}" for r in v[:6])
                 out.append(f"  {k}: {s}{' …' if len(v) > 6 else ''}")
     return "\n".join(out)
 

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

@@ -29,6 +29,7 @@ on any target follow the implementation that target builds.
 """
 from __future__ import annotations
 
+import dataclasses
 import fnmatch
 import json
 import os
@@ -658,11 +659,13 @@ def apply(project, builder) -> dict:
                 etag[k] = hit
     targets, tsrc = declared_targets(root, cfg, marks, set(langs) | ({"c_cpp"} if langs & {"c", "cpp"} else set()))
     _write_attrs(builder, ntag, nvals, etag, targets)
+    narrowed = _narrow_variant_edges(builder, nvals, etag)
     _variant_platforms(builder, nvals, targets)
     unknown = [m for m in marks if any(m["cond"].values().get(p) is None for p in targets)]
     tagged_files = sorted({m["file"] for m in marks})
     st = {"targets": targets, "target_sources": tsrc, "conditions": len(marks), "files_with_conditions": len(tagged_files),
-          "tagged_nodes": len(ntag), "tagged_edges": len(etag), "variant_edges": mirrored, "text_scanned_files": scanned,
+          "tagged_nodes": len(ntag), "tagged_edges": len(etag), "variant_edges": mirrored,
+          "variant_edges_narrowed": narrowed, "text_scanned_files": scanned,
           "unevaluated_conditions": len(unknown),
           "unevaluated_per_target": {p: sum(1 for m in unknown if m["cond"].values().get(p) is None) for p in targets},
           "unevaluated_samples": sorted({f"{m['cond'].text} @ {m['file']}:{m['line']}" for m in unknown})[:8]}
@@ -824,6 +827,63 @@ def _write_attrs(builder, ntag, nvals, etag, targets=None) -> None:
             put(e.attrs, ms, _combine([m["cond"].values() for m in ms]))
 
 
+def _narrow_variant_edges(builder, nvals: dict, etag: dict) -> int:
+    """A reference made where only some targets build (`#if os(macOS)` around the caller or the call) reaches only the
+    per-platform definitions built on one of those targets (#201): a macOS-only call of `refreshStatus()` links the
+    macOS definition, not the `#else` stub. A reference whose definition is not built anywhere the site is moves to the
+    sibling definitions that are (the `#else` type's `Self()` names its own type), and a Swift `init` of a sibling
+    variant type that declares no initializer of its own (the implicit one) is no reference at all. References from
+    code built everywhere keep linking every definition."""
+    alts = {}
+    for ids in _alt_groups(builder, nvals).values():
+        if len(ids) > 1 and any(i in nvals for i in ids):
+            for i in ids:
+                alts[i] = ids
+    inits: dict[str, list] = defaultdict(list)       # Swift type -> its init nodes
+    parent: dict[str, str] = {}
+    for e in builder.edges.values():
+        if e.kind == "CONTAINS" and e.src.startswith("class:"):
+            parent[e.dst] = e.src
+            dn = builder.nodes.get(e.dst)
+            if dn is not None and dn.name == "init":
+                inits[e.src].append(e.dst)
+
+    def avail(i):
+        return {p for p in KNOWN if _avail(nvals.get(i), p)}
+
+    drop, adds = [], []
+    for k, e in builder.edges.items():
+        if e.kind in ("CONTAINS", "DEFINES", "GATED_BY"):
+            continue
+        vals = ([nvals[e.src]] if e.src in nvals else []) + [m["cond"].values() for m in etag.get(k, ())]
+        if not vals:
+            continue
+        site = {p for p, v in _combine(vals).items() if v is not False}
+        if not site or avail(e.dst) & site:
+            continue
+        ids = alts.get(e.dst)
+        if ids:
+            other = [i for i in ids if i != e.dst and avail(i) & site]
+            if other:
+                drop.append(k)
+                adds += [(e, i) for i in other]
+            continue
+        dn = builder.nodes.get(e.dst)
+        if dn is None or dn.lang != "swift" or dn.name != "init" or e.dst not in parent:
+            continue
+        own = parent[e.dst]
+        sib = [v for v in alts.get(own) or () if v != own and avail(v) & site]
+        if sib and all(not inits.get(v) for v in sib):
+            drop.append(k)                       # the sibling variant type's implicit initializer
+    for k in drop:
+        builder.edges.pop(k, None)
+    for e, nid in adds:
+        key = (e.src, nid, e.kind, e.file, e.line, e.gate)
+        if key not in builder.edges:
+            builder.edges[key] = dataclasses.replace(e, dst=nid, attrs={**(e.attrs or {}), "platform_variant_of": e.dst})
+    return len(drop)
+
+
 def _variant_platforms(builder, nvals: dict, targets) -> int:
     """A reference into one of a symbol's per-platform definitions (Rust / C / C++ / Swift `#if` branches) carries
     `variant_platforms`: the targets that definition is built for. Every definition is linked (_mirror), so a caller
@@ -935,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.2 → cg_code_graph-0.23.4}/cg_code_graph/plugins/swift/exact.py

@@ -318,8 +318,10 @@ class ExactLayer:
                         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), {}) \
                         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",
-                                    **({"dynamic": True} if o.roles & ix.DYNAMIC else {}), **acc, **br)
+                                    **({"dynamic": True} if o.roles & ix.DYNAMIC else {}), **acc, **br,
+                                    **({"default_arg": da} if da else {}))
                     exact.add((src, dst, kind))
                     refs += 1
         st["index_references"] = refs
@@ -410,17 +412,22 @@ class ExactLayer:
         it is kept, marked `via: not-compiled`, and left out of the comparison. Candidate edges (#83) go to
         self.candidates, compared on their own."""
         out, cand, kept = set(), set(), 0
+        self.default_args = {}      # (callee, file, line) -> parameter label of a default-argument call (#208)
         for key, e in list(self.b.edges.items()):
             if e.confidence != HEURISTIC or e.file not in covered or e.kind not in CALL_KINDS:
                 continue
             n = self.b.nodes.get(e.src)
             if n is None or n.lang != "swift":
                 continue
+            if e.attrs.get("omits_default"):
+                continue              # the call runs a default the compiler records at the declaration only (#212)
             if (e.file, e.line) not in seen_lines:
                 e.attrs["via"] = "not-compiled"
                 kept += 1
                 continue
             (cand if e.attrs.get("binding") == "candidate" else out).add((e.src, e.dst, e.kind))
+            if e.attrs.get("default_arg"):
+                self.default_args[(e.dst, e.file, e.line)] = e.attrs["default_arg"]
             del self.b.edges[key]
         self.candidates = cand
         return out, kept

{cg_code_graph-0.23.2 → 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
@@ -565,6 +567,7 @@ class SwiftPlugin(LanguagePlugin):
             self._available(sf)
         self._resolve_calls()
         self._resolve_props()
+        self._omitted_defaults()
         self._at = None
         self._hierarchy()
         self._fluent_migrations(sfiles)
@@ -928,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")]
@@ -942,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):
@@ -1437,6 +1450,11 @@ class SwiftPlugin(LanguagePlugin):
             # `a + weight(forExtraIndex: 2)` parses as `(a + weight)(forExtraIndex: 2)`: the callee is the right operand
             f = f.child_by_field_name("rhs")
             line = f.start_point[0] + 1
+        while f.type == "prefix_expression" and len(f.children) == 2 and self.t(f.children[0]) in ("!", "-", "~", "+") \
+                and f.children[1].type in ("navigation_expression", "simple_identifier"):
+            # tree-sitter-swift 0.7.4 parses `!Preview.matches(a, b)` as `(!Preview.matches)(a, b)`; 0.7.3 as
+            # `(!Preview).matches(a, b)` (handled below): either way the operator applies to the result (#199)
+            f = f.children[1]
         suf = next((x for x in c.children if x.type == "call_suffix"), None)
         args = next((x for x in suf.children if x.type == "value_arguments"), None) if suf is not None else None
         lam = next((x for x in suf.children if x.type in ("lambda_literal", "annotated_lambda")), None) if suf is not None else None
@@ -2122,6 +2140,8 @@ class SwiftPlugin(LanguagePlugin):
         return self._qext
 
     def _resolve_calls(self):
+        self._default_edges: dict[str, list] = defaultdict(list)   # function -> [(label, callee, attrs)] (#208)
+        self._call_sites: list = []                                  # (caller, callee, file, line, labels, trailing)
         for rec in self.calls:
             owner, name, recv, line, sf, decl, labels, trailing = rec[:8]
             default_arg = rec[8] if len(rec) > 8 else None
@@ -2151,15 +2171,57 @@ class SwiftPlugin(LanguagePlugin):
                                     **self.branch_of.get((owner, line, name), {}))
                     for m in hit:
                         self.b.add_edge(owner, m.id, "CALLS", sf.rel, line, HEURISTIC)
+                        self._call_sites.append((owner, m.id, sf.rel, line, labels, trailing))
                 else:
                     if default_arg:
                         how = {**how, "default_arg": default_arg}
+                        self._default_edges[owner].append((default_arg, t.id, {}))
+                    elif self._how != "candidate":
+                        self._call_sites.append((owner, t.id, sf.rel, line, labels, trailing))
                     self.b.add_edge(owner, t.id, "CALLS", sf.rel, line, HEURISTIC, **how, **self._accessor_attr(decl, line))
                     if how:
                         self.st["calls_by_name_only" if self._how == "name" else "call_candidate_edges"] += 1
                 done = True
             self.st["calls_resolved" if done else "calls_unresolved"] += 1
 
+    def _omitted_defaults(self):
+        """A call that leaves out a defaulted argument runs the default expression: an edge from the caller to what
+        the default calls, at the call site, with `omits_default` (the parameter label) and `default_of` (#212). A
+        call that passes the argument gets none. The declaration's own `default_arg` edge stays (#208)."""
+        if not self._default_edges:
+            return
+        n = 0
+        for owner, did, rel, line, labels, trailing in self._call_sites:
+            defs = self._default_edges.get(did)
+            if not defs:
+                continue
+            left = self._left_out(did, labels, trailing)
+            for label, callee, extra in defs:
+                if label in left and callee != owner:
+                    self.b.add_edge(owner, callee, "CALLS", rel, line, HEURISTIC, omits_default=label, default_of=did,
+                                    **extra)
+                    n += 1
+        if n:
+            self.st["default_argument_sites"] = n
+
+    def _left_out(self, did: str, labels: tuple, trailing: bool) -> set:
+        """Labels of the defaulted / optional parameters the call leaves out, by the first signature it fits."""
+        for sig in self.sigs.get(did) or ():
+            i, ok, left, tr = 0, True, set(), trailing
+            for k, (lab, opt) in enumerate(sig):
+                if i < len(labels) and labels[i] == lab:
+                    i += 1
+                elif tr and i == len(labels) and all(o for _l, o in sig[k + 1:]):
+                    tr = False
+                elif opt:
+                    left.add(lab)
+                else:
+                    ok = False
+                    break
+            if ok and i == len(labels):
+                return left
+        return set()
+
     def _prop_member(self, cls: Decl | None, name: str, depth: int = 0) -> list[Decl]:
         """Property nodes named `name` of a type, its extensions and its supertypes (protocol extensions too)."""
         if cls is None or name in self.stored_in.get(cls.fqn, ()):
@@ -2241,6 +2303,7 @@ class SwiftPlugin(LanguagePlugin):
                     continue
                 if default_arg:
                     how = {**how, "default_arg": default_arg}
+                    self._default_edges[owner].append((default_arg, t.id, {"property": "write" if write else "read"}))
                 self.b.add_edge(owner, t.id, "CALLS", sf.rel, line, HEURISTIC, property="write" if write else "read",
                                 **how, **self._accessor_attr(decl, line))
                 done = True
@@ -2252,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.2 → cg_code_graph-0.23.4}/cg_code_graph/query.py

@@ -981,6 +981,9 @@ def _hop_of(e) -> dict:
         a = json.loads(e["attrs"])
         if a.get("binding") == "candidate":      # one of several same-name methods, receiver type unknown (#83)
             hop["candidate"] = a.get("candidates") or True
+    if e["kind"] in ("CALLS", "TEST_CALLS") and e["attrs"] and '"omits_default"' in e["attrs"]:
+        a = json.loads(e["attrs"])     # the call leaves out a defaulted argument and runs its default (#212)
+        hop["omits_default"], hop["default_of"] = a.get("omits_default"), a.get("default_of")
     if e["kind"] in ("CALLS", "TEST_CALLS") and e["attrs"] and '"accessor"' in e["attrs"]:
         hop["accessor"] = json.loads(e["attrs"]).get("accessor")   # inside `didSet { }` / `get { }` (Swift, #72)
     if e["gate"]:
@@ -1253,7 +1256,7 @@ def render_reaches(res: dict, show_paths=True, kinds=CODE_KINDS + ENTRY_NODE_KIN
         out.append(f"== {labels[cls]}: {len(group)} functions/methods")
         bymod = defaultdict(list)
         for i in group:
-            bymod[i.get("module") or "?"].append(i)
+            bymod[caller_group(i)].append(i)
         for mod in sorted(bymod):
             out.append(f"  [{mod}]")
             for i in bymod[mod]:
@@ -1270,7 +1273,7 @@ def render_reaches(res: dict, show_paths=True, kinds=CODE_KINDS + ENTRY_NODE_KIN
         out.append(f"== GATED UNDER SCENARIO '{res.get('gate')}' (dead when the scenario holds; live otherwise): {len(gated)} functions/methods")
         bymod = defaultdict(list)
         for i in gated:
-            bymod[i.get("module") or "?"].append(i)
+            bymod[caller_group(i)].append(i)
         for mod in sorted(bymod):
             out.append(f"  [{mod}]")
             for i in bymod[mod]:
@@ -1304,7 +1307,8 @@ def _first_hop(path: list[dict] | None) -> dict:
         return {}
     h = path[0]
     return {"edge": h["kind"], **({"how": h["how"]} if h.get("how") else {}), **({"via": h["via"]} if h.get("via") else {}),
-            **({"accessor": h["accessor"]} if h.get("accessor") else {})}
+            **({"accessor": h["accessor"]} if h.get("accessor") else {}),
+            **({"omits_default": h["omits_default"], "default_of": h.get("default_of")} if h.get("omits_default") else {})}
 
 
 def with_generated(row: dict) -> dict:
@@ -1348,6 +1352,54 @@ def generated_label(n: dict) -> str:
 
 
 CANDIDATE_LABEL = "  (candidate)"
+
+
+def _node_name(nid: str) -> str:
+    """`method:PrinterBridge.refreshStatus@24` -> `refreshStatus`."""
+    return nid.split(":", 1)[-1].split("@", 1)[0].rsplit(".", 1)[-1].rsplit("::", 1)[-1].rsplit("#", 1)[-1]
+
+
+def caller_group(c: dict) -> str:
+    """Module of a caller; a caller without one (a free function, a top-level script) is grouped by its file,
+    never as `?` (#204)."""
+    if c.get("module"):
+        return c["module"]
+    f = c.get("file")
+    return f"{os.path.basename(f)} (top level)" if f else "?"
+
+
+def fanout_text(c: dict) -> str:
+    """' (1 of 4 methods named refreshStatus)' for a selector-only candidate caller (#204), else ''."""
+    co = c.get("candidate_of") or {}
+    return f" (1 of {co['count']} methods named {co['name']})" if co.get("count") else ""
+
+
+def candidate_label(attrs: str | None, dst: str) -> str:
+    """'  (candidate, 1 of 3 methods named refreshStatus)' for a candidate call edge (#204)."""
+    try:
+        a = json.loads(attrs or "{}") or {}
+    except ValueError:
+        a = {}
+    n = a.get("candidates")
+    if isinstance(n, int) and not isinstance(n, bool) and n > 1:
+        return f"  (candidate, 1 of {n} methods named {_node_name(dst)})"
+    return CANDIDATE_LABEL
+
+
+def omitted_default_label(attrs: str | None) -> str:
+    """'  (runs the default of gamut: in render)' for a call site that leaves out a defaulted argument (#212)."""
+    if attrs and '"default_arg"' in attrs:
+        try:
+            return f"  (parameter default {(json.loads(attrs) or {}).get('default_arg')}:)"
+        except ValueError:
+            return ""
+    if not attrs or '"omits_default"' not in attrs:
+        return ""
+    try:
+        a = json.loads(attrs) or {}
+    except ValueError:
+        return ""
+    return f"  (runs the default of {a.get('omits_default')}: in {_node_name(a.get('default_of') or '?')})"
 CANDIDATE_NOTE = ("(candidate): through a call whose receiver type is unknown, bound to each project method with that "
                   "selector; it may reach a same-name sibling instead")
 
@@ -1418,7 +1470,10 @@ def caller_label(c: dict) -> str:
     if c.get("in_property"):                     # a type node: the call is in a property of that type (#72)
         lab += "  (in a property)"
     if c.get("candidate"):
-        lab += CANDIDATE_LABEL
+        co = c.get("candidate_of") or {}
+        lab += f"  (candidate, 1 of {co['count']} methods named {co['name']})" if co.get("count") else CANDIDATE_LABEL
+    if c.get("omits_default"):
+        lab += f"  (runs the default of {c['omits_default']}: in {_node_name(c.get('default_of') or '?')})"
     if c.get("via_override"):
         v = c["via_override"]
         lab += f"  (via override {v[0]}" + (f" +{len(v) - 1}" if len(v) > 1 else "") + ")"
@@ -1655,6 +1710,10 @@ def _impact(st: GraphStore, spec: str, min_conf: str, platform: str | None) -> d
         p = paths.get(n) or []
         if path_candidate(p):
             c["candidate"] = True
+            fan = next((h for h in p if h.get("candidate")), {})
+            if isinstance(fan.get("candidate"), int) and not isinstance(fan.get("candidate"), bool):
+                # one of N project methods sharing the selector (#204)
+                c["candidate_of"] = {"count": fan["candidate"], "name": _node_name(fan["to"])}
         if p and p[0]["to"] in bases:      # calls the base declaration; reaches the target through the override
             c["via_base"] = fq.get(p[0]["to"], p[0]["to"])
         if n in direct:    # calls an override (not the target itself): reaches the target's API through it
@@ -1662,6 +1721,9 @@ def _impact(st: GraphStore, spec: str, min_conf: str, platform: str | None) -> d
         callers.append(c)
     out = {"targets": targets, "entry_points": sorted(entries, key=lambda x: (x["entry_kind"], x["name"])),
            "callers": sorted(callers, key=lambda x: (x["depth"], x["fqn"] or "")), **rel}
+    # selector-only candidates (receiver type unknown, #83) are counted apart from resolved callers (#204)
+    out["callers_candidate"] = sum(1 for c in callers if c.get("candidate"))
+    out["callers_resolved"] = len(callers) - out["callers_candidate"]
     defaults = _default_arguments(st, targets)
     if defaults:
         out["default_arguments"] = defaults
@@ -1719,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.2 → 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.2
+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
@@ -18,7 +18,7 @@ Requires-Dist: tree-sitter-c>=0.23
 Requires-Dist: tree-sitter-cpp>=0.23
 Requires-Dist: tree-sitter-kotlin>=1.0
 Requires-Dist: tree-sitter-java>=0.23
-Requires-Dist: tree-sitter-swift<0.7.4,>=0.6
+Requires-Dist: tree-sitter-swift<0.8,>=0.6
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Provides-Extra: watch

{cg_code_graph-0.23.2 → cg_code_graph-0.23.4}/cg_code_graph.egg-info/SOURCES.txt

@@ -275,8 +275,10 @@ tests/test_inherited_overrides.py
 tests/test_inline_guards.py
 tests/test_install_rules.py
 tests/test_issue_192.py
+tests/test_issue_201.py
 tests/test_issue_202.py
 tests/test_issue_203.py
+tests/test_issue_204.py
 tests/test_issue_205.py
 tests/test_issue_206.py
 tests/test_issue_207.py
@@ -285,6 +287,8 @@ tests/test_issue_209.py
 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.2 → cg_code_graph-0.23.4}/cg_code_graph.egg-info/requires.txt

@@ -7,7 +7,7 @@ tree-sitter-c>=0.23
 tree-sitter-cpp>=0.23
 tree-sitter-kotlin>=1.0
 tree-sitter-java>=0.23
-tree-sitter-swift<0.7.4,>=0.6
+tree-sitter-swift<0.8,>=0.6
 
 [dev]
 pytest>=8

{cg_code_graph-0.23.2 → cg_code_graph-0.23.4}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
     "tree-sitter-cpp>=0.23",
     "tree-sitter-kotlin>=1.0",
     "tree-sitter-java>=0.23",
-    "tree-sitter-swift>=0.6,<0.7.4",   # 0.7.4 (2026-10-04) changes the parse of two recovered shapes (#133)
+    "tree-sitter-swift>=0.6,<0.8",
 ]
 
 [project.optional-dependencies]