cg-code-graph 0.23.7__tar.gz → 0.23.9__tar.gz

{cg_code_graph-0.23.7/cg_code_graph.egg-info → cg_code_graph-0.23.9}/PKG-INFO

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

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

{cg_code_graph-0.23.7 → cg_code_graph-0.23.9}/cg_code_graph/cli.py

@@ -301,9 +301,12 @@ def main(argv=None):
     p.add_argument("--strip-prefix", action="append", default=[], help="a name prefix one side adds (`Vault` in "
                    "VaultAddEditState for AddEditState), ignored when matching (repeatable)")
     p.add_argument("--structure", action="store_true", help="also pair symbols whose names differ by what they use: "
-                   "shared strings, localization keys, endpoints and already-paired callees, plus rename rules learned "
-                   "from the pairs found (#93); matches carry their evidence")
+                   "shared strings, localization keys, resources, endpoints and already-paired callees, then types by "
+                   "their declared fields, plus rename rules learned from the pairs found (#93); matches carry their "
+                   "evidence")
     p.add_argument("--no-learn", action="store_true", help="with --structure: no learned rename rules")
+    p.add_argument("--both-sides", action="store_true", help="also list the matched pairs and what only --against "
+                   "has (target symbols no source symbol matched)")
     p.add_argument("--write-map", help="with --structure: write the inferred pairs as a --map JSON file to review")
     p.add_argument("--json", action="store_true"); p.add_argument("--max-items", type=int, default=200)
     p = sub.add_parser("lint", help="heuristic lints (#88): `lint async-state` flags stale async results, state with "
@@ -574,7 +577,7 @@ def main(argv=None):
         from . import parity as PA
         mapping = json.loads(open(a.map, encoding="utf-8").read()) if a.map else None
         res = PA.parity(a.db, a.against, mapping=mapping, fuzzy=not a.no_fuzzy, strip_prefixes=a.strip_prefix,
-                        structure=a.structure, learn=not a.no_learn)
+                        structure=a.structure, learn=not a.no_learn, both_sides=a.both_sides)
         if a.write_map:
             with open(a.write_map, "w", encoding="utf-8") as fh:
                 json.dump(PA.rename_map(res), fh, indent=1, sort_keys=True)

{cg_code_graph-0.23.7 → cg_code_graph-0.23.9}/cg_code_graph/parity.py

@@ -220,21 +220,27 @@ def _cat(sym: dict, is_type: bool) -> str:
     return "type" if is_type else "const" if sym["kind"] in ("constant", "enum_case") else "func"
 
 
