fix(csharp): resolve a member access to the receiver type's property (#3528)

`db.Users` inside `db.Users.Where(...)` was dropped: the invocation branch
keeps only a simple receiver, so every ORM query site behind a DbSet<T>
property reached _resolve_csharp_member_calls with receiver=None and the
property node (#3006) had no inbound edge but its own type's `defines`.

Record a non-call member_access_expression on a simple receiver (recv /
this / base / this.field / Type) as a raw_calls entry stamped
is_member_access, typed from the same scoped receiver table the member
calls use, and bind it in _resolve_csharp_member_calls through the same
this/base/Type/typed tiers to a property_index built from `defines`
edges to .cs nodes — a `uses` edge at the access line, EXTRACTED when the
type is named in source and INFERRED when the receiver is typed. Never
parked: parked entries are cross-repo call candidates (#3152).

The receiver-capture arms of the invocation branch, including the cast
arm from #3797 (`((IStore)x)` / `(x as IStore)`), become
_csharp_member_receiver, shared by both sites, so a property read through
a cast resolves on the cast type the same way a call does.

Author: Ayushraj06-bit

CHANGELOG.md

@@ -326,6 +326,7 @@ 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

@@ -4832,6 +4832,13 @@ def _resolve_csharp_member_calls(
     ``inherits`` chain; a chain containing an unresolvable (out-of-corpus) base
     poisons the lookup — the method may live there, so no edge is emitted.
 
+    A member ACCESS (``db.Users``, ``this.Count``, ``Config.Instance`` — a raw
+    call stamped ``is_member_access``, #3528) is typed by the same tiers and
+    bound to the receiver type's property node (#3006) instead of a method,
+    as a ``uses`` edge. That is what makes the ORM query sites behind a
+    ``DbSet<T>`` property reachable: the table name never appears in source,
+    only the property does.
+
     Must run after id-disambiguation so node ids and caller_nids are final.
     """
     def _key(label: str) -> str:
@@ -4865,6 +4872,23 @@ def _key(label: str) -> str:
         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
+
     # 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
     # left unresolvable ones on dangling sourceless stubs — a stub target marks
@@ -4889,13 +4913,16 @@ def _key(label: str) -> str:
             if tgt not in bucket:
                 bucket.append(tgt)
 
-    def _method_on_type_or_bases(type_nid: str, callee_key: str) -> str | None:
-        """The method's definition on the type or its resolvable base chain.
+    def _member_on_type_or_bases(
+        index: dict[tuple[str, str], str], type_nid: str, callee_key: str
+    ) -> str | None:
+        """The member's definition on the type or its resolvable base chain.
 
-        A type that declares the method directly wins (overrides shadow the
-        base). Otherwise walk `inherits` upward; an unresolved base anywhere the
-        walk actually reaches poisons the lookup (no edge), as does anything
-        other than exactly one declaration found.
+        ``index`` is method_index for a call and property_index for a member
+        access. A type that declares the member directly wins (overrides
+        shadow the base). Otherwise walk `inherits` upward; an unresolved base
+        anywhere the walk actually reaches poisons the lookup (no edge), as
+        does anything other than exactly one declaration found.
         """
         hits: set[str] = set()
         seen: set[str] = set()
@@ -4905,9 +4932,9 @@ def _method_on_type_or_bases(type_nid: str, callee_key: str) -> str | None:
             if nid in seen:
                 continue
             seen.add(nid)
-            method_nid = method_index.get((nid, callee_key))
-            if method_nid:
-                hits.add(method_nid)
+            member_nid = index.get((nid, callee_key))
+            if member_nid:
+                hits.add(member_nid)
                 continue  # an override shadows anything above it
             if nid in unresolved_base:
                 return None  # the method may live on the out-of-corpus base
@@ -5000,6 +5027,11 @@ def _field_type_nid(type_nid: str, field: str) -> str | None:
         chain = rc.get("receiver_chain") or []
         if not (receiver or chain) or not callee or not caller:
             continue
+        # A member access (`db.Users`, #3528) types its receiver exactly like a
+        # call and then binds to a property instead of a method. It is never
+        # parked: the parked entries are cross-repo CALL candidates (#3152),
+        # and a property read on an out-of-corpus type is not one.
+        is_access = bool(rc.get("is_member_access"))
         src_file = rc.get("source_file", "")
         caller_node = node_by_id.get(caller)
         if not receiver:
@@ -5036,7 +5068,8 @@ def _field_type_nid(type_nid: str, field: str) -> str | None:
             if not type_nid:
                 type_nid = _resolve_type_name_nid(receiver, caller_node, src_file)
                 if not type_nid:
-                    _park_if_absent(type_name or receiver, caller_node, rc)
+                    if not is_access:
+                        _park_if_absent(type_name or receiver, caller_node, rc)
                     continue
             type_qualified = True
         else:
@@ -5045,20 +5078,23 @@ def _field_type_nid(type_nid: str, field: str) -> str | None:
                 continue
             type_nid = _resolve_type_name_nid(type_name, caller_node, src_file)
             if not type_nid:  # ambiguous or absent -> bail (god-node guard)
-                _park_if_absent(type_name, caller_node, rc)
+                if not is_access:
+                    _park_if_absent(type_name, caller_node, rc)
                 continue
             type_qualified = False
-        method_nid = _method_on_type_or_bases(type_nid, _key(callee))
-        if not method_nid:
-            continue  # receiver typed, but the type has no such method — skip
-        if method_nid == caller or (caller, method_nid) in existing_pairs:
+        member_nid = _member_on_type_or_bases(
+            property_index if is_access else method_index, type_nid, _key(callee)
+        )
+        if not member_nid:
+            continue  # receiver typed, but the type has no such member — skip
+        if member_nid == caller or (caller, member_nid) in existing_pairs:
             continue
-        existing_pairs.add((caller, method_nid))
+        existing_pairs.add((caller, member_nid))
         all_edges.append({
             "source": caller,
-            "target": method_nid,
-            "relation": "calls",
-            "context": "call",
+            "target": member_nid,
+            "relation": "uses" if is_access else "calls",
+            "context": "member_access" if is_access else "call",
             "confidence": "EXTRACTED" if type_qualified else "INFERRED",
             "confidence_score": 1.0 if type_qualified else 0.85,
             "source_file": src_file,