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

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

@@ -4707,6 +4707,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:
@@ -4740,6 +4747,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
@@ -4764,13 +4788,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()
@@ -4780,9 +4807,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
@@ -4837,6 +4864,11 @@ def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -
         caller = rc.get("caller_nid")
         if not receiver 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 receiver == "this":
@@ -4863,7 +4895,8 @@ def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -
             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:
@@ -4872,20 +4905,23 @@ def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -
                 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,

graphify/extractors/engine.py

@@ -3685,6 +3685,50 @@ def _csharp_member_call_parts(fn_node):
     return None
 
 
+def _csharp_member_receiver(recv, source: bytes) -> str | None:
+    """The receiver name of a C# member access, or None when it is not simple.
+
+    ``recv`` is the `expression` field of a member_access_expression. A bare
+    identifier reads as-is; `this` and `base` read as those literals, resolved
+    against the caller's own type (or its single resolvable base) in the
+    cross-file pass; `this.field` reads as the bare field name, so it is typed
+    exactly like `field` via the method's scoped receiver table. A cast
+    receiver, `((IStore)x)` or `(x as IStore)`, names its type in source and
+    reads as that type, so it resolves as `IStore.M` (#3797). Any other chain
+    (`a.b`, a call result, `typeof(T)`) stays untyped — the resolver bails
+    rather than guessing.
+    """
+    if recv is None:
+        return None
+    if recv.type == "identifier":
+        return _read_text(recv, source)
+    if recv.type in ("this", "this_expression"):
+        return "this"
+    if recv.type in ("base", "base_expression"):
+        return "base"
+    if recv.type == "member_access_expression":
+        inner = recv.child_by_field_name("expression")
+        fname = recv.child_by_field_name("name")
+        if (
+            inner is not None
+            and inner.type in ("this", "this_expression")
+            and fname is not None
+            and fname.type == "identifier"
+        ):
+            return _read_text(fname, source)
+    if recv.type == "parenthesized_expression":
+        inner = recv.named_children[0] if recv.named_children else None
+        cast_type = None
+        if inner is not None and inner.type == "cast_expression":
+            cast_type = inner.child_by_field_name("type")
+        elif inner is not None and inner.type == "as_expression":
+            cast_type = inner.child_by_field_name("right")
+        type_info = _read_csharp_type_name(cast_type, source)
+        if type_info and type_info[0]:
+            return type_info[0]
+    return None
+
+
 def _read_csharp_type_name(node, source: bytes) -> tuple[str, bool, str] | None:
     """Resolve a C# type name, whether it was qualified, and its qualifier prefix."""
     if node is None:
@@ -7358,41 +7402,7 @@ def walk_calls(
                         # (#3406) — read the bare identifier instead.
                         callee_name = _csharp_bare_call_name(mname, source)
                         is_member_call = True
-                        if recv is not None and recv.type == "identifier":
-                            member_receiver = _read_text(recv, source)
-                        elif recv is not None and recv.type in ("this", "this_expression"):
-                            member_receiver = "this"
-                        elif recv is not None and recv.type in ("base", "base_expression"):
-                            # base.M(): resolved against the caller's single
-                            # resolvable base class in the cross-file pass.
-                            member_receiver = "base"
-                        elif recv is not None and recv.type == "member_access_expression":
-                            # this.field.M(): the explicit-`this` field access is
-                            # typed exactly like a bare `field.M()` via the file
-                            # table; any other chained receiver stays untyped
-                            # (the resolver bails rather than guessing).
-                            inner = recv.child_by_field_name("expression")
-                            fname = recv.child_by_field_name("name")
-                            if (
-                                inner is not None
-                                and inner.type in ("this", "this_expression")
-                                and fname is not None
-                                and fname.type == "identifier"
-                            ):
-                                member_receiver = _read_text(fname, source)
-                        elif recv is not None and recv.type == "parenthesized_expression":
-                            # ((IStore)x).M() / (x as IStore).M(): the cast names
-                            # the receiver's type in source, so resolve it as
-                            # IStore.M() (#3797).
-                            inner = recv.named_children[0] if recv.named_children else None
-                            cast_type = None
-                            if inner is not None and inner.type == "cast_expression":
-                                cast_type = inner.child_by_field_name("type")
-                            elif inner is not None and inner.type == "as_expression":
-                                cast_type = inner.child_by_field_name("right")
-                            type_info = _read_csharp_type_name(cast_type, source)
-                            if type_info and type_info[0]:
-                                member_receiver = type_info[0]
+                        member_receiver = _csharp_member_receiver(recv, source)
                 elif fn_node is not None and fn_node.type == "identifier":
                     callee_name = _read_text(fn_node, source)
                 elif fn_node is not None and fn_node.type == "generic_name":
@@ -8026,6 +8036,62 @@ def walk_calls(
                                 "weight": 1.0,
                             })
 
+        # C#: a member access that is not itself a call — `db.Users` inside
+        # `db.Users.Where(...)`, `order.Status`, `Config.Instance` (#3528).
+        # The invocation branch keeps only a simple receiver, so the chained
+        # `db.Users` was dropped on the floor and the DbSet property (a node
+        # since #3006) sat in the graph with nothing but its `defines` edge:
+        # "what code reads or writes this table" had no answer. Record the
+        # access as a raw entry typed from the same scoped receiver table the
+        # 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
+        # `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")
+        ):
+            member_name = node.child_by_field_name("name")
+            access_receiver = (
+                _csharp_member_receiver(node.child_by_field_name("expression"), source)
+                if member_name is not None and member_name.type == "identifier"
+                else None
+            )
+            if access_receiver:
+                receiver_type = _csharp_scoped_receiver_type(
+                    receiver_types, access_receiver, node.start_byte
+                )
+                # Property reads are far more common than calls, and raw_calls
+                # ride the AST cache, so only record an entry the resolver can
+                # act on: `this`/`base`, a type name, or a typed receiver. An
+                # untyped lowercase receiver (`u.Email` on a lambda parameter)
+                # would be skipped there anyway.
+                if (
+                    receiver_type
+                    or access_receiver in ("this", "base")
+                    or access_receiver[:1].isupper()
+                ):
+                    rc_entry = {
+                        "caller_nid": caller_nid,
+                        "callee": _read_text(member_name, source),
+                        # is_member_call keeps every bare-name resolver off this
+                        # entry, the way it does for a receiver call;
+                        # is_member_access is what the C# resolver branches on.
+                        "is_member_call": True,
+                        "is_member_access": True,
+                        "lang": "csharp",
+                        "source_file": str_path,
+                        "source_location": f"L{node.start_point[0] + 1}",
+                        "receiver": access_receiver,
+                    }
+                    if receiver_type:
+                        rc_entry["receiver_type"] = receiver_type
+                    raw_calls.append(rc_entry)
+
         # Static property access: Foo::$bar → uses_static_prop edge
         if node.type in config.static_prop_types:
             scope_node = node.child_by_field_name("scope")