+INFERRED = ("structure", "fields", "learned")
+PREVIEW_NAME = re.compile(r"Preview")
+
+
 def parity(source_db: str, target_db: str, mapping: dict | None = None, fuzzy: bool = True,
-           strip_prefixes: list[str] | None = None, structure: bool = False, learn: bool = True) -> dict:
+           strip_prefixes: list[str] | None = None, structure: bool = False, learn: bool = True,
+           both_sides: bool = False) -> dict:
     """See the module docstring. `strip_prefixes`: name prefixes one side adds (`Vault` in `VaultAddEditState`
     for `AddEditState`), dropped before normalized matching on both sides. `structure` (#93): after the name rules,
     pair the rest by shared strings, localization keys, endpoints and paired callees, and (`learn`) apply rename
-    rules learned from the pairs found (cg_code_graph/parity_structure.py); off, the output is the name matching alone."""
+    rules learned from the pairs found (cg_code_graph/parity_structure.py); off, the output is the name matching alone.
+    `both_sides`: also list what only the target has (`target_only`)."""
     _PREFIXES[:] = [p.lower() for p in strip_prefixes or ()]
     try:
-        return _parity(source_db, target_db, mapping, fuzzy, structure, learn)
+        return _parity(source_db, target_db, mapping, fuzzy, structure, learn, both_sides)
     finally:
         _PREFIXES.clear()
 
 
 def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, structure: bool = False,
-            learn: bool = True) -> dict:
+            learn: bool = True, both_sides: bool = False) -> dict:
     S, T = load(source_db), load(target_db)
     mapping = mapping or {}
     exact_ix, norm_ix, comp_ix, all_short = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)
@@ -357,7 +363,7 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
                 tm.setdefault(_short(nt), T["types"][nt])
             tm_norm = {norm_member(k): k for k in tm}
             for nm, sym in sorted(S["members"].get(sfq, {}).items()):
-                if nm in ("body", "init", "deinit", "hash", "description", "encode", "hashValue") or sym["override"]:
+                if nm in BOILERPLATE or sym["override"]:
                     out["skipped"] += 1          # lifecycle / platform overrides (viewDidLoad, onCreate) and boilerplate
                     continue
                 if nm in tm:
@@ -375,7 +381,7 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
     match_members(tmap)
     if structure:
         _structure(S, T, out, tmap, learn)
-        inferred = {r["symbol"]: r["target"] for r in out["matched"] if r.get("confidence") in ("structure", "learned")
+        inferred = {r["symbol"]: r["target"] for r in out["matched"] if r.get("confidence") in INFERRED
                     and r["symbol"] in S["types"] and r["target"] in T["types"]}
         match_members(inferred)
     counts = defaultdict(int)
@@ -387,10 +393,44 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
                       "missing": len(out["missing"]), "unknown": len(out["unknown"]),
                       "platform_only": len(out["platform_only"])}
     if structure:
-        out["summary"]["inferred"] = sum(1 for r in out["matched"] if r["confidence"] in ("structure", "learned"))
+        out["summary"]["inferred"] = sum(1 for r in out["matched"] if r["confidence"] in INFERRED)
+    if both_sides:
+        _target_only(T, out, t_nested)
+        out["summary"]["target_only"] = len(out["target_only"])
     return out
 
 
+BOILERPLATE = ("body", "init", "deinit", "hash", "description", "encode", "hashValue")
+
+
+def _target_only(T, out, t_nested):
+    """`--both-sides`: target types and top-level symbols no source symbol matched, and the unmatched members of
+    target types that were matched. Members of an unmatched type are counted under it, not listed."""
+    used = {r["target"] for r in out["matched"]}
+    rows, hidden = [], 0
+    for coll in (T["types"], T["top"]):
+        for fq, sym in sorted(coll.items()):
+            if fq in used:
+                continue
+            owner = fq.rsplit(".", 1)[0] if "." in fq else None
+            if owner in T["types"] and owner not in used:
+                continue                       # a nested type of an unmatched type: the type is listed
+            if PREVIEW_NAME.search(_short(fq)) or sym["file"] in T["err_files"]:
+                hidden += 1
+                continue
+            rows.append(_row(sym, None, None))
+    for o in sorted(o for o in T["members"] if o in used):
+        for nm, sym in sorted(T["members"][o].items()):
+            if f"{o}.{nm}" in used:
+                continue
+            if nm in BOILERPLATE or sym["override"] or sym["file"] in T["err_files"]:
+                hidden += 1
+                continue
+            rows.append(_row(sym, None, None))
+    out["target_only"] = rows
+    out["target_only_hidden"] = hidden
+
+
 def _structure(S, T, out, tmap, learn):
     from . import parity_structure as PS
     sym_of, cat_of, t_syms, t_cat = {}, {}, {}, {}
@@ -409,7 +449,7 @@ def _structure(S, T, out, tmap, learn):
 
 def rename_map(res: dict) -> dict:
     """The structure / learned matches as a `--map` file ({source: target}) to review and commit."""
-    return {r["symbol"]: r["target"] for r in res["matched"] if r.get("confidence") in ("structure", "learned")}
+    return {r["symbol"]: r["target"] for r in res["matched"] if r.get("confidence") in INFERRED}
 
 
 def _row(sym, target, how, owner_match=None) -> dict:
@@ -435,6 +475,25 @@ def _group(file: str) -> str:
     return "/".join(parts[:2]) if len(parts) > 2 else (parts[0] if parts else "")
 
 
+def _grouped(lines, title, rows, total, max_items):
+    by = defaultdict(list)
+    for r in rows:
+        by[r["module"]].append(r)
+    if not by:
+        return
+    lines += ["", f"== {title}: {total}"]
+    shown = 0
+    for mod in sorted(by, key=lambda k: -len(by[k])):
+        lines.append(f"  {mod or '.'}  ({len(by[mod])})")
+        for r in by[mod]:
+            if shown >= max_items:
+                break
+            shown += 1
+            lines.append(f"    {r['symbol']}  [{r['kind']}] {r['file']}:{r['line']}")
+    if shown < total:
+        lines.append(f"  ... {total - shown} more (--json for all)")
+
+
 def render(res: dict, max_items: int = 200) -> str:
     s = res["summary"]
     m = s["matched"]
@@ -457,7 +516,14 @@ def render(res: dict, max_items: int = 200) -> str:
                 lines.append(f"    {r['symbol']}  [{r['kind']}] {r['file']}:{r['line']}")
         if shown < s["missing"]:
             lines.append(f"  ... {s['missing'] - shown} more (--json for all)")
-    inferred = [r for r in res["matched"] if r.get("confidence") in ("structure", "learned")]
+    if "target_only" in res:
+        lines[1] += f"; {s['target_only']} only in the target"
+        lines += ["", f"== MATCHED pairs: {sum(m.values())}"]
+        for r in sorted(res["matched"], key=lambda r: (r["confidence"] != "explicit", r["symbol"]))[:max_items]:
+            lines.append(f"    {r['symbol']} -> {r['target']}  [{r['confidence']}]")
+        if sum(m.values()) > max_items:
+            lines.append(f"  ... {sum(m.values()) - max_items} more (--json for all)")
+    inferred = [r for r in res["matched"] if r.get("confidence") in INFERRED]
     if inferred:
         lines += ["", f"== INFERRED matches (not by name): {len(inferred)}"]
         for r in inferred[:max_items]:
@@ -467,6 +533,8 @@ def render(res: dict, max_items: int = 200) -> str:
         if rule is (res.get("learned_rules") or [None])[0]:
             lines += ["", "== LEARNED rename rules"]
         lines.append(f"    {rule['at']}: {rule['from']!r} -> {rule['to']!r} (seen {rule['support']}x)")
+    if "target_only" in res:
+        _grouped(lines, "ONLY IN TARGET (no source counterpart)", res["target_only"], s["target_only"], max_items)
     if res["unknown"]:
         lines += ["", f"== UNKNOWN (file parsed with syntax errors): {s['unknown']}"]
         lines += [f"    {r['symbol']}  {r['file']}:{r['line']}" for r in res["unknown"][:max_items]]

{cg_code_graph-0.23.7 → cg_code_graph-0.23.9}/cg_code_graph/parity_structure.py

@@ -11,8 +11,21 @@ its outgoing edges:
   sym:<target> symbols it calls / instantiates / navigates to that are already paired (the source side is
                rewritten to the target's name, so a call to a paired API on both sides is a shared feature)
   call:<name>  the names of the members it calls (two words or more)
+  res:<name>   image and raw resources it uses (`Image("ic_lock")`, `UIImage(named:)`, `Asset.Images.icLock`,
+               `Image(.icLock)`, `R.drawable.ic_lock`, `Res.drawable.x`), case and `_` folded; colors are design
+               tokens shared by every screen and are left out
   w:<stem>     the stemmed content words of its own name
 
+A use is specific when it appears in at most SPECIFIC_FILES files on each side (files, not symbols, since a type's span
+holds its members'); a pair whose shared uses are all generic needs two shared name words, so two screens that only
+share `l10n:cancel` / `l10n:yes` and one word do not pair.
+
+Types that are still missing after that are paired by their declared fields (`fields`): stored properties, each under
+its wire name when one is declared (Swift `CodingKeys` raw values, Kotlin `@SerialName` / `@SerializedName` /
+`@Json(name =)`), and enum cases, kept apart from properties; case and `_` folded. A pair needs MIN_FIELDS shared
+fields, an IDF-weighted overlap of at least MIN_FIELD_SCORE, a shared name word or a higher overlap, mutual best and
+the margin.
+
 A pair is accepted when it shares a use (any feature but w:) and either two uses or two name words, its IDF-weighted
 cosine is at least MIN_SCORE, both symbols are each other's best candidate, the runner-up scores below MARGIN times
 the best, and category, UI-ness and architecture role agree (`compatible`). Learned rules come from the
@@ -21,6 +34,7 @@ MIN_SUPPORT times, two thirds of the time for that source tail, is applied to th
 top-level symbols. Every match carries its evidence; name matches are left as they are."""
 from __future__ import annotations
 
+import json
 import math
 import re
 import sqlite3
@@ -32,9 +46,16 @@ MIN_SHARED = 2
 MARGIN = 0.8                 # the runner-up must score below MARGIN * best
 MIN_SUPPORT = 2
 MAX_DF = 40
+SPECIFIC_FILES = 3           # a shared use found in more files than this on either side is generic (`l10n:cancel`)
+MIN_FIELDS = 3
+MIN_FIELD_SCORE = 0.5
 PREVIEW = re.compile(r"Preview")           # Compose @Preview functions / PreviewParameterProviders, SwiftUI previews                  # features shared by more symbols than this do not propose candidates
 L10N = re.compile(r"\b(?:Localizations|L10n|R\.string|BitwardenString|CommonStrings|[A-Z]\w*Strings)\.([A-Za-z_]\w*)")
 STR = re.compile(r'"((?:[^"\\\n]|\\.){5,80})"')
+RES = re.compile(r"""\b(?:UI|NS)?Image\(\s*(?:named:\s*)?"([^"\n]+)"|\bAsset\.(?:Images|Assets)\.(\w+)|"""
+                 r"""\bImage\(\s*\.(\w+)\s*\)|\b(?:R|Res)\.(?:drawable|mipmap|raw)\.(\w+)""")
+WIRE = re.compile(r'@(?:SerialName|SerializedName|JsonProperty|Json\(\s*name\s*=)\s*\(?\s*(?:value\s*=\s*)?"([^"\n]+)"')
+RAW_CASE = re.compile(r'\bcase\s+`?(\w+)`?\s*=\s*"([^"\n]+)"')
 EDGE_KINDS = ("CALLS", "INSTANTIATES", "NAVIGATES_TO", "HTTP_CALLS", "USES_VALUE", "REFERENCES_FN", "USES_TYPE")
 
 
@@ -123,8 +144,40 @@ class Side:
         for r in c.execute(q, EDGE_KINDS):
             self.out[r["src"]].append((r["dst"], r["kind"]))
         self.http = {r["id"]: (r["name"] or r["id"]) for r in c.execute("SELECT id, name FROM nodes WHERE kind='http'")}
+        self.decl = defaultdict(list)          # owner fqn -> [(name, kind, file, line)] of stored fields / enum cases
+        for r in c.execute("SELECT kind, fqn, file, line, attrs FROM nodes WHERE kind IN ('field', 'enum_case') "
+                           "AND fqn IS NOT NULL AND file IS NOT NULL"):
+            if ".Companion." in r["fqn"] or "." not in r["fqn"]:
+                continue
+            if r["kind"] == "field" and (json.loads(r["attrs"] or "{}").get("property") or "stored") != "stored":
+                continue
+            o, nm = r["fqn"].rsplit(".", 1)
+            self.decl[o].append((nm, r["kind"], r["file"], r["line"]))
         c.close()
 
+    def fields(self, fq: str) -> set:
+        """`field:<wire name>` for each stored property declared directly on the type: the explicit wire name
+        (`@SerialName("item_title")`, a `CodingKeys` case `title = "item_title"`) or else the property name; `case:<name>`
+        for each enum case, so an enum of field names does not meet the type that has those fields."""
+        raw = {}
+        for nm, kind, file, line in self.decl.get(fq + ".CodingKeys", ()):
+            m = RAW_CASE.search(self.text(file, line, line))
+            if m:
+                raw[m.group(1)] = m.group(2)
+        out = set()
+        for nm, kind, file, line in self.decl.get(fq, ()):
+            wire = raw.get(nm)
+            if not wire and kind == "field":
+                m = WIRE.search(self.text(file, line, line))
+                if not m and line > 1:            # an annotation on its own line above
+                    prev = self.text(file, line - 1, line - 1)
+                    m = None if re.search(r"\b(?:val|var|let)\s", prev) else WIRE.search(prev)
+                wire = m.group(1) if m else None
+            k = _fold(wire or nm)
+            if len(k) > 1:
+                out.add(("case:" if kind == "enum_case" else "field:") + k)
+        return out
+
     def text(self, file: str, a: int, b: int) -> str:
         if file not in self.lines:
             try:
@@ -139,6 +192,9 @@ class Side:
         if file and a:
             src = self.text(file, a, b)
             f |= {"l10n:" + _fold(m) for m in L10N.findall(src)}
+            for m in RES.finditer(src):
+                f.add("res:" + _fold(next(g for g in m.groups() if g)))
+            src = RES.sub(" ", src)
             for m in STR.findall(src):
                 s = m.strip().lstrip("/")
                 if len(s) >= 5 and re.search(r"[A-Za-z]{3}", s) and not re.search(r"\\\(|\$\{|%[@sd]", s):
@@ -250,6 +306,60 @@ def _apply_rules(rules, out, sym_of, cat_of, t_syms, t_cat, used):
     out["missing"] = keep
 
 
+def _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T):
+    """Types still missing, paired by the fields they declare (`ViewItemState` / `VaultItemState`, a Swift
+    `Codable` model and its Kotlin `@Serializable` port)."""
+    src = {r["symbol"]: sS.fields(r["symbol"]) for r in out["missing"] if cat_of.get(r["symbol"]) == "type"
+           and "owner_matched" not in r}
+    src = {k: v for k, v in src.items() if len(v) >= MIN_FIELDS and _short(k) != "CodingKeys"}
+    tgt = {fq: sT.fields(fq) for fq in t_syms if t_cat.get(fq) == "type" and fq not in used}
+    tgt = {k: v for k, v in tgt.items() if len(v) >= MIN_FIELDS and _short(k) != "CodingKeys"}
+    if not src or not tgt:
+        return
+    df = Counter()
+    for fs in list(src.values()) + list(tgt.values()):
+        df.update(fs)
+    n = len(src) + len(tgt)
+    w = {f: math.log(1 + n / c) for f, c in df.items()}
+    inv = defaultdict(list)
+    for fq, fs in tgt.items():
+        for f in fs:
+            inv[f].append(fq)
+
+    def score(fq, t):
+        a, b = src[fq], tgt[t]
+        sh = a & b
+        if len(sh) < MIN_FIELDS:
+            return 0.0, sh
+        sc = sum(w[f] for f in sh) / sum(w[f] for f in a | b)
+        words = name_words(fq) & name_words(t)
+        if sc < MIN_FIELD_SCORE or (not words and sc < 0.75):
+            return 0.0, sh
+        return sc, sh | words
+
+    best = {}
+    for fq, fs in src.items():
+        cands = {t for f in fs if df[f] <= MAX_DF for t in inv[f]
+                 if compatible(fq, "type", t, "type", S["_ui"].get(fq), T["_ui"].get(t))}
+        scored = sorted(((score(fq, t), t) for t in cands), key=lambda x: -x[0][0])
+        if scored and scored[0][0][0] > 0 and (len(scored) == 1 or scored[1][0][0] < MARGIN * scored[0][0][0]):
+            best[fq] = (scored[0][1], scored[0][0][0], scored[0][0][1])
+    by_t = defaultdict(list)
+    for fq, (t, sc, sh) in best.items():
+        by_t[t].append((sc, fq))
+    keep = []
+    for row in out["missing"]:
+        got = best.get(row["symbol"])
+        if got and max(by_t[got[0]])[1] == row["symbol"] and got[0] not in used:
+            t, sc, sh = got
+            used.add(t)
+            ev = sorted(sh, key=lambda f: (f.startswith("w:"), -w.get(f, 0), f))[:6]
+            out["matched"].append(dict(row, target=t, confidence="fields", score=round(sc, 2), evidence=ev))
+        else:
+            keep.append(row)
+    out["missing"] = keep
+
+
 def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
     sS, sT = Side(S), Side(T)
     pairs = {r["symbol"]: r["target"] for r in out["matched"]}
@@ -264,6 +374,12 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
     df = Counter()
     for fs in list(src_f.values()) + list(tgt_f.values()):
         df.update(fs)
+    spread = [defaultdict(set), defaultdict(set)]          # feature -> files having it, per side
+    for k, (fsets, syms) in enumerate(((src_f, sym_of), (tgt_f, t_syms))):
+        for fq, fs in fsets.items():
+            for f in fs:
+                spread[k][f].add(syms[fq]["file"])
+    specific = {f for f in df if len(spread[0][f]) <= SPECIFIC_FILES and len(spread[1][f]) <= SPECIFIC_FILES}
     n = max(1, len(src_f) + len(tgt_f))
     w = {f: math.log(1 + n / c) for f, c in df.items()}
     inv = defaultdict(list)
@@ -278,6 +394,8 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         # what they use must carry the match: two shared uses, or one use and two shared name words
         if nw < 1 or (nw < MIN_SHARED and len(sh) - nw < 2):
             return 0.0, sh
+        if len(sh) - nw < 2 and not any(f in specific for f in sh if not f.startswith("w:")):
+            return 0.0, sh                      # only generic uses (`l10n:cancel`, `l10n:yes`) and one name word
         return sum(w[f] for f in sh) / math.sqrt(sum(w[f] for f in a) * sum(w[f] for f in b)), sh
 
     best_s = {}
@@ -305,3 +423,4 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         else:
             keep.append(row)
     out["missing"] = keep
+    _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)

{cg_code_graph-0.23.7 → cg_code_graph-0.23.9}/cg_code_graph/platforms.py

@@ -254,6 +254,29 @@ OTHER_OS_STEM = re.compile(r"(?:^|[_-])(aix|sunos|solaris|os390|zos|ibmi|freebsd
                            r"cygwin|hurd|illumos|pase)$", re.I)
 
 
+# Swift platform files (#225): `Foo+iOS.swift`, `Foo.macOS.swift`, `Foo_watchOS.swift`, or a folder `macOS/` / `iOS/`
+# of a multiplatform app. A guess: built for that platform, unknown on the other Apple platforms, absent elsewhere
+SWIFT_PLAT = {"ios": "ios", "iphone": "ios", "ipados": "ios", "macos": "macos", "osx": "macos", "mac": "macos",
+              "appkit": "macos", "tvos": "tvos", "watchos": "watchos", "visionos": "visionos", "xros": "visionos"}
+SWIFT_STEM = re.compile(r"[+._-](iOS|iPhone|iPadOS|macOS|OSX|Mac|AppKit|tvOS|watchOS|visionOS|xrOS)$")
+SWIFT_DIR = re.compile(r"^(iOS|iPadOS|macOS|OSX|tvOS|watchOS|visionOS|xrOS)$")
+APPLE = ("ios", "macos", "tvos", "watchos", "visionos")
+
+
+def swift_path_convention(rel: str) -> tuple[str, str] | None:
+    parts = rel.split("/")
+    stem = parts[-1][:-len(".swift")] if parts[-1].endswith(".swift") else None
+    if stem is None:
+        return None
+    m = SWIFT_STEM.search(stem)
+    if m:
+        return SWIFT_PLAT[m.group(1).lower()], f"file name {parts[-1]}"
+    for d in parts[:-1]:
+        if SWIFT_DIR.match(d):
+            return SWIFT_PLAT[d.lower()], f"directory {d}/"
+    return None
+
+
 def _plat_atom(name: str):
     if name == "other":                            # an OS outside the known targets
         return ("atom", "platform", "__other__")
@@ -655,6 +678,18 @@ def apply(project, builder) -> dict:
                 tree = ("any", [_plat_atom(p) for p in ps]) if len(ps) > 1 else _plat_atom(ps[0])
                 names = ", ".join(m["targets"][:3]) + (" …" if len(m["targets"]) > 3 else "")
                 mark(builder, f, 1, BIG, Cond("tree", tree, f"Xcode target membership ({names})"), line=1)
+    if "swift" in langs and pc.get("path_conventions", True):
+        whole = {m["file"] for m in builder.platform_marks if m["start"] <= 1 and m.get("end") in (None, BIG)}
+        for f, ns in nodes_by_file.items():
+            if f in whole or ns[0].lang != "swift":
+                continue                         # Xcode membership (or .cg.yaml paths) already says where it is built
+            pcv = swift_path_convention(f)
+            if pcv:
+                n0 = len(builder.platform_marks)
+                tree = ("any", [_plat_atom(pcv[0])] + [("atom", "unknown_on", p) for p in APPLE if p != pcv[0]])
+                mark(builder, f, 1, BIG, Cond("tree", tree, f"{pcv[1]} (platform file name)"), line=1)
+                if len(builder.platform_marks) > n0:
+                    builder.platform_marks[-1]["convention"] = True
     marks = builder.platform_marks
     if not marks:
         return {}

{cg_code_graph-0.23.7 → cg_code_graph-0.23.9}/cg_code_graph/plugins/kotlin/plugin.py

@@ -296,6 +296,8 @@ class KotlinPlugin(LanguagePlugin):
         if files is None:
             files = source_files(project.root, project)
         self.decls: dict[str, Decl] = {}
+        self.rets: dict[str, str] = {}       # function / method id -> declared (or constructed) result type text (#109)
+        self._ksrc: dict[str, bytes] = {}
         self.test_fw: dict[str, str | None] = {}
         self._fd = None
         self.by_name: dict[str, list[Decl]] = defaultdict(list)
@@ -361,7 +363,8 @@ class KotlinPlugin(LanguagePlugin):
                     tree = nt
                     self.st["files_reparsed_by_member"] += 1
                     self.st["members_dropped_by_reparse"] += len(dropped)
-            kf = KFile(rel, src, tree)            # names and text from the original bytes; offsets are unchanged
+            kf = KFile(rel, src, tree)
+            self._ksrc[rel] = src            # names and text from the original bytes; offsets are unchanged
             if tree.root_node.has_error or dropped:
                 self.st["files_with_syntax_errors"] += 1
                 errs[rel] = merge(tree_spans(tree.root_node) + [list(x) for x in dropped])
@@ -608,6 +611,9 @@ class KotlinPlugin(LanguagePlugin):
                           self._params(params) if params is not None else {}, kf.test, self._name_line(c),
                           slots=self._fn_slots(params))
                 self._local_types(c, dc.types)
+                rt = self._ret_text(c)
+                if rt is not None:
+                    self.rets[dc.id] = rt if self.rets.get(dc.id, rt) == rt else ""
                 if any(dflt for _n, dflt, _f in fparams):
                     self.fn_params[dc.id] = fparams
                 self._add_decl(dc, kind)
@@ -1970,11 +1976,28 @@ class KotlinPlugin(LanguagePlugin):
                             **({"via": write} if isinstance(write, str) else {}))
             self.st["stored_property_writes" if write else "stored_property_reads"] += 1
 
-    def _local_type(self, decl: Decl, name: str, kf: KFile) -> str | None:
-        """`val d = Cart(...)` inside the function body: the constructed type of a local."""
+    def _local_type(self, decl: Decl, name: str, kf: KFile, depth: int = 0) -> str | None:
+        """`val d = Cart(...)` inside the function body: the constructed type of a local; also `val g: Garage<E>`,
+        `val g = Garage<E>(..)` and `val e = shop.engine()` through the call chain's declared result (#109)."""
         src = "\n".join(kf.src.decode("utf-8", "replace").split("\n")[decl.line - 1:decl.end])
-        m = re.search(r"\b(?:val|var)\s+" + re.escape(name) + r"\s*(?::\s*([A-Z][\w.]*))?\s*=\s*([A-Z][\w.]*)\s*\(", src)
-        return (m.group(1) or m.group(2)) if m else None
+        m = re.search(r"\b(?:val|var)\s+" + re.escape(name) +
+                      r"\s*(?::\s*([A-Z][\w.]*(?:<[^=\n]*?>)?))?\s*=\s*([A-Z][\w.]*(?:<[^=\n(){}]*?>)?)\s*\(", src)
+        if m:
+            return m.group(1) or m.group(2)
+        m = re.search(r"\b(?:val|var)\s+" + re.escape(name) + r"\s*(?::\s*([A-Z][\w.]*(?:<[^=\n]*?>)?)\s*\??)?\s*="
+                      r"\s*([^\n;]*)", src)
+        if not m:
+            return None
+        if m.group(1):
+            return m.group(1)
+        rhs = m.group(2).strip()
+        if depth > 2 or not re.fullmatch(r"[a-z_][\w]*(?:\([^()]*\))?(?:\s*[?!]*\.\s*\w+(?:\([^()]*\))?)*", rhs) \
+                or rhs.split(".")[0].split("(")[0] == name:
+            return None
+        if "(" not in rhs and "." not in rhs:
+            return None
+        c, args = self._expr_type(rhs, kf, decl, depth + 1)
+        return (c.name + (f"<{', '.join(args)}>" if args else "")) if c is not None else None
 
     def _prop_member(self, cls: Decl, name: str, depth: int = 0) -> list[Decl]:
         hit = self.prop_members.get(cls.fqn, {}).get(name)
@@ -2056,6 +2079,140 @@ class KotlinPlugin(LanguagePlugin):
                                 **({"binding": how} if how else {}))
                 self.st[{"read": "property_reads", "write": "property_writes"}.get(m, "property_read_writes")] += 1
 
+    def _ret_text(self, c) -> str | None:
+        """`fun f(): Garage<Engine>?` -> 'Garage<Engine>'; `fun f() = Engine(..)` -> 'Engine' (#109)."""
+        kids = c.children
+        seen_params = False
+        for i, x in enumerate(kids):
+            if x.type == "function_value_parameters":
+                seen_params = True
+            elif seen_params and x.type == ":" and i + 1 < len(kids):
+                return self.t(kids[i + 1]).rstrip("?! ").strip()
+            elif seen_params and x.type == "function_body":
+                m = re.match(r"=\s*([A-Z]\w*(?:<[^=\n(){}]*?>)?)\s*\(", self.t(x))
+                return m.group(1) if m else None
+        return None
+
+    @staticmethod
+    def _split_type(txt: str | None) -> tuple[str | None, list]:
+        """'Garage<Engine, Map<A, B>>?' -> ('Garage', ['Engine', 'Map'])."""
+        if not txt:
+            return None, []
+        m = re.match(r"\s*([A-Z][\w.]*)\s*(?:<(.*)>)?", txt, re.S)
+        if not m:
+            return None, []
+        args, depth, cur = [], 0, ""
+        for ch in (m.group(2) or "") + ("," if m.group(2) else ""):
+            if ch in "<([":
+                depth += 1
+            elif ch in ">)]":
+                depth -= 1
+            if ch == "," and depth == 0:
+                a = re.match(r"\s*(?:out\s+|in\s+)?([A-Z][\w.]*)", cur)
+                args.append(a.group(1).split(".")[-1] if a else "")
+                cur = ""
+            else:
+                cur += ch
+        return m.group(1).split(".")[-1], args
+
+    def _gparams(self, cls: Decl) -> list[str]:
+        cache = self.__dict__.setdefault("_gp_cache", {})
+        if cls.id not in cache:
+            src = self._ksrc.get(cls.file, b"").decode("utf-8", "replace").split("\n")[cls.line - 1:cls.line + 2]
+            m = re.search(r"\b(?:class|interface)\s+" + re.escape(cls.name) + r"\s*<([^>{(]*)>", "\n".join(src))
+            cache[cls.id] = [re.split(r"[:\s]", re.sub(r"^\s*(?:out|in|reified)\s+", "", x).strip())[0]
+                             for x in m.group(1).split(",")] if m else []
+        return cache[cls.id]
+
+    def _full_type(self, where: Decl | None, name: str, ty: str | None) -> str | None:
+        """Parameter / property types are kept without their generic arguments; read them back from the declaring
+        span (`val garage: Garage<Engine>`, `fun f(g: Garage<Engine>)`) when the stored type is generic there."""
+        if where is None or not ty or "<" in ty:
+            return ty
+        src = "\n".join(self._ksrc.get(where.file, b"").decode("utf-8", "replace").split("\n")[where.line - 1:where.end])
+        m = re.search(r"\b" + re.escape(name) + r"\s*:\s*((?:[\w]+\.)*" + re.escape(ty) + r"\s*<[^=\n(){}]*>)", src)
+        return m.group(1) if m else ty
+
+    def _as_class(self, txt: str | None, owner: Decl | None, args: list, kf: KFile) -> tuple:
+        """A declared type text read on a receiver: a generic parameter of `owner` becomes the receiver's argument."""
+        name, targs = self._split_type(txt)
+        if name is None:
+            return None, []
+        if owner is not None:
+            gp = self._gparams(owner)
+            if name in gp:
+                i = gp.index(name)
+                name, targs = (args[i] if i < len(args) and args[i] else None), []
+                if name is None:
+                    return None, []
+        c = self._class_of(name, kf)
+        return c, targs
+
+    def _expr_type(self, txt: str, kf: KFile, decl: Decl | None, depth: int = 0) -> tuple:
+        """The project class of a receiver expression (`shop.engine()`, `Garage<E>(e).get()`, `makeShop().engine()`,
+        `repo.items.first()`), with its generic arguments; (None, []) when a step is not known (#109)."""
+        if depth > 3 or not txt:
+            return None, []
+        segs, d, cut, q = [], 0, 0, False
+        t = txt.strip()
+        for i, ch in enumerate(t):
+            if ch == '"':
+                q = not q
+            if q:
+                continue
+            if ch in "([{<" and not (ch == "<" and not t[cut:i].strip()[:1].isupper()):
+                d += 1
+            elif ch in ")]}>" and d > 0:
+                d -= 1
+            elif ch == "." and d == 0:
+                segs.append(t[cut:i])
+                cut = i + 1
+        segs.append(t[cut:])
+        segs = [x.strip().rstrip("?!").strip() for x in segs]
+        cls = self.classes.get(decl.cls) if decl is not None and decl.cls else None
+        cur, args = None, []
+        for i, seg in enumerate(segs):
+            m = re.match(r"^([A-Za-z_]\w*)\s*(<[^=\n(){}]*?>)?\s*(\(|\{)?", seg)
+            if not m:
+                return None, []
+            ident, ga, called = m.group(1), m.group(2), m.group(3)
+            if i == 0:
+                if ident == "this":
+                    cur = cls
+                elif ident[:1].isupper():
+                    cur = self._class_of(ident, kf)
+                    args = self._split_type(ident + (ga or ""))[1]
+                elif called:
+                    ds = [x for x in self._member(cls, ident) if x.kind != "class"] if cls is not None else []
+                    if not ds:
+                        ds = [x for x in self.by_name.get(ident, []) if x.kind == "function"]
+                    rets = {self.rets.get(x.id) for x in ds}
+                    if len(rets) != 1 or not next(iter(rets)):
+                        return None, []
+                    cur, args = self._as_class(next(iter(rets)), None, [], kf)
+                else:
+                    ty = (self._full_type(decl, ident, decl.types.get(ident)) if decl is not None else None) or \
+                        (self._full_type(cls, ident, self._field_type(cls, ident)) if cls is not None else None) or \
+                        (self._local_type(decl, ident, kf, depth + 1) if decl is not None and decl.kind != "class" else None)
+                    cur, args = self._as_class(ty, None, [], kf)
+                if cur is None:
+                    return None, []
+                continue
+            owner = cur
+            if called:
+                ds = [x for x in self._member(cur, ident) if x.kind != "class"]
+                rets = {self.rets.get(x.id) for x in ds}
+                if len(rets) != 1 or not next(iter(rets)):
+                    return None, []
+                dcls = self.classes.get(ds[0].cls) if ds[0].cls else cur
+                cur, args = self._as_class(next(iter(rets)), dcls, args, kf)
+            else:
+                ty = self._full_type(cur, ident, self._field_type(cur, ident))
+                cur, args = self._as_class(ty, owner, args, kf)
+            if cur is None:
+                return None, []
+        return cur, args
+
     def _targets(self, name: str, recv: str | None, kf: KFile, decl: Decl | None) -> list[Decl]:
         cls = self.classes.get(decl.cls) if decl is not None and decl.cls else None
         if recv is None or recv == "this":
@@ -2098,6 +2255,13 @@ class KotlinPlugin(LanguagePlugin):
             tyname = decl.types.get(rname)
         if tyname is None and cls is not None:
             tyname = self._field_type(cls, rname)
+        if tyname is None and ("." in recv.strip("?!") or "(" in recv or rname[:1].islower()):
+            tc, _args = self._expr_type(recv, kf, decl)          # `shop.engine().run()`, a local from a call (#109)
+            if tc is not None:
+                r = self._member(tc, name)
+                if r:
+                    self._recv = tc
+                    return self._same_set(r, kf)
         if tyname is None and rname[:1].isupper():
             tyname = re.sub(r"\s*[({].*$", "", rname, flags=re.S)     # `WishController().add(x)`: a WishController
         if tyname: