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

{cg_code_graph-0.23.8/cg_code_graph.egg-info → cg_code_graph-0.23.10}/PKG-INFO

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

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

{cg_code_graph-0.23.8 → cg_code_graph-0.23.10}/cg_code_graph/parity_structure.py

@@ -56,6 +56,11 @@ RES = re.compile(r"""\b(?:UI|NS)?Image\(\s*(?:named:\s*)?"([^"\n]+)"|\bAsset\.(?
                  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]+)"')
+ARM = re.compile(r"^(\s*)case\s+(?:let\s+|var\s+)?((?:\.\w+(?:\([^)]*\))?\s*,?\s*)+)(?:where\b[^:]*)?:")
+DISPATCH = {"receive", "perform", "handle", "handleaction", "onaction", "reduce", "send", "dispatch", "process"}
+MIN_MEMBER_SCORE = 0.35
+MIN_NAME_SCORE = 0.45
+MIN_BOTH_SCORE = 0.25
 EDGE_KINDS = ("CALLS", "INSTANTIATES", "NAVIGATES_TO", "HTTP_CALLS", "USES_VALUE", "REFERENCES_FN", "USES_TYPE")
 
 
@@ -140,9 +145,11 @@ class Side:
             self.by_file[r["file"]].append((r["line"], r["end_line"] or r["line"], r["id"]))
             self.span[r["id"]] = (r["file"], r["line"], r["end_line"] or r["line"])
         self.out = defaultdict(list)
-        q = f"SELECT src, dst, kind FROM edges WHERE kind IN ({','.join('?' * len(EDGE_KINDS))})"
+        self.out_at = defaultdict(list)        # src -> [(line, dst, kind)]
+        q = f"SELECT src, dst, kind, line FROM edges WHERE kind IN ({','.join('?' * len(EDGE_KINDS))})"
         for r in c.execute(q, EDGE_KINDS):
             self.out[r["src"]].append((r["dst"], r["kind"]))
+            self.out_at[r["src"]].append((r["line"] or 0, 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') "
@@ -202,21 +209,50 @@ class Side:
             for la, lb, nid in self.by_file.get(file, ()):
                 if a <= la <= b:
                     for dst, kind in self.out.get(nid, ()):
-                        if kind == "HTTP_CALLS" or dst in self.http:
-                            p = re.sub(r"\{[^}]*\}|(?<=/):\w+", "{}", self.http.get(dst, dst).split(" ")[-1])
-                            f.add("http:" + p.lstrip("/").lower())
-                            continue
-                        dq = self.fqn_of.get(dst)
-                        t = rename(dq)
-                        if t:
-                            f.add("sym:" + t)
-                        # the called member's own name (two words or more): `getDevices` on an AuthService and on
-                        # an AuthRepository is the same call even when the owners are not paired
-                        nm = _short(dq or "").split("(")[0]
-                        if kind == "CALLS" and len(_words(nm)) >= 2:
-                            f.add("call:" + re.sub(r"^(get|fetch|load)(?=[a-z])", "", _fold(nm)))
+                        self._edge(f, dst, kind, rename)
         return f
 
+    def _edge(self, f: set, dst: str, kind: str, rename) -> None:
+        if kind == "HTTP_CALLS" or dst in self.http:
+            p = re.sub(r"\{[^}]*\}|(?<=/):\w+", "{}", self.http.get(dst, dst).split(" ")[-1])
+            f.add("http:" + p.lstrip("/").lower())
+            return
+        dq = self.fqn_of.get(dst)
+        t = rename(dq)
+        if t:
+            f.add("sym:" + t)
+        # the called member's own name (two words or more): `getDevices` on an AuthService and on
+        # an AuthRepository is the same call even when the owners are not paired
+        nm = _short(dq or "").split("(")[0]
+        if kind == "CALLS" and len(_words(nm)) >= 2:
+            f.add("call:" + re.sub(r"^(get|fetch|load)(?=[a-z])", "", _fold(nm)))
+
+    def arms(self, sym: dict) -> list:
+        """The top-level `case .x:` arms of a Swift `receive(_:)` / `perform(_:)` style switch: [(case names,
+        features of what the arm calls)]."""
+        file, a, b = self.span.get(sym["id"], (None, 0, 0))
+        if not file or b <= a:
+            return []
+        rows = self.text(file, a, b).split("\n")
+        hits = [(i, len(m.group(1)), m.group(2)) for i, ln in enumerate(rows) for m in [ARM.match(ln)] if m]
+        if not hits:
+            return []
+        top = min(h[1] for h in hits)
+        hits = [h for h in hits if h[1] == top]
+        out = []
+        for k, (i, _, names) in enumerate(hits):
+            lo, hi = a + i, (a + hits[k + 1][0] - 1 if k + 1 < len(hits) else b)
+            f = set()
+            for ln, dst, kind in self.out_at.get(sym["id"], ()):
+                if lo <= ln <= hi:
+                    self._edge(f, dst, kind, lambda x: x)
+            for la, lb, nid in self.by_file.get(file, ()):
+                if lo <= la <= hi and nid != sym["id"]:
+                    for dst, kind in self.out.get(nid, ()):
+                        self._edge(f, dst, kind, lambda x: x)
+            out.append((re.findall(r"\.(\w+)", names), f))
+        return out
+
 
 def match(S: dict, T: dict, out: dict, sym_of: dict, cat_of: dict, t_syms: dict, t_cat: dict, learn: bool = True) -> dict:
     ui_s = {fq: is_ui(fq, sym, S["members"]) for fq, sym in sym_of.items()}
@@ -369,7 +405,8 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         if sym is not None:
             src_f[row["symbol"]] = sS.features(sym, lambda x: pairs.get(x)) | name_words(row["symbol"])
     tgt_f = {fq: sT.features(sym, lambda x: x) | name_words(fq) for fq, sym in t_syms.items()
-             if fq not in used and not PREVIEW.search(_short(fq))}
+             if fq not in used and not PREVIEW.search(_short(fq))
+             and not (_fold(_short(fq).split("(")[0]) in DISPATCH and sT.arms(sym))}    # its arms are paired below
     src_f = {fq: f for fq, f in src_f.items() if not PREVIEW.search(_short(fq))}
     df = Counter()
     for fs in list(src_f.values()) + list(tgt_f.values()):
@@ -423,4 +460,88 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         else:
             keep.append(row)
     out["missing"] = keep
+    _members(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)
     _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)
+
+
+def _members(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T):
+    """Members of matched types still missing, paired inside the counterpart type (#227): with an unmatched member,
+    or a top-level function, that makes the same paired calls, or with a `case .x:` arm of its `receive(_:)` /
+    `perform(_:)` switch (`handleCopyClick` on a view model, `case .copyGeneratedValue:` in the processor). Uses are
+    weighed within the pair of types, so a call that is common across the project still tells two members apart."""
+    pairs = {r["symbol"]: r["target"] for r in out["matched"]}
+    by_owner = defaultdict(list)
+    for r in out["missing"]:
+        if r.get("owner_matched") and r["symbol"] in sym_of and not PREVIEW.search(_short(r["symbol"])):
+            by_owner[r["owner_matched"]].append(r)
+    if not by_owner:
+        return
+    ident = lambda x: x  # noqa: E731
+    top, top_inv = None, defaultdict(list)
+    taken_arms, best, cand_of = set(), {}, {}
+    for o, rows in by_owner.items():
+        units = []                                   # (key, target fqn, case name or None, category, features)
+        for nm, sym in T["members"].get(o, {}).items():
+            fq = f"{o}.{nm}"
+            arms = sT.arms(sym) if _fold(nm.split("(")[0]) in DISPATCH else []
+            for names, f in arms:                    # a dispatching switch stands for its arms, not as a whole
+                ws = set().union(*(name_words(n) for n in names))
+                units.append(((fq, names[0]), fq, names[0], "func", f | ws))
+            if not arms and fq not in used and not PREVIEW.search(nm):
+                units.append((fq, fq, None, t_cat.get(fq), sT.features(sym, ident) | name_words(fq)))
+        src = {r["symbol"]: sS.features(sym_of[r["symbol"]], pairs.get) | name_words(r["symbol"]) for r in rows}
+        if top is None:                              # top-level functions, met only through two paired uses
+            top = {}
+            for fq, sym in t_syms.items():
+                if t_cat.get(fq) == "func" and fq not in used and "." not in fq.replace(o, "") and fq in T["top"]:
+                    top[fq] = {f for f in sT.features(sym, ident) if f.startswith("sym:")} | name_words(fq)
+                    for f in top[fq]:
+                        if f.startswith("sym:"):
+                            top_inv[f].append(fq)
+        df = Counter()
+        for fs in list(src.values()) + [u[4] for u in units]:
+            df.update(fs)
+        n = len(src) + len(units)
+        for fq, fs in src.items():
+            extra = {t for f in fs if f.startswith("sym:") for t in top_inv.get(f, ())}
+            cands = [u for u in units if u[3] == cat_of.get(fq)] + [(t, t, None, "func", top[t]) for t in extra
+                                                                    if cat_of.get(fq) == "func"]
+            scored = []
+            for key, t, case, cat, tf in cands:
+                sh = fs & tf
+                uses = sum(1 for f in sh if not f.startswith("w:"))
+                words = len(sh) - uses
+                if case is None and t in top and uses < 2:
+                    continue
+                if not (uses >= 2 or (uses and words) or words >= 2):
+                    continue
+                wt = lambda f: math.log(1 + n / df[f]) if df[f] else math.log(1 + n)  # noqa: E731
+                sc = sum(wt(f) for f in sh) / math.sqrt(sum(wt(f) for f in fs) * sum(wt(f) for f in tf))
+                if sc < (MIN_NAME_SCORE if not uses else MIN_BOTH_SCORE if words else MIN_MEMBER_SCORE):
+                    continue                         # names alone must agree more; a use and a name word less
+                scored.append((sc, key, t, case, sh))
+            scored.sort(key=lambda x: -x[0])
+            if scored and (len(scored) == 1 or scored[1][0] < MARGIN * scored[0][0]):
+                best[fq] = scored[0]
+    by_key = defaultdict(list)
+    for fq, (sc, key, *_rest) in best.items():
+        by_key[key].append((sc, fq))
+    keep = []
+    for row in out["missing"]:
+        got = best.get(row["symbol"])
+        if not got:
+            keep.append(row)
+            continue
+        sc, key, t, case, sh = got
+        if max(by_key[key])[1] != row["symbol"] or (case is None and t in used) or key in taken_arms:
+            keep.append(row)
+            continue
+        if case is None:
+            used.add(t)
+        taken_arms.add(key)
+        ev = sorted(sh, key=lambda f: (f.startswith("w:"), f))[:6]
+        r = dict(row, target=t, confidence="structure", score=round(sc, 2), evidence=([f"case .{case}"] if case else []) + ev)
+        if case:
+            r["case"] = case
+        out["matched"].append(r)
+    out["missing"] = keep

{cg_code_graph-0.23.8 → cg_code_graph-0.23.10}/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.8 → cg_code_graph-0.23.10}/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: