fix(csharp): reference the type arguments of a qualified generic type (#3510)

Review finding on #3523: `global::IFoo<Bar>` used to reach `Bar` only by
accident — the unhandled alias_qualified_name fell into child recursion,
which emitted the phantom `global` and `Bar` alongside `IFoo` — so routing
it through the qualified branch dropped `Bar`. That branch had never
collected type arguments at all: a bare `IFoo<Bar>` references Bar, a
qualified `Acme.IFoo<Bar>` did not. Collect every type_argument_list at any
depth of a qualified or alias-qualified name, the way the generic_name
branch reads a bare one, so both spellings yield the same generic_arg
references.

Author: Ayushraj06-bit

graphify/extractors/engine.py

@@ -240,9 +240,23 @@ def _csharp_collect_type_refs(
             out.append((name, "generic_arg" if generic else "type", False, ""))
         return
     if t in ("qualified_name", "alias_qualified_name"):
+        # A qualified_name keeps its top-level dot, so `prefix` is never empty
+        # there; only the undotted alias form (`global::IFoo`) is unqualified.
         prefix, _, text = _csharp_dotted_name(_read_text(node, source)).rpartition(".")
         if text and text not in skip:
             out.append((text, "generic_arg" if generic else "type", bool(prefix), prefix))
+        # Its type arguments are references too, at any depth of the name
+        # (`Acme.Box<Widget>` -> Box, and Widget as a generic_arg), the way the
+        # bare generic_name branch below already reads `Box<Widget>`.
+        pending = list(node.children)
+        while pending:
+            sub = pending.pop()
+            if sub.type == "type_argument_list":
+                for arg in sub.children:
+                    if arg.is_named:
+                        _csharp_collect_type_refs(arg, source, True, out, skip)
+            else:
+                pending.extend(sub.children)
         return
     if t == "generic_name":
         name_child = node.child_by_field_name("name")

tests/test_csharp_extension_blocks.py

@@ -314,6 +314,53 @@ def test_dotted_generic_argument_does_not_split_a_field_or_base_type(tmp_path):
     assert not [lbl for lbl in _labels(r) if "<" in lbl or ">" in lbl or "&" in lbl]
 
 
+def _generic_arg_refs(r, source_id):
+    return {e["target"] for e in r["edges"]
+            if e["relation"] == "references" and e["source"] == source_id
+            and e.get("context") == "generic_arg"}
+
+
+@pytest.mark.parametrize("type_expr", [
+    "Acme.IFoo<Bar>",                                        # qualified
+    "global::Acme.IFoo<Bar>",                                # alias-qualified, dotted
+    "global::IFoo2<Bar>",                                    # alias-qualified, undotted
+    "Acme.IFoo<System.Collections.Generic.List<Bar>>",       # nested, dotted argument
+])
+def test_qualified_generic_arguments_are_referenced(tmp_path, type_expr):
+    """A qualified or alias-qualified generic type references its type
+    arguments the way a bare `IFoo<Bar>` always has; `global::IFoo<Bar>` used
+    to reach `Bar` only by accident, next to a phantom `global` node."""
+    _, r = _calls(tmp_path, {"S.cs": (
+        "namespace Acme { public interface IFoo<T> { } }\n"
+        "public interface IFoo2<T> { }\n"
+        "public class Bar { }\n"
+        f"public class Holder {{ private {type_expr} f; }}\n"
+    )})
+    holder = _find(r, "Holder", "holder")
+    assert _find(r, "Bar", "bar") in _generic_arg_refs(r, holder), type_expr
+    assert "global" not in _labels(r)
+
+
+def test_extension_receiver_generic_arguments_are_referenced(tmp_path):
+    """The receiver of a constructor-shaped block goes through the same node
+    path, so `Acme.IFoo<Bar>` references Bar as well as IFoo."""
+    calls, r = _calls(tmp_path, {"S.cs": (
+        "namespace Acme { public interface IFoo<T> { string? Next(); } }\n"
+        "public class Bar { }\n"
+        "public static class E\n"
+        "{\n"
+        "    extension(Acme.IFoo<Bar> spec)\n"
+        "    {\n"
+        "        public string? Url() => spec.Next();\n"
+        "    }\n"
+        "}\n"
+    )})
+    e = _find(r, "E", "_e")
+    assert (e, _find(r, "IFoo", "ifoo")) in _refs(r)
+    assert _find(r, "Bar", "bar") in _generic_arg_refs(r, e)
+    assert (_find(r, ".Url()", "_e_url"), _find(r, ".Next()", "ifoo")) in calls
+
+
 def test_nested_type_of_a_generic_outer_keeps_its_own_name(tmp_path):
     """`Outer<int>.Inner`: the type-argument list belongs to the qualifier and
     must not eat the split — `Inner`, qualified by `Outer`."""