perf(csharp): cut the member-access pass's overhead; drop the stale changelog hunk (#3528)

Measured on jellyfin/jellyfin (2,208 .cs files, +26.6k access entries on top
of 85.6k member calls, +6,347 `uses` edges), graph output byte-identical
before and after:

- engine.py: the member-access branch asked tree-sitter for `node.parent`
  twice per member_access_expression to tell a callee (`db.Users.Where`)
  from a property read (`db.Users`); `Node.parent` re-descends from the
  root on every call (~700ms over the corpus's 137k such nodes vs ~13ms
  for a set lookup). The walk is pre-order, so the invocation branch now
  records the callee node's id in a per-file `csharp_callee_ids` set and
  the access branch tests membership instead. Per-file extraction goes
  from +1.2-1.6s over base to +0.7-0.8s.

- extract.py: `_resolve_type_name_nid` memoizes per (type_name, caller,
  file) — a method reads and calls the same receiver many times over, and
  every access is one more entry that types it (80k -> 40k scope-chain
  walks on the corpus). The `defines` scan that builds property_index is
  folded into the existing `method` scan: one pass over all_edges fills
  both twin indexes. `_resolve_csharp_member_calls` goes from 430ms to
  288ms (base: 250ms).

- CHANGELOG.md: the entry was written under `## 0.9.61 (unreleased)`; after
  rebasing onto v8 it lands inside the released 0.9.61 section. Release
  notes here are written at the version bump (see 9335cee), so the hunk is
  dropped rather than moved.

Author: Ayushraj06-bit

CHANGELOG.md

@@ -273,7 +273,6 @@ Intra-class call binding across five languages, new language-structure coverage,
 
 ## 0.9.61 (2026-09-12)
 
-- Fix: a C# member access on a typed receiver (`db.Users` in `db.Users.Where(...)`, `this.Count`, `Config.Instance`) now resolves to the receiver type's property node as a `uses` edge, the way `recv.Method()` resolves to its method — so the ORM query sites behind a `DbSet<T>` property, whose table name never appears in source, are reachable from the property (#3528).
 - Fix: `graphify.serve` now imports cleanly on Python 3.12 and 3.13. The `chinese` extra pins `jieba-py` from 3.12 onward (0.9.60 mistakenly kept the old `jieba` until 3.14, and its invalid regex escapes are a hard error on 3.12+), and the jieba import now suppresses the tokenizer's `SyntaxWarning` regardless of message or line so it never escalates under `-W error`.
 - Fix: the git hook's rebuild-root guard now rejects a symlink-loop or dangling `.graphify_root` on Python 3.13, whose `Path.resolve()` no longer raises on a loop — the saved root must resolve to a real directory inside the repo before it is adopted.
 

graphify/extract.py

@@ -4734,35 +4734,31 @@ def _key(label: str) -> str:
     resolver = CsharpNameResolver(all_nodes, all_edges)
 
     # (type_node_id, method_key) -> method_node_id, and caller -> enclosing type.
-    # C# owns its methods via `method` edges.
+    # C# owns its methods via `method` edges. property_index is the member-
+    # access twin (#3528): (type_node_id, property_key) -> property_node_id. A
+    # C# property is the target of a `defines` edge from its type (#3006); C++
+    # data members ride the same relation, so keep to targets declared in a
+    # .cs file — a receiver typed by bare-name fallback must not reach a
+    # same-named C++ member. One pass over the edges fills both.
     method_index: dict[tuple[str, str], str] = {}
+    property_index: dict[tuple[str, str], str] = {}
     enclosing_type: dict[str, str] = {}
     for e in all_edges:
-        if e.get("relation") != "method":
+        rel = e.get("relation")
+        if rel != "method" and rel != "defines":
             continue
         src, tgt = e.get("source"), e.get("target")
         tnode = node_by_id.get(tgt)
         if tnode is None:
             continue
-        enclosing_type.setdefault(tgt, src)
-        method_index[(src, _key(tnode.get("label", "")))] = tgt
-
-    # (type_node_id, property_key) -> property_node_id, the member-access twin
-    # of method_index (#3528). A C# property is the target of a `defines` edge
-    # from its type (#3006); C++ data members ride the same relation, so keep
-    # to targets declared in a .cs file — a receiver typed by bare-name
-    # fallback must not reach a same-named C++ member.
-    property_index: dict[tuple[str, str], str] = {}
-    for e in all_edges:
-        if e.get("relation") != "defines":
-            continue
-        src, tgt = e.get("source"), e.get("target")
-        if not (isinstance(src, str) and isinstance(tgt, str)):
-            continue
-        tnode = node_by_id.get(tgt)
-        if tnode is None or not str(tnode.get("source_file", "")).endswith(".cs"):
-            continue
-        property_index[(src, _key(tnode.get("label", "")))] = tgt
+        if rel == "method":
+            enclosing_type.setdefault(tgt, src)
+            method_index[(src, _key(tnode.get("label", "")))] = tgt
+        elif (
+            isinstance(src, str) and isinstance(tgt, str)
+            and str(tnode.get("source_file", "")).endswith(".cs")
+        ):
+            property_index[(src, _key(tnode.get("label", "")))] = tgt
 
     # Base-class chain from `inherits` edges (C# files only). The type-reference
     # pass has already re-pointed each resolvable base to its real definition and
@@ -4816,6 +4812,13 @@ def _member_on_type_or_bases(
             frontier.extend(bases_of.get(nid, []))
         return next(iter(hits)) if len(hits) == 1 else None
 
+    # (type_name, caller_nid, src_file) -> resolved type nid, or None. A
+    # method reads and calls the same receiver (`db`, `_context`) many times
+    # over, and every member access (#3528) is one more entry that types it,
+    # so resolve each name once per caller rather than re-walking the
+    # namespace/using scope chain for every site.
+    type_nid_memo: dict[tuple[str, str | None, str], str | None] = {}
+
     def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
                                src_file: str) -> str | None:
         """Resolve a declared type name to exactly one definition node id.
@@ -4828,16 +4831,24 @@ def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
         """
         if not type_name:
             return None
+        memo_key = (
+            type_name,
+            caller_node.get("id") if caller_node is not None else None,
+            src_file,
+        )
+        if memo_key in type_nid_memo:
+            return type_nid_memo[memo_key]
+        type_nid: str | None = None
+        decisive = False
         if caller_node is not None:
-            resolved, decisive = resolver.resolve_type_name(
+            type_nid, decisive = resolver.resolve_type_name(
                 type_name, caller_node, src_file
             )
-            if resolved:
-                return resolved
-            if decisive:
-                return None
-        type_defs = type_def_nids.get(_key(type_name), [])
-        return type_defs[0] if len(type_defs) == 1 else None
+        if not type_nid and not decisive:
+            type_defs = type_def_nids.get(_key(type_name), [])
+            type_nid = type_defs[0] if len(type_defs) == 1 else None
+        type_nid_memo[memo_key] = type_nid
+        return type_nid
 
     def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -> None:
         """Park a call whose receiver type is declared nowhere in this corpus (#3152).

graphify/extractors/engine.py

@@ -6928,6 +6928,12 @@ def scala_base_name(type_node) -> str | None:
     seen_static_ref_pairs: set[tuple[str, str, str]] = set()
     seen_helper_ref_pairs: set[tuple[str, str, str]] = set()
     seen_bind_pairs: set[tuple[str, str, str]] = set()
+    # C#: node ids of the member_access_expression that is an invocation's
+    # callee (`db.Users.Where` in `db.Users.Where(...)`), recorded when the
+    # invocation is visited so the member-access branch below can tell it
+    # apart from a property read (#3528) without asking tree-sitter for
+    # `node.parent`, which re-descends from the root on every call.
+    csharp_callee_ids: set[int] = set()
     raw_calls: list[dict] = []  # unresolved calls for cross-file resolution in extract()
     # Ruby: per-method `var -> ClassName` table from `var = Const.new` bindings,
     # populated before walk_calls runs. Lets member-call raw_calls carry a
@@ -7394,6 +7400,8 @@ def walk_calls(
                 fn_node = node.child_by_field_name("function")
                 member_parts = _csharp_member_call_parts(fn_node)
                 if member_parts is not None:
+                    if fn_node.type == "member_access_expression":
+                        csharp_callee_ids.add(fn_node.id)
                     mname, recv = member_parts
                     if mname is not None:
                         # `recv.Get<int>(...)`: the name field is a
@@ -8046,14 +8054,16 @@ def walk_calls(
         # member calls use, for _resolve_csharp_member_calls to bind to the
         # receiver type's property node. The callee of an invocation is its
         # `function` field, and that is the only member_access_expression
-        # ever parented directly by one (arguments sit under argument_list),
-        # so the parent check is what separates `db.Users` from
+        # ever parented directly by one (arguments sit under argument_list);
+        # the walk is pre-order, so the invocation branch above has already
+        # put that node's id in csharp_callee_ids by the time the walk reaches
+        # it, and the id check is what separates `db.Users` from
         # `db.Users.Add`. A generic_name member (`db.Set<T>`) is a call, not a
         # property, and is left to the call-site type-argument pass (#2911).
         if (
             config.ts_module == "tree_sitter_c_sharp"
             and node.type == "member_access_expression"
-            and not (node.parent is not None and node.parent.type == "invocation_expression")
+            and node.id not in csharp_callee_ids
         ):
             member_name = node.child_by_field_name("name")
             access_receiver = (

tests/test_csharp_member_access.py

@@ -398,3 +398,24 @@ def test_untypable_lowercase_receiver_records_no_raw_entry(tmp_path):
     )
     entries = [rc for rc in extract_csharp(p)["raw_calls"] if rc.get("is_member_access")]
     assert entries == []
+
+
+def test_invocation_callee_is_a_call_entry_not_an_access_entry(tmp_path):
+    # `db.Save()` reaches the walk twice: once as the invocation, once as the
+    # member_access_expression that is its callee. The callee must surface
+    # only as the call — never as a second, dead access entry for `Save`.
+    # The walk is pre-order, so the invocation records the callee's node id
+    # before the access branch reaches it; nested and chained shapes must
+    # keep that straight too.
+    p = tmp_path / "S.cs"
+    p.write_text(
+        "public class Svc {\n"
+        "    private Ctx db;\n"
+        "    public void Q() { db.Save(); db.Log(db.Users); db.Users.Add(db.Orders.First()); }\n"
+        "}\n"
+    )
+    raw = [rc for rc in extract_csharp(p)["raw_calls"] if rc.get("lang") == "csharp"]
+    accesses = sorted(rc["callee"] for rc in raw if rc.get("is_member_access"))
+    calls = sorted(rc["callee"] for rc in raw if not rc.get("is_member_access"))
+    assert accesses == ["Orders", "Users", "Users"]
+    assert calls == ["Add", "First", "Log", "Save"]