cg-code-graph 0.23.5__tar.gz → 0.23.6__tar.gz

{cg_code_graph-0.23.5/cg_code_graph.egg-info → cg_code_graph-0.23.6}/PKG-INFO

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

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

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/kotlin/plugin.py

@@ -305,6 +305,9 @@ class KotlinPlugin(LanguagePlugin):
         self.calls: list[tuple] = []
         self.unresolved_calls: list[tuple] = []          # (owner_id, name, receiver, line, file obj, decl)
         self.call_branch: dict = {}           # (owner_id, line, name) -> {branch, branch_line} (#88)
+        self.call_default: dict = {}          # (owner_id, line, name) -> parameter whose default holds the call (#212)
+        self.call_args: dict = {}             # (owner_id, line, name) -> (positional count, named labels, trailing lambda)
+        self.fn_params: dict = {}             # function id -> [(name, has default, function type)]
         # properties with a custom accessor, `by lazy` or a delegate are nodes (#89); kept out of by_name / members so
         # a call `x()` never binds to one
         self.props: dict[str, dict] = {}                                   # decl id -> {"property", "accessors"}
@@ -599,11 +602,14 @@ class KotlinPlugin(LanguagePlugin):
                 fq = f"{owner}.{nm}" if owner else nm
                 kind = "method" if cls else "function"
                 params = next((d for d in c.children if d.type == "function_value_parameters"), None)
+                fparams = self._param_defaults(params)
                 dc = Decl(f"{kind}:{fq}{self._variant(kf, mods)}", kind, nm, fq, kf.rel, c.start_point[0] + 1,
                           c.end_point[0] + 1, cls.fqn if cls else None, [], anns, mods, recv,
                           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)
+                if any(dflt for _n, dflt, _f in fparams):
+                    self.fn_params[dc.id] = fparams
                 self._add_decl(dc, kind)
                 self._local_fns(c, kf, dc)
             elif ty == "enum_entry" and cls is not None:
@@ -1161,12 +1167,77 @@ class KotlinPlugin(LanguagePlugin):
                     if typ:
                         self.navs.append((owner, None, typ, kf.rel, line))
         self.calls.append((owner, name, rtext, line, kf, decl, self._accessor(c) if owner in self.props else None))
+        dp = self._default_param(c)
+        if dp:
+            self.call_default[(owner, line, name)] = dp
+        if args is not None:
+            vas = [x for x in args.children if x.type == "value_argument"]
+            named = {self.t(x.children[0]) for x in vas if any(k.type == "=" for k in x.children) and x.children}
+            spread = any(self.t(x).lstrip().startswith("*") for x in vas)
+            self.call_args[(owner, line, name)] = (None if spread else len(vas) - len(named), named, lam is not None)
+        elif lam is not None:
+            self.call_args[(owner, line, name)] = (0, set(), True)
         if name[:1].isupper():                      # a constructor or a composable: its branch (#88)
             br = self._branch(c)
             if br:
                 self.call_branch[(owner, line, name)] = br
         return False
 
+    def _param_defaults(self, fvp) -> list:
+        """[(name, has a default value, function-typed)] per value parameter of a `function_value_parameters` node."""
+        out = []
+        kids = list(fvp.children) if fvp is not None else []
+        for i, p in enumerate(kids):
+            if p.type != "parameter":
+                continue
+            ids = [x for x in p.children if x.type == "identifier"]
+            if not ids:
+                continue
+            ft = any(x.type == "function_type" or (x.type == "nullable_type" and "->" in self.t(x)) for x in p.children)
+            out.append((self.t(ids[0]), i + 1 < len(kids) and kids[i + 1].type == "=", ft))
+        return out
+
+    def _default_param(self, c) -> str | None:
+        """The parameter whose default value holds call `c` (`fun render(gamut: Int = currentGamut())`), else None."""
+        x = c
+        while x is not None and x.parent is not None:
+            p = x.parent
+            if p.type == "function_value_parameters":
+                prev = x.prev_sibling
+                if prev is None or prev.type != "=":
+                    return None
+                par = prev.prev_sibling
+                ids = [y for y in par.children if y.type == "identifier"] if par is not None and par.type == "parameter" else []
+                return self.t(ids[0]) if ids else None
+            if p.type in ("function_declaration", "lambda_literal", "anonymous_function", "class_body", "function_body"):
+                return None
+            x = p
+        return None
+
+    def _omitted_defaults(self):
+        """A call that leaves out a defaulted argument runs the default: an edge from the caller to what the default
+        calls, at the call site, with `omits_default` and `default_of` (#212). A call that passes it gets none."""
+        if not self._default_edges:
+            return
+        n = 0
+        for owner, tid, rel, line, key in self._default_sites:
+            defs = self._default_edges.get(tid)
+            params = self.fn_params.get(tid)
+            ca = self.call_args.get(key, (0, set(), False))
+            if not defs or not params or ca[0] is None:
+                continue
+            pos, named, trailing = ca
+            given = {nm for nm, _d, _f in params[:pos]} | named
+            if trailing and params[-1][2]:
+                given.add(params[-1][0])
+            left = {nm for nm, dflt, _f in params if dflt and nm not in given}
+            for label, callee, kind in defs:
+                if label in left and callee != owner:
+                    self.b.add_edge(owner, callee, kind, rel, line, HEURISTIC, omits_default=label, default_of=tid)
+                    n += 1
+        if n:
+            self.st["default_argument_sites"] = n
+
     def _branch(self, c) -> dict:
         """The innermost `if` / `else` / `when` entry around a construction or a composable call inside its function
         (#88): attrs.branch (`if (loading)`, `else of if (loading)`, `when Tab.Home`, `else of when (tab)`) and
@@ -1525,6 +1596,7 @@ class KotlinPlugin(LanguagePlugin):
         return []
 
     def _resolve_calls(self):
+        self._default_edges, self._default_sites = defaultdict(list), []
         for owner, name, recv, line, kf, decl, acc in self.calls:
             self._data_access(owner, name, recv, line, kf, decl)
             self._how = self._recv = None
@@ -1543,17 +1615,24 @@ class KotlinPlugin(LanguagePlugin):
                 how["candidates"] = len(targets)
                 self.st["call_candidate_edges"] += len(targets)
             br = self.call_branch.get((owner, line, name), {})
+            dp = self.call_default.get((owner, line, name))
+            da = {"default_arg": dp} if dp else {}
             for t in targets[:MAX_CANDIDATES if self._how == "candidate" else 3]:
                 if t.kind == "class":
-                    self.b.add_edge(owner, t.id, "INSTANTIATES", kf.rel, line, HEURISTIC, **br)
+                    self.b.add_edge(owner, t.id, "INSTANTIATES", kf.rel, line, HEURISTIC, **br, **da)
                     ctor = [m for m in self.members.get(t.fqn, {}).get("init", [])]
                     self.b.add_edge(owner, t.id, "USES_TYPE", kf.rel, line, HEURISTIC, how="constructor call")
                     for m in ctor:
-                        self.b.add_edge(owner, m.id, "CALLS", kf.rel, line, HEURISTIC)
+                        self.b.add_edge(owner, m.id, "CALLS", kf.rel, line, HEURISTIC, **da)
                 else:
                     composable = br and any(a[0] == "Composable" for a in t.annotations)
-                    self.b.add_edge(owner, t.id, "CALLS", kf.rel, line, HEURISTIC, **how, **(br if composable else {}))
+                    self.b.add_edge(owner, t.id, "CALLS", kf.rel, line, HEURISTIC, **how, **(br if composable else {}), **da)
+                    if self._how != "candidate":
+                        self._default_sites.append((owner, t.id, kf.rel, line, (owner, line, name)))
+                if dp:
+                    self._default_edges[owner].append((dp, t.id, "INSTANTIATES" if t.kind == "class" else "CALLS"))
             self.st["calls_resolved"] += 1
+        self._omitted_defaults()
         self._resolve_reads()
         self._resolve_fields()
         self._resolve_copies()

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/php/extractor/extract.php

@@ -169,6 +169,7 @@ function argsDesc(array $args, Ctx $c, int $depth = 0): array {
         if (!($a instanceof Node\Arg)) { $o[] = ['k' => 'variadic']; continue; }
         $d = desc($a->value, $c, $depth);
         if ($a->name) $d['named'] = $a->name->toString();
+        if ($a->unpack) $d['unpack'] = true;
         $o[] = $d;
         if ($i > 12) break;
     }
@@ -328,7 +329,8 @@ function funcLike($fn, Ctx $c, \PhpParser\NameContext $nc, ?string $doc): array
         $pn = ($p->var instanceof Expr\Variable && is_string($p->var->name)) ? $p->var->name : '?';
         $ts = typeList($p->type);
         if (!$ts && isset($docParams[$pn])) $ts = $docParams[$pn];
-        $params[] = ['name' => $pn, 'types' => $ts, 'promoted' => $p->flags !== 0, 'line' => $p->getStartLine()];
+        $params[] = ['name' => $pn, 'types' => $ts, 'promoted' => $p->flags !== 0, 'line' => $p->getStartLine()]
+            + ($p->default !== null ? ['default' => true] : []) + ($p->variadic ? ['variadic' => true] : []);
     }
     $returns = typeList($fn->returnType ?? null);
     $nullable = ($fn->returnType ?? null) instanceof Node\NullableType
@@ -339,6 +341,14 @@ function funcLike($fn, Ctx $c, \PhpParser\NameContext $nc, ?string $doc): array
     if (isset($fn->stmts) && $fn->stmts !== null) walk($fn->stmts, $c, $nc);
     if ($fn instanceof Expr\ArrowFunction) walk($fn->expr, $c, $nc);
     $skel = (isset($fn->stmts) && $fn->stmts !== null) ? skelStmts($fn->stmts, $c) : [];
+    // a parameter default (`Clock $clock = new SystemClock()`, PHP 8.1) runs on each call that leaves the argument
+    // out: its facts come last, marked with the parameter (#212)
+    foreach ($fn->params as $p) {
+        if ($p->default === null || !($p->var instanceof Expr\Variable) || !is_string($p->var->name)) continue;
+        $lo = count($c->facts);
+        walk($p->default, $c, $nc);
+        for ($i = $lo; $i < count($c->facts); $i++) $c->facts[$i]['default_arg'] = $p->var->name;
+    }
     return ['params' => $params, 'returns' => $returns, 'returns_nullable' => $nullable, 'facts' => $c->facts, 'skel' => $skel];
 }
 

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/php/plugin.py

@@ -509,6 +509,7 @@ class PhpProgram:
         return self.b.has(fn.id)
 
     def emit_references(self):
+        self._dflt_edges = defaultdict(list)      # function id -> [(parameter, callee, kind)] of its defaults (#212)
         self._emit_refs(self.all_funcs, self.fact_handlers)
         # test code: calls / instantiations / class refs plus the test-only handlers; framework handlers (columns,
         # bindings, schedules, listeners...) never run on tests, so a test cannot add facts to the application graph
@@ -516,21 +517,30 @@ class PhpProgram:
 
     def _emit_refs(self, funcs, handlers):
         b = self.b
+        self._dflt_sites = []
+        if not hasattr(self, "_dflt_edges"):
+            self._dflt_edges = defaultdict(list)
         for fn in funcs:
             ctx = ResolveCtx(self, fn)
             for i, f in enumerate(fn.facts):
                 b.current_gate = fn.dead.get(i)
                 t = f["t"]
                 line = f.get("line")
+                da = {"default_arg": f["default_arg"]} if f.get("default_arg") else {}
                 if t == "call":
-                    self._emit_call(fn, f, ctx)
+                    self._emit_call(fn, f, ctx, da)
                 elif t == "new" and f.get("class"):
                     c = self.cls(f["class"])
                     if c:
-                        b.add_edge(fn.id, f"{c.kind}:{c.fqcn}", "INSTANTIATES", fn.file, line, EXACT)
+                        b.add_edge(fn.id, f"{c.kind}:{c.fqcn}", "INSTANTIATES", fn.file, line, EXACT, **da)
                         ctor = self.find_method(c.fqcn, "__construct")
+                        if da:
+                            self._dflt_edges[fn.id].append((da["default_arg"], f"{c.kind}:{c.fqcn}", "INSTANTIATES"))
                         if ctor:
-                            b.add_edge(fn.id, ctor.id, "CALLS", fn.file, line, EXACT)
+                            b.add_edge(fn.id, ctor.id, "CALLS", fn.file, line, EXACT, **da)
+                            self._dflt_sites.append((fn, ctor, f))
+                            if da:
+                                self._dflt_edges[fn.id].append((da["default_arg"], ctor.id, "CALLS"))
                 elif t in ("fetch", "pwrite"):
                     self._emit_prop(fn, f, ctx)
                 elif t == "classref" and f.get("class"):
@@ -543,6 +553,30 @@ class PhpProgram:
                 for h in handlers:
                     h(self, fn, f, ctx)
             b.current_gate = None
+        self._omitted_defaults()
+
+    def _omitted_defaults(self):
+        """A call that leaves out a defaulted argument runs the default (`Clock $clock = new SystemClock()`): an edge
+        from the caller to what the default calls, at the call site, with `omits_default` and `default_of` (#212)."""
+        n = 0
+        for fn, m, f in self._dflt_sites:
+            defs = self._dflt_edges.get(m.id)
+            if not defs:
+                continue
+            args = f.get("args") or []
+            if any(a.get("k") == "variadic" or a.get("unpack") for a in args) or len(args) > 13:
+                continue
+            named = {a["named"] for a in args if a.get("named")}
+            pos = sum(1 for a in args if not a.get("named"))
+            params = m.params or []
+            given = {p["name"] for p in params[:pos]} | named
+            left = {p["name"] for p in params if p.get("default") and p["name"] not in given}
+            for label, dst, kind in defs:
+                if label in left and dst != fn.id:
+                    self.b.add_edge(fn.id, dst, kind, fn.file, f.get("line"), RESOLVED, omits_default=label, default_of=m.id)
+                    n += 1
+        if n:
+            self.stats["default_argument_sites"] += n
 
     def call_targets(self, fn: PhpFunc, f: dict, ctx: ResolveCtx) -> tuple[list, str]:
         """Resolve a call fact to (targets [(PhpFunc, confidence)], status)."""
@@ -579,7 +613,7 @@ class PhpProgram:
             return [(cands[0], HEURISTIC)], "heuristic"
         return [], "unresolved_method"
 
-    def _emit_call(self, fn: PhpFunc, f: dict, ctx: ResolveCtx):
+    def _emit_call(self, fn: PhpFunc, f: dict, ctx: ResolveCtx, da: dict | None = None):
         b, line, kind = self.b, f.get("line"), f["kind"]
         self.stats[f"calls_{kind}"] += 1
         self.last_recv = []
@@ -594,12 +628,16 @@ class PhpProgram:
             own = self.cls(fn.cls)
             if own and not self.last_recv:
                 self.last_recv = [f"{own.kind}:{own.fqcn}"]
+        da = da or {}
         for m, conf in targets:
             if conf == HEURISTIC:
-                b.add_edge(fn.id, m.id, "CALLS", fn.file, line, HEURISTIC, via="unique-method-name")
+                b.add_edge(fn.id, m.id, "CALLS", fn.file, line, HEURISTIC, via="unique-method-name", **da)
             else:
                 b.add_edge(fn.id, m.id, "CALLS", fn.file, line, conf,
-                           **({"recv": sorted(set(self.last_recv))} if self.last_recv else {}), **scope)
+                           **({"recv": sorted(set(self.last_recv))} if self.last_recv else {}), **scope, **da)
+                self._dflt_sites.append((fn, m, f))
+            if da:
+                self._dflt_edges[fn.id].append((da["default_arg"], m.id, "CALLS"))
         if status == "resolved":
             self.stats["calls_resolved"] += 1
         elif status == "heuristic":

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/python/plugin.py

@@ -58,6 +58,23 @@ STOP_METHODS = {"get", "set", "save", "delete", "update", "filter", "all", "item
 ASYNC_WRAPPERS = {"sync_to_async", "async_to_sync", "database_sync_to_async", "run_sync"}
 
 
+def _default_call_params(fn) -> dict[int, str]:
+    """id(call node) -> parameter name, for calls inside a parameter default (`def render(gamut=current_gamut())`).
+    Python evaluates a default once, when the `def` runs, so only the declaration edge is marked (#212)."""
+    a = getattr(fn, "args", None)
+    if a is None:
+        return {}
+    pos = list(a.posonlyargs) + list(a.args)
+    pairs = list(zip(pos[len(pos) - len(a.defaults):], a.defaults)) + \
+        [(k, d) for k, d in zip(a.kwonlyargs, a.kw_defaults) if d is not None]
+    out = {}
+    for arg, d in pairs:
+        for n in ast.walk(d):
+            if isinstance(n, ast.Call):
+                out[id(n)] = arg.arg
+    return out
+
+
 def _recv_attr(prog, call, tgt) -> dict:
     """{"recv": [class ids]} for a call on a receiver whose class inherits the target method, else {}."""
     r = prog.recv.get((id(call.func), id(tgt)))
@@ -1460,16 +1477,18 @@ class PythonPlugin(LanguagePlugin):
             calls: list = []
             body = {id(x) for x in f.node.body}
             rp.scan(f.id, [(c, f.node, id(c) in body) for c in ast.iter_child_nodes(f.node)], ctx, f.file, False, calls)
+            dflt = _default_call_params(f.node)
             for sub in calls:
+                da = {"default_arg": dflt[id(sub)]} if id(sub) in dflt else {}
                 for tgt, conf, via in prog.resolve_call(sub, ctx):
                     if isinstance(tgt, ClassInfo):
-                        b.add_edge(f.id, tgt.id, "INSTANTIATES", f.file, sub.lineno, conf)
+                        b.add_edge(f.id, tgt.id, "INSTANTIATES", f.file, sub.lineno, conf, **da)
                         init = prog.find_method(tgt, "__init__")
                         if init:
-                            b.add_edge(f.id, init.id, "CALLS", f.file, sub.lineno, conf, via="constructor")
+                            b.add_edge(f.id, init.id, "CALLS", f.file, sub.lineno, conf, via="constructor", **da)
                     else:
                         b.add_edge(f.id, tgt.id, "CALLS", f.file, sub.lineno, conf, **({"via": via} if via else {}),
-                                   **_recv_attr(prog, sub, tgt))
+                                   **_recv_attr(prog, sub, tgt), **da)
                     conf_ct[conf] += 1
             n_env += self.env_reads(prog, b, f.id, f.node, ctx)
         for m in prog.modules.values():

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/swift/plugin.py

@@ -177,6 +177,12 @@ LOCAL_DECL = re.compile(
     r"\b(?:let|var)\s+(\w+)\s*(?::\s*(?:some\s+|any\s+)?([A-Z][\w.]*))?\s*(?:=\s*(?:try\s*[?!]?\s+)?(?:await\s+)?"
     r"(?:([A-Z]\w*)\s*(?:<[^=\n]*?>)?\s*\(|((?:true|false)\b|-?\d+\.\d+\b|-?\d+\b|\"))?)?")
 
+# `let r = makeBridge()`, `let r = try await ShelfBridge.make()`: a local initialised from a function's result; typed by
+# 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*\(")
+
+PRIVATE_MODS = frozenset({"private", "fileprivate"})
+
 
 def _static(d) -> bool:
     return bool(STATIC_MODS & d.modifiers)
@@ -502,6 +508,8 @@ class SwiftPlugin(LanguagePlugin):
         self.globals_: dict[str, list] = {}      # file-level constant name -> [(id, file, test, private)]
         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.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)
         # navigationDestination(for: T.self) { switch d { case .x: V() } }: T -> case (None: any) -> view names (#68)
@@ -838,15 +846,27 @@ class SwiftPlugin(LanguagePlugin):
                     # second carries `~static` / `~instance` (like `~2` for a second TypeScript declaration);
                     # overloads of one static-ness still share a node
                     did = f"{did}~{'static' if STATIC_MODS & mods else 'instance'}"
+                ret = None
+                for i, x in enumerate(kids[:-1]):
+                    if x.type == "->":
+                        rm = re.fullmatch(r"\s*([A-Z][\w.]*)\s*[?!]?\s*", self.t(kids[i + 1]))
+                        ret = rm.group(1) if rm else ""
+                        break
                 if did in self.decls:
                     prev = self._prev(did, cls)
                     if not self._branch_variant(prev, sf, c, cls):           # overloads share one node
+                        if self.rets.get(prev.id, ret) != ret:
+                            self.rets[prev.id] = ""
+                        if sf.rel != prev.file or bool(mods & PRIVATE_MODS) != bool(prev.modifiers & PRIVATE_MODS):
+                            self._multi_file.add(prev.id)    # one node for declarations in several files / of mixed access
                         prev.types.update(params)
                         self.sigs[did].append(tuple(sig))
                         self._overloads[(sf.rel, c.start_point[0] + 1, nm)] = prev    # its body's calls are prev's
                         continue
                     did = f"{did}@{c.start_point[0] + 1}"                     # per-platform definition (#if os)
                 self.sigs[did].append(tuple(sig))
+                if ret is not None:
+                    self.rets[did] = ret
                 d = Decl(did, kind, nm, fq, sf.rel, c.start_point[0] + 1, c.end_point[0] + 1,
                          cls.fqn if cls else None, [], attrs, mods, params, sf.test, owner=self._owner(cls))
                 self._add(d, "protocol requirement" if ty == "protocol_function_declaration" else kind)
@@ -2475,6 +2495,8 @@ class SwiftPlugin(LanguagePlugin):
                 found.append((m.start(), nm, tn))
             for m in CLOSURE_PARAM.finditer(txt):         # `Path { p in p.close() }`: p is a Path
                 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 pos, nm, tn in sorted(found, key=lambda x: x[0]):
                 out[nm].append((decl.line + txt.count("\n", 0, pos), tn))
             cache[key] = out
@@ -2484,6 +2506,25 @@ class SwiftPlugin(LanguagePlugin):
                 best = tn
         return best
 
+    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)."""
+        if tname:
+            t = self._type(tname)
+            if t is None or "extension-only" in t.modifiers:
+                return None
+            ds = [d for d in self._member(t, fname) if d.kind == "method" and _static(d)]
+        else:
+            ds = [d for d in self.by_name.get(fname, []) if d.kind == "function"]
+        rets = {self.rets.get(d.id) for d in ds}
+        if len(rets) != 1:
+            return None
+        ret = next(iter(rets))
+        if ret == "Self" and tname:
+            ret = t.fqn
+        rt = self._type(ret) if ret else None
+        return rt.fqn if rt is not None and "extension-only" not in rt.modifiers else None
+
     def _recv_type(self, recv: str, decl: Decl | None, cls: Decl | None) -> tuple[str, str | None]:
         """What a receiver expression is: ("type", T) a value of project type T, ("meta", T) the project type T itself
         (static members), ("sdk", T | None) a value of an SDK type (T when known; modifier chains on SDK views,
@@ -2557,7 +2598,17 @@ class SwiftPlugin(LanguagePlugin):
         return state
 
     def _fitting(self, ds: list, labels: tuple, trailing: bool) -> list:
-        return [d for d in ds if self._fits(d.id, labels, trailing) and self._sees(d, True)]
+        return [d for d in ds if self._fits(d.id, labels, trailing) and self._file_visible(d) and self._sees(d, True)]
+
+    def _file_visible(self, d: Decl) -> bool:
+        """A `private` / `fileprivate` member, or a member of such a type, is not visible from another file (#218)."""
+        at = getattr(self, "_at", None)
+        if at is None or at[0] is None or d.file == at[0].rel or d.id in self._multi_file:
+            return True
+        if d.modifiers & PRIVATE_MODS:
+            return False
+        t = self.types.get(d.cls) if d.cls else None
+        return not (t is not None and t.file == d.file and t.id not in self._multi_file and t.modifiers & PRIVATE_MODS)
 
     def _dispatch_visible(self, d: Decl, caller: str, depth: int = 0) -> bool:
         """A member of a type outside the caller's modules that overrides or implements a member of a supertype the

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6}/cg_code_graph/plugins/ts/extractor/extract.mjs

@@ -1980,6 +1980,7 @@ function addEdge(src, dst, kind, file, line, conf, attrs) {
   edges.push({ src, dst, kind, file, line, confidence: conf, attrs: attrs || undefined })
 }
 const callSites = []
+const defaultCalls = []      // calls inside parameter defaults (#212)
 
 // ---------- class hierarchy: EXTENDS / IMPLEMENTS between project classes, OVERRIDDEN_BY base method -> override ----------
 // (a call on a base-typed value resolves to the base declaration; the override edge lets impact / tests reach the
@@ -1988,7 +1989,9 @@ const callSites = []
   const memberNode = (cls, name) => {
     for (const m of cls.members || []) {
       if (m.name && (ts.isIdentifier(m.name) || ts.isPrivateIdentifier(m.name) || ts.isStringLiteralLike(m.name)) && m.name.text === name
-          && (ts.isMethodDeclaration(m) || ts.isGetAccessor(m) || ts.isSetAccessor(m) || ts.isPropertyDeclaration(m)) && declId.has(m)) return declId.get(m)
+          && (ts.isMethodDeclaration(m) || ts.isGetAccessor(m) || ts.isSetAccessor(m) || ts.isPropertyDeclaration(m)) && declId.has(m)
+          // an instance method never overrides a static one (`static create(Service, ctx)` on a base service, #199)
+          && !(m.modifiers && m.modifiers.some(x => x.kind === ts.SyntaxKind.StaticKeyword))) return declId.get(m)
     }
     return null
   }
@@ -3278,10 +3281,29 @@ function handleCall(node, cur, sf, r, encFn) {
   if (kind === 'REFERENCES_TYPE') return
   const recv = kind === 'CALLS' && ts.isPropertyAccessExpression(callee) ? receiverClasses(callee.expression, t.id) : null
   const br = kind === 'INSTANTIATES' && !inTpl ? branchOf(node, sf) : null
-  addEdge(cur, t.id, kind, r, line, t.conf, { via: t.via.length ? t.via : undefined, template: inTpl || undefined, recv: recv || undefined, ...(br || {}) })
+  const dp = defaultParamOf(node)
+  if (dp) defaultCalls.push({ fid: cur, idx: dp.idx, name: dp.name, dst: t.id, kind, conf: t.conf })
+  addEdge(cur, t.id, kind, r, line, t.conf, { via: t.via.length ? t.via : undefined, template: inTpl || undefined, recv: recv || undefined,
+    default_arg: dp ? dp.name : undefined, ...(br || {}) })
   callSites.push({ target: t.id, node, cur, r, line, encFn })
 }
 
+// a call inside a parameter's default value (`function render(gamut = currentGamut())`): runs only when a call leaves
+// that argument out (#212). Returns the parameter's position and name, or null.
+function defaultParamOf(node) {
+  let x = node
+  while (x && x.parent) {
+    const p = x.parent
+    if (ts.isParameter(p)) {
+      if (p.initializer !== x || !p.parent || !p.parent.parameters) return null
+      return { idx: p.parent.parameters.indexOf(p), name: ts.isIdentifier(p.name) ? p.name.text : p.name.getText().slice(0, 40) }
+    }
+    if (ts.isFunctionLike(p) || ts.isClassLike(p) || ts.isSourceFile(p)) return null
+    x = p
+  }
+  return null
+}
+
 // `b.run()` landing on `Base.run` (B inherits it): the receiver's project classes (attrs.recv), so `impact B.run` can
 // keep only the calls whose receiver can be a B. Only for methods of classes / interfaces something extends or implements
 var baseTypeIds = null      // var: handleCall runs before this line is reached
@@ -3561,6 +3583,28 @@ for (const d of deferredParamSubs) {
   if (deep) stats.realtime_subscriptions_wrapper_too_deep = (stats.realtime_subscriptions_wrapper_too_deep || 0) + 1
 }
 
+// a call that leaves out a defaulted argument (or passes `undefined`) runs the default: an edge from the caller to what
+// the default calls, at the call site, with `omits_default` and `default_of` (#212)
+if (defaultCalls.length) {
+  const byFn = new Map()
+  for (const d of defaultCalls) { if (!byFn.has(d.fid)) byFn.set(d.fid, []); byFn.get(d.fid).push(d) }
+  let n = 0
+  for (const c of callSites) {
+    const ds = byFn.get(c.target)
+    if (!ds || !(ts.isCallExpression(c.node) || ts.isNewExpression(c.node))) continue
+    const args = c.node.arguments || []
+    if (args.some(a => ts.isSpreadElement(a))) continue
+    for (const d of ds) {
+      const a = args[d.idx]
+      if (a && !(ts.isIdentifier(unwrap(a)) && unwrap(a).text === 'undefined')) continue
+      if (d.dst === c.cur) continue
+      addEdge(c.cur, d.dst, d.kind, c.r, c.line, d.conf === 'exact' ? 'resolved' : d.conf, { omits_default: d.name, default_of: c.target })
+      n++
+    }
+  }
+  if (n) stats.default_argument_sites = n
+}
+
 const httpFns = new Set(apiCalls.map(a => a.src))
 for (const c of callSites) {
   if (!httpFns.has(c.target) || !ts.isCallExpression(c.node)) continue

{cg_code_graph-0.23.5 → cg_code_graph-0.23.6/cg_code_graph.egg-info}/PKG-INFO

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

@@ -288,6 +288,8 @@ tests/test_issue_210.py
 tests/test_issue_211.py
 tests/test_issue_211_used_at.py
 tests/test_issue_212.py
+tests/test_issue_212_langs.py
+tests/test_issue_218.py
 tests/test_issue_219.py
 tests/test_java.py
 tests/test_java_exact.py