fix(analyzer): correct tree-sitter resolver name→def pairing

The per-module symbol table in `_index_file` was built by zipping two
independently-grouped `QueryCursor.captures()` lists (`@name` and `@def`).
When `@def` positions shift relative to `@name` (e.g. decorated defs), the
zip mis-pairs names with definitions, so imported-call resolution attaches
CALLS edges to the wrong target — producing phantom edges to functions whose
token never appears at the call site.

Fix: iterate per-match via a `_matches()` helper wrapping
`QueryCursor.matches()`, which guarantees each match's `@name`/`@def`
captures belong together. Applied across all four indexing loops
(top-level funcs, classes, assigns, class methods).

Impact (deterministic graph-vs-jedi-oracle caller bench, n=40, paired,
identical harness — only the resolver differs):
  uxarray CALLS macro-F1 0.178 → 0.713 (median 0.0 → 0.94)
  arkouda CALLS macro-F1 0.031 → 0.262

Adds two regression tests asserting each imported call resolves to the def
whose name matches exactly (10 top-level functions, 8 classes).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: DvirDukhan

api/analyzers/python/ts_resolver.py

@@ -167,6 +167,21 @@ def _captures(query, root: Node) -> dict[str, list[Node]]:
     return cursor.captures(root)
 
 
+def _matches(query, root: Node) -> list[tuple[int, dict[str, list[Node]]]]:
+    """Return per-match capture groups.
+
+    Unlike :func:`_captures` (which groups *all* nodes by capture name into
+    parallel lists that are **not** guaranteed to be index-aligned across
+    different capture names), this yields one dict per match so that, e.g.,
+    a ``@name`` capture is always paired with the ``@def`` capture from the
+    *same* match. Zipping the two independent lists from ``captures()`` mis-
+    aligns names and definitions whenever the per-capture node orderings
+    diverge, scrambling the module symbol table.
+    """
+    cursor = QueryCursor(query)
+    return cursor.matches(root)
+
+
 # ---------------------------------------------------------------------------
 # Public resolver
 # ---------------------------------------------------------------------------
@@ -217,46 +232,50 @@ def _ensure_built(self, files: dict[Path, File], project_root: Path) -> None:
 
     def _index_file(self, mi: _ModuleIndex, root: Node) -> None:
         # Top-level functions
-        caps = _captures(self._queries.top_level_func, root)
-        names = caps.get("name", [])
-        defs = caps.get("def", [])
-        for name_node, def_node in zip(names, defs):
-            name = name_node.text.decode("utf-8")
-            d = _Definition(mi.file_path, _strip_decorator(def_node), "func")
+        for _, caps in _matches(self._queries.top_level_func, root):
+            name_nodes = caps.get("name", [])
+            def_nodes = caps.get("def", [])
+            if not name_nodes or not def_nodes:
+                continue
+            name = name_nodes[0].text.decode("utf-8")
+            d = _Definition(mi.file_path, _strip_decorator(def_nodes[0]), "func")
             mi.top_level[name] = d
             self._by_name[name].append(d)
 
         # Top-level classes
-        caps = _captures(self._queries.top_level_class, root)
-        names = caps.get("name", [])
-        defs = caps.get("def", [])
-        for name_node, def_node in zip(names, defs):
-            name = name_node.text.decode("utf-8")
-            d = _Definition(mi.file_path, _strip_decorator(def_node), "class")
+        for _, caps in _matches(self._queries.top_level_class, root):
+            name_nodes = caps.get("name", [])
+            def_nodes = caps.get("def", [])
+            if not name_nodes or not def_nodes:
+                continue
+            name = name_nodes[0].text.decode("utf-8")
+            d = _Definition(mi.file_path, _strip_decorator(def_nodes[0]), "class")
             mi.top_level[name] = d
             self._by_name[name].append(d)
 
         # Top-level assignments (for class aliases like ``Foo = OtherFoo``)
-        caps = _captures(self._queries.top_level_assign, root)
-        names = caps.get("name", [])
-        defs = caps.get("def", [])
-        for name_node, def_node in zip(names, defs):
-            name = name_node.text.decode("utf-8")
+        for _, caps in _matches(self._queries.top_level_assign, root):
+            name_nodes = caps.get("name", [])
+            def_nodes = caps.get("def", [])
+            if not name_nodes or not def_nodes:
+                continue
+            name = name_nodes[0].text.decode("utf-8")
             if name in mi.top_level:
                 continue
-            d = _Definition(mi.file_path, def_node, "var")
+            d = _Definition(mi.file_path, def_nodes[0], "var")
             mi.top_level[name] = d
             self._by_name[name].append(d)
 
         # Class methods
-        caps = _captures(self._queries.class_methods, root)
-        class_names = caps.get("class_name", [])
-        method_names = caps.get("method_name", [])
-        method_defs = caps.get("method_def", [])
-        for cls_node, mname_node, mdef_node in zip(class_names, method_names, method_defs):
-            class_name = cls_node.text.decode("utf-8")
-            method_name = mname_node.text.decode("utf-8")
-            d = _Definition(mi.file_path, _strip_decorator(mdef_node), "method")
+        for _, caps in _matches(self._queries.class_methods, root):
+            class_nodes = caps.get("class_name", [])
+            mname_nodes = caps.get("method_name", [])
+            mdef_nodes = caps.get("method_def", [])
+            if not class_nodes or not mname_nodes or not mdef_nodes:
+                continue
+            class_name = class_nodes[0].text.decode("utf-8")
+            method_name = mname_nodes[0].text.decode("utf-8")
+            d = _Definition(mi.file_path, _strip_decorator(mdef_nodes[0]), "method")
             mi.class_methods.setdefault(class_name, {})[method_name] = d
             self._by_name[method_name].append(d)
 

tests/analyzers/test_ts_python_resolver.py

@@ -227,6 +227,58 @@ def test_resolver_unknown_name_returns_empty(tmp_path: Path):
     assert r.resolve(files, mod, tmp_path.resolve(), name) == []
 
 
+def test_resolver_many_defs_name_def_alignment(tmp_path: Path):
+    """Regression for the scrambled module symbol table.
+
+    With several top-level definitions in one module, pairing the ``@name``
+    and ``@def`` captures by zipping two independently-grouped lists mis-
+    aligned names with definitions (e.g. an imported ``arange`` call resolved
+    to the ``array`` def node). Each imported call must resolve to the def
+    whose name actually matches the call name.
+    """
+    lib_src = "".join(f"def fn_{i}():\n    return {i}\n\n" for i in range(10))
+    import_line = "from lib import " + ", ".join(f"fn_{i}" for i in range(10))
+    call_lines = "\n".join(f"    fn_{i}()" for i in range(10))
+    app_src = f"{import_line}\n\ndef use():\n{call_lines}\n"
+    files = _make_project(tmp_path, {"lib.py": lib_src, "app.py": app_src})
+    r = TreeSitterPythonResolver(_PY)
+    app_path = (tmp_path / "app.py").resolve()
+    lib_path = (tmp_path / "lib.py").resolve()
+    root = files[app_path].tree.root_node
+    for i in range(10):
+        call = _find_call_node(root, f"fn_{i}(")
+        out = r.resolve(
+            files, app_path, tmp_path.resolve(), call.child_by_field_name("function")
+        )
+        assert len(out) == 1, f"fn_{i} did not resolve uniquely"
+        file, def_node = out[0]
+        assert file.path == lib_path
+        resolved_name = def_node.child_by_field_name("name").text.decode("utf-8")
+        assert resolved_name == f"fn_{i}", (
+            f"call fn_{i} resolved to wrong def {resolved_name}"
+        )
+
+
+def test_resolver_many_classes_name_def_alignment(tmp_path: Path):
+    """Same alignment regression for top-level classes."""
+    lib_src = "".join(f"class Cls{i}:\n    pass\n\n" for i in range(8))
+    import_line = "from lib import " + ", ".join(f"Cls{i}" for i in range(8))
+    body = "\n".join(f"    Cls{i}()" for i in range(8))
+    app_src = f"{import_line}\n\ndef use():\n{body}\n"
+    files = _make_project(tmp_path, {"lib.py": lib_src, "app.py": app_src})
+    r = TreeSitterPythonResolver(_PY)
+    app_path = (tmp_path / "app.py").resolve()
+    root = files[app_path].tree.root_node
+    for i in range(8):
+        call = _find_call_node(root, f"Cls{i}(")
+        out = r.resolve(
+            files, app_path, tmp_path.resolve(), call.child_by_field_name("function")
+        )
+        assert len(out) == 1
+        resolved_name = out[0][1].child_by_field_name("name").text.decode("utf-8")
+        assert resolved_name == f"Cls{i}"
+
+
 # ---------------------------------------------------------------------------
 # PythonAnalyzer integration via env var
 # ---------------------------------------------------------------------------