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

{cg_code_graph-0.23.8/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.8
+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.8 → 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.8"
+__version__ = "0.23.9"

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

{cg_code_graph-0.23.8 → cg_code_graph-0.23.9}/cg_code_graph/plugins/swift/plugin.py

@@ -181,6 +181,32 @@ LOCAL_DECL = re.compile(
 # that function's declared return type when it is a project type (#218)
 LOCAL_CALL = re.compile(r"\b(?:let|var)\s+(\w+)\s*=\s*(?:try\s*[?!]?\s+)?(?:await\s+)?(?:([A-Z]\w*)\s*\.\s*)?([a-z_]\w*)\s*\(")
 
+# `let g = Garage<Engine>(...)`, `let g: Garage<Engine> = ...`, `var g: Garage<Engine>`: the generic arguments (#109)
+GENERIC_USE = re.compile(r"(?::\s*|=\s*(?:try\s*[?!]?\s+)?(?:await\s+)?)([A-Z][\w.]*)\s*<([^=\n(){}]*?)>")
+LOCAL_GENERIC = re.compile(r"\b(?:let|var)\s+(\w+)\s*" + GENERIC_USE.pattern)
+# `let e = shop.engine()`, `let x = a.b.c()`: a local initialised from a call chain on a value, typed when the chain is (#109)
+LOCAL_CHAIN = re.compile(r"\b(?:let|var)\s+(\w+)\s*=\s*(?:try\s*[?!]?\s+)?(?:await\s+)?"
+                         r"([a-z_]\w*(?:\s*\([^()\n]*\))?(?:\s*[?!]?\.\s*\w+(?:\s*\([^()\n]*\))?)+)[ \t]*(?=\n|$|;)")
+TYPE_HEAD = re.compile(r"\b(?:struct|class|enum|actor|protocol)\s+(\w+)\s*<([^>{]*)>")
+
+
+def _gargs(txt: str) -> list[str]:
+    """`Engine, [String: Int]` -> ['Engine', '']: the top-level generic arguments, simple type names only."""
+    out, depth, cur = [], 0, ""
+    for ch in txt + ",":
+        if ch in "<[(":
+            depth += 1
+        elif ch in ">])":
+            depth -= 1
+        if ch == "," and depth == 0:
+            m = re.fullmatch(r"\s*([A-Z][\w.]*)\s*[?!]?\s*", cur)
+            out.append(m.group(1) if m else "")
+            cur = ""
+        else:
+            cur += ch
+    return out
+
+
 PRIVATE_MODS = frozenset({"private", "fileprivate"})
 
 
@@ -509,6 +535,8 @@ class SwiftPlugin(LanguagePlugin):
         self.prop_refs: list[tuple] = []         # (owner, name, receiver | None, line, sf, decl, write)
         self.sigs: dict[str, list] = defaultdict(list)   # function / init node id -> [((label, optional), ...)]
         self._multi_file: set[str] = set()   # nodes shared by same-name declarations in several files or of mixed access
+        self._srcs: dict[str, bytes] = {}    # file -> source, for generic parameter lists (#109)
+        self._pargs: dict[tuple, list] = {}  # (type fqn, property) -> generic arguments of its declared type (#109)
         self.rets: dict[str, str] = {}   # function / method node id -> declared return type name ('' when overloads differ)
         self.http: list[dict] = []
         self.navs: list[tuple] = []          # (owner, view type name, how, file, line)
@@ -548,6 +576,7 @@ class SwiftPlugin(LanguagePlugin):
                 errs[rel] = tree_spans(tree.root_node)
             sfiles.append(SFile(rel, src, tree))
             sfiles[-1].attr_blocks = blocks
+            self._srcs[rel] = src
         self._fd: dict[str, list[Decl]] = defaultdict(list)
         self._avail_regions: dict[str, list] = {}
         self.deploy = deployment_targets(project.root)
@@ -595,6 +624,7 @@ class SwiftPlugin(LanguagePlugin):
                 self.st["routes_unresolved_handler"] += 1
         self.file_report = {"seen": [sf.rel for sf in sfiles] + failed, "parse_failed": failed, "syntax_errors": errs}
         mode = self._exact(project, [sf.rel for sf in sfiles])
+        self._sfiles = sfiles
         self._apply_available()
         st = dict(self.st)
         st.update({"mode": mode, "files": len(sfiles), "declarations": len(self.decls),
@@ -700,6 +730,8 @@ class SwiftPlugin(LanguagePlugin):
                                 self._raw.setdefault(attrs[-1], self.t(m))
                     else:
                         mods.update(self.t(m).split())
+            elif c.type == "class" and n.type != "class_declaration":
+                mods.add("class")              # a bare `class func make()` / `class var x`: the keyword is no modifier node
         return attrs, mods
 
     def _name(self, n) -> str | None:
@@ -947,6 +979,9 @@ class SwiftPlugin(LanguagePlugin):
                 tn = m.group(1) if m else None
             if nm and tn:
                 d.types[nm] = tn
+                g = GENERIC_USE.search(self.t(x))
+                if g and g.group(1).split(".")[-1] == tn.split(".")[-1]:
+                    self._pargs[(d.fqn, nm)] = _gargs(g.group(2))
 
     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
@@ -1478,8 +1513,11 @@ class SwiftPlugin(LanguagePlugin):
         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
-        if f.type == "simple_identifier":
+        if f.type == "simple_identifier" or self.t(f) == "Self":
             return None, self.t(f), args, lam, line
+        if f.type == "prefix_expression" and len(f.children) == 2 and self.t(f.children[0]) == "." \
+                and f.children[1].type == "simple_identifier":
+            return ".", self.t(f.children[1]), args, lam, line      # `.init(x: 1)`: typed by its context (#108)
         if f.type == "navigation_expression":
             target = f.child_by_field_name("target") or f.children[0]
             sfx = next((x for x in f.children if x.type == "navigation_suffix"), None)
@@ -1517,10 +1555,39 @@ class SwiftPlugin(LanguagePlugin):
                 out.append((self.t(lab).strip() if lab is not None else None, val))
         return out
 
+    def _implicit_ctx(self, c, decl: Decl | None) -> str | None:
+        """The contextual type of an implicit member call `.init(...)` / `.make(...)` (#108): the annotation of the
+        property / local it initialises, or the declared return type of the function whose result it is."""
+        p, cur = c.parent, c
+        while p is not None and p.type in ("parenthesized_expression", "try_expression", "await_expression"):
+            cur, p = p, p.parent
+        if p is None:
+            return None
+        if p.type == "property_declaration":
+            ta = next((x for x in p.children if x.type == "type_annotation"), None)
+            if ta is not None:
+                m = re.match(r":\s*([A-Z][\w.]*)\s*[?!]?\s*$", self.t(ta))
+                return m.group(1) if m else None
+            return None
+        ret_ctx = p.type == "control_transfer_statement" and self.t(p).startswith("return")
+        if p.type == "statements" and len([x for x in p.children if x.is_named]) == 1 and p.parent is not None \
+                and p.parent.type in ("function_body", "computed_property"):
+            ret_ctx = True                       # `func moved() -> Point { .init(x: 1) }`
+        if ret_ctx and decl is not None and decl.kind != "class":
+            r = self.rets.get(decl.id)
+            if r == "Self":
+                return decl.cls
+            return r or None
+        return None
+
     def _call(self, c, sf: SFile, owner: str, decl: Decl | None, ctx: dict) -> bool:
         recv, name, args, lam, line = self._callee(c)
         if not name or not re.match(r"^\w+$", name):
             return False
+        if recv == ".":
+            recv = self._implicit_ctx(c, decl)
+            if recv is None:
+                return False
         al = self._args(args)
         # ---- SwiftUI / UIKit navigation
         if name == "NavigationLink":
@@ -1922,20 +1989,28 @@ class SwiftPlugin(LanguagePlugin):
             if not opens or not closes:
                 return
             if not neg:
-                a, z = kids[opens[0]].start_point[0] + 1, kids[closes[0]].start_point[0] + 1
+                cl = kids[closes[0]]
+                # from the end of the check: the conditions after it (`, Assistant.isAvailable`) run only when it holds
+                a, z = c.end_point[0] + 1, cl.start_point[0] + 1
+                acol, zcol = c.end_point[1] - 1, cl.start_point[1]
             else:                              # `if #unavailable(iOS 17) { old } else { new }`: the else branch
                 if len(opens) < 2:
                     return
-                a, z = kids[opens[1]].start_point[0] + 1, p.end_point[0] + 1
+                o = kids[opens[1]]
+                a, z = o.start_point[0] + 1, p.end_point[0] + 1
+                acol, zcol = o.start_point[1], p.end_point[1]
         elif p.type == "guard_statement" and not neg:
             stmts = p.parent
-            a, z = p.end_point[0] + 2, (stmts.end_point[0] + 1 if stmts is not None else p.end_point[0] + 1)
+            a, z = p.end_point[0] + 1, (stmts.end_point[0] + 1 if stmts is not None else p.end_point[0] + 1)
+            acol, zcol = p.end_point[1], (stmts.end_point[1] if stmts is not None else p.end_point[1])
         else:
             return
         av = self._unmet(av, self.cur.rel if self.cur is not None else "", c.start_point[0] + 1,
                          "#unavailable" if neg else "#available")
         if z >= a and av:
-            regions.append((a, z, av))
+            # columns too (#225): `} else { legacy() }` on the closing line, or a one-line `if #available { } else { }`,
+            # is outside the guarded branch
+            regions.append((a, z, av, acol, zcol))
             self.st["available_branches"] += 1
 
     def _unmet(self, av: dict, rel: str, line: int, what: str) -> dict:
@@ -1961,14 +2036,25 @@ class SwiftPlugin(LanguagePlugin):
         """References inside `if #available(...)` / after `guard #available(...)`: edge attrs.available."""
         if not any(self._avail_regions.values()):
             return
+        srcs = {sf.rel: sf.src.split(b"\n") for sf in getattr(self, "_sfiles", ())}
         for e in self.b.edges.values():
             regs = self._avail_regions.get(e.file)
             if not regs or e.line is None:
                 continue
             av = {}
-            for a, z, v in regs:
-                if a <= e.line <= z:
-                    av = self._vmax(av, v)
+            for a, z, v, acol, zcol in regs:
+                if not a <= e.line <= z:
+                    continue
+                if e.line in (a, z) and e.file in srcs:
+                    dn = self.b.nodes.get(e.dst)
+                    nm = ((dn.name if dn is not None else None) or e.dst.rsplit(".", 1)[-1]).encode()
+                    ln = srcs[e.file][e.line - 1] if e.line - 1 < len(srcs[e.file]) else b""
+                    cols = [m.start() for m in re.finditer(rb"(?<![\w])" + re.escape(nm) + rb"(?![\w])", ln)]
+                    lo = acol if e.line == a else -1
+                    hi = zcol if e.line == z else len(ln) + 1
+                    if cols and not any(lo < c < hi for c in cols):
+                        continue
+                av = self._vmax(av, v)
             if av:
                 e.attrs = {**(e.attrs or {}), "available": av}
                 self.st["available_references"] += 1
@@ -2497,15 +2583,74 @@ class SwiftPlugin(LanguagePlugin):
                 found.append((m.start(), m.group(2), CLOSURE_PARAM_TYPES[m.group(1)]))
             for m in LOCAL_CALL.finditer(txt):
                 found.append((m.start(), m.group(1), self._returned(m.group(2), m.group(3))))
+            for m in LOCAL_CHAIN.finditer(txt):
+                if m.group(2).split(".")[0].split("(")[0].strip() != m.group(1):   # not `let x = x.next()`
+                    found.append((m.start(), m.group(1), ("chain", m.group(2))))
+            gen = {}
+            for m in LOCAL_GENERIC.finditer(txt):
+                gen[m.start()] = _gargs(m.group(3))
             for pos, nm, tn in sorted(found, key=lambda x: x[0]):
-                out[nm].append((decl.line + txt.count("\n", 0, pos), tn))
+                out[nm].append((decl.line + txt.count("\n", 0, pos), tn, gen.get(pos)))
             cache[key] = out
-        best = None
-        for ln, tn in cache[key].get(ident, ()):
+        best, self._largs = None, None
+        for ln, tn, ga in cache[key].get(ident, ()):
             if ln <= line:
-                best = tn
+                best, self._largs = tn, ga
+        if isinstance(best, tuple):
+            # typed by its initialiser's call chain, resolved now (a depth guard against `let a = b.f(); let b = a.g()`)
+            guard = self.__dict__.setdefault("_chain_guard", set())
+            if (key, ident) in guard or len(guard) > 4:
+                return None
+            guard.add((key, ident))
+            try:
+                kind, tn = self._recv_type(best[1], decl, self._encl_type(decl))
+                self._largs = getattr(self, "_rargs", None)
+            finally:
+                guard.discard((key, ident))
+            return tn if kind == "type" else None
         return best
 
+    def _gparams(self, t: Decl | None) -> list[str]:
+        """The generic parameter names of a project type (`struct Garage<T, U: Hashable>` -> ['T', 'U'])."""
+        if t is None or t.file not in self._srcs:
+            return []
+        cache = self.__dict__.setdefault("_gp_cache", {})
+        if t.id not in cache:
+            lines = self._srcs[t.file].decode("utf-8", "replace").split("\n")[t.line - 1:t.line + 2]
+            m = TYPE_HEAD.search("\n".join(lines))
+            cache[t.id] = [re.split(r"[:\s]", x.strip())[0] for x in m.group(2).split(",")] \
+                if m and m.group(1) == t.name else []
+        return cache[t.id]
+
+    def _subst(self, ret: str | None, owner: Decl | None, recv_t: Decl | None, args: list | None) -> tuple:
+        """A member's declared type read on a receiver: `Self` is the receiver's type, a generic parameter of the
+        declaring type is the receiver's generic argument (`Garage<Engine>.get() -> T` is an Engine). (fqn, args)."""
+        if not ret:
+            return None, None
+        if ret == "Self" and recv_t is not None:
+            return recv_t.fqn, args
+        if owner is not None and args:
+            gp = self._gparams(owner)
+            if ret in gp and gp.index(ret) < len(args) and args[gp.index(ret)]:
+                ret = args[gp.index(ret)]
+                rt = self._type(ret)
+                return (rt.fqn if rt is not None and "extension-only" not in rt.modifiers else None), None
+        if owner is not None and ret in self._gparams(owner):
+            return None, None
+        rt = self._type(ret)
+        return (rt.fqn if rt is not None and "extension-only" not in rt.modifiers else None), None
+
+    def _call_result(self, t: Decl | None, name: str, static: bool, args: list | None) -> tuple:
+        """The type a call `T.name(...)` (static) / `value.name(...)` returns, when every declaration agrees (#109)."""
+        if t is None:
+            return None, None
+        ds = [d for d in self._member(t, name) if d.kind == "method" and _static(d) == static]
+        rets = {self.rets.get(d.id) for d in ds}
+        if len(rets) != 1:
+            return None, None
+        owner = self.types.get(ds[0].cls) if ds[0].cls else None
+        return self._subst(next(iter(rets)), owner, t, args)
+
     def _returned(self, tname: str | None, fname: str) -> str | None:
         """The project type a call's result has: the declared return type of the one free function `fname` (of the
         static `tname.fname` when qualified), when every declaration of it agrees and it is a project type (#218)."""
@@ -2534,12 +2679,19 @@ class SwiftPlugin(LanguagePlugin):
         if not segs:
             return "unknown", None
         state: tuple[str, str | None] = ("unknown", None)
+        args: list | None = None              # the generic arguments of the value so far (#109)
+        self._rargs = None
         for i, seg in enumerate(segs):
             seg = seg.rstrip("!?")
             m = re.match(r"^([A-Za-z_]\w*)\s*(.*)$", seg, re.S)
             if not m:
                 return "unknown", None
             ident, rest = m.group(1), m.group(2).strip()
+            targs = None
+            if rest.startswith("<") and ident[:1].isupper():     # `Garage<Engine>(item: e)`
+                g = re.match(r"<([^=\n(){}]*?)>\s*", rest)
+                if g:
+                    targs, rest = _gargs(g.group(1)), rest[g.end():]
             called = rest.startswith(("(", "{"))
             sub = rest.startswith("[")
             if i == 0:
@@ -2552,6 +2704,7 @@ class SwiftPlugin(LanguagePlugin):
                     t = self._type(ident)
                     if t is not None and "extension-only" not in t.modifiers:
                         state = ("type", t.fqn) if called else ("meta", t.fqn)
+                        args = targs
                     else:                            # an SDK type, its initializer or a value built from it
                         state = ("sdk", ident) if t is not None else self._sdk_or_unknown(ident)
                         if called and len(segs) == 1 and state[0] == "sdk":
@@ -2559,11 +2712,24 @@ class SwiftPlugin(LanguagePlugin):
                     if sub:
                         state = ("unknown", None)
                     continue
-                if called:                            # a free function's result
-                    return "unknown", None
+                if called:                            # a free function's (or own method's) result (#109)
+                    rt = None
+                    if cls is not None and self._member(cls, ident):
+                        own_static = bool(decl is not None and decl.kind != "class" and _static(decl))
+                        rt, args = self._call_result(cls, ident, own_static, None)
+                    elif not self.by_name.get(ident) or all(d.kind == "function" for d in self.by_name[ident]):
+                        rt, args = self._returned(None, ident), None
+                    if rt is None or sub:
+                        return "unknown", None
+                    state = ("type", rt)
+                    continue
+                self._largs = None
                 ltn = self._local(decl, ident)
+                args = self._largs if ltn else None
                 tn = ltn or (decl.types.get(ident) if decl is not None else None) or \
                     (cls.types.get(ident) if cls is not None else None)
+                if not ltn and tn and cls is not None and not (decl is not None and ident in decl.types):
+                    args = self._pargs.get((cls.fqn, ident))
                 if tn is None or sub:
                     return "unknown", None
                 t = self._type(tn)
@@ -2582,12 +2748,26 @@ class SwiftPlugin(LanguagePlugin):
                 # anything further down a chain (`Text("x").font(...)`) is some SDK value
                 state = ("sdk", tname if not called and i == 1 and segs[0][:1].isupper() else None)
                 continue
+            if kind in ("type", "meta") and called and not sub:
+                # `shop.engine().run()`, `Garage<E>(..).get().run()`, `Sub.make().ping()` (#109)
+                rt, args = self._call_result(self._type(tname), ident, kind == "meta", args)
+                if rt is None:
+                    return "unknown", None
+                state = ("type", rt)
+                continue
             if kind in ("type", "meta") and not called and not sub:
                 tc = self.types.get(tname)
                 tn = tc.types.get(ident) if tc is not None else None
+                if tc is not None and tn and tn in self._gparams(tc) and args:     # `let item: T` on Garage<E>
+                    rt, _ = self._subst(tn, tc, tc, args)
+                    if rt:
+                        state, args = ("type", rt), None
+                        continue
+                    return "unknown", None
                 t = self._type(tn)
                 if t is not None and "extension-only" not in t.modifiers:
                     state = ("type", t.fqn)
+                    args = self._pargs.get((tc.fqn, ident)) if tc is not None else None
                     continue
                 if tn:
                     state = ("sdk", tn) if t is not None else self._sdk_or_unknown(tn)
@@ -2595,6 +2775,7 @@ class SwiftPlugin(LanguagePlugin):
                         return state
                     continue
             return "unknown", None
+        self._rargs = args
         return state
 
     def _fitting(self, ds: list, labels: tuple, trailing: bool) -> list:
@@ -2681,6 +2862,8 @@ class SwiftPlugin(LanguagePlugin):
                         bool(decl is not None and decl.kind != "class" and _static(decl))
                     return [d for d in fit if _static(d) == want] or (fit if recv is None else
                                                                       [d for d in fit if d.name == "init"])
+            if name == "Self" and cls is not None and "extension-only" not in cls.modifiers:
+                return [cls]                         # `Self(x: 0)` inside the type: its initializer (#108)
             if name[:1].isupper():
                 t = self.types.get(name)
                 return [t] if t is not None else []
@@ -2691,6 +2874,9 @@ class SwiftPlugin(LanguagePlugin):
                 return [min(cands, key=lambda d: ("@" in d.id, d.line))]
             return cands if len(cands) == 1 else []
         kind, tname = self._recv_type(recv, decl, cls)
+        if kind == "meta" and name[:1].isupper():
+            nt = self.types.get(f"{tname}.{name}")       # `Point.Delta(dx: 1)`: a nested type's initializer (#108)
+            return [nt] if nt is not None and "extension-only" not in nt.modifiers else []
         if kind in ("type", "meta"):
             tc = self._type(tname)
             self._recv = tc