parser: emit REFERENCES edges for Python callback arguments (#363)

The dispatcher in `_extract_value_references` only matched the
`arguments` AST node type, which is the JS/TS shape. Python's
tree-sitter grammar uses `argument_list` for the same construct, so
function references in callback positions — `executor.submit(handler)`,
`filter(predicate, xs)`, `map(transform, xs)`, `df.apply(fn)`, etc. —
silently produced no REFERENCES edges.

Downstream effect: `find_dead_code` already checks `has_references`
(refactor.py), but for Python the edge was never created, so callback
functions were systematically flagged as dead — exactly the high false
positive rate users report in #363 (executor pools, pandas .apply,
higher-order functions, returned closures).

Fix is one line of intent: introduce `_ARGUMENTS_TYPES = {"arguments",
"argument_list"}` and dispatch on set membership instead of string
equality. The existing `_ref_from_arguments` walker already handles
identifier children correctly and `_emit_reference_if_known` still
gates emission on the name being locally defined or imported, so this
does not introduce noise from arbitrary identifiers.

Scoped to the dispatcher only: JS/TS shorthand-property, pair-value,
and array-element handling are unchanged.

Author: Pr1ncePS2002

code_review_graph/parser.py

@@ -3113,6 +3113,11 @@ def _resolve_jsx_component_target(
     # AST node types for array/list containers.
     _ARRAY_TYPES = frozenset({"array", "list"})
 
+    # AST node types for call argument containers. JS/TS uses ``arguments``;
+    # Python uses ``argument_list``. Both share the same identifier-child shape
+    # for bare-identifier callbacks like ``executor.submit(my_handler)``.
+    _ARGUMENTS_TYPES = frozenset({"arguments", "argument_list"})
+
     # Names that are almost certainly not function references (constants,
     # common primitives).  All-uppercase identifiers and very short names
     # are excluded by a length/casing heuristic in the method itself.
@@ -3185,7 +3190,7 @@ def _extract_value_references(
             return
 
         # --- Callback arguments (identifier args inside call_expression) ---
-        if node_type == "arguments":
+        if node_type in self._ARGUMENTS_TYPES:
             self._ref_from_arguments(
                 child, source, language, file_path, caller, edges, imap, dnames,
             )

tests/fixtures/sample_callback_refs.py

@@ -0,0 +1,35 @@
+"""Fixture for issue #363: function references in callback positions.
+
+Each `*_callback` function is passed as a bare-identifier argument to
+another call. They are never invoked with parens, so without REFERENCES
+edge tracking they would be flagged as dead code.
+"""
+from concurrent.futures import ThreadPoolExecutor
+
+
+def executor_callback():
+    return "submitted"
+
+
+def filter_callback(item):
+    return item > 0
+
+
+def map_callback(item):
+    return item * 2
+
+
+def trigger_executor():
+    with ThreadPoolExecutor() as executor:
+        future = executor.submit(executor_callback)
+        return future
+
+
+def trigger_filter():
+    items = [1, -2, 3, -4]
+    return list(filter(filter_callback, items))
+
+
+def trigger_map():
+    items = [1, 2, 3]
+    return list(map(map_callback, items))

tests/test_parser.py

@@ -648,6 +648,54 @@ def test_vitest_tested_by_edges(self):
             f"All edges: {[(e.kind, e.source, e.target) for e in edges]}"
         )
 
+    # --- Python callback REFERENCES (#363) ---
+    # Functions passed as bare-identifier arguments (executor.submit(fn),
+    # filter(fn, xs), map(fn, xs), df.apply(fn), ...) should produce
+    # REFERENCES edges so dead-code detection does not flag them as unused.
+    # Pre-fix: only the JS/TS `arguments` node type triggered the
+    # _ref_from_arguments dispatcher; Python's `argument_list` was ignored.
+
+    def test_python_callback_references_emitted(self):
+        """A function passed as a bare identifier to another call should
+        produce a REFERENCES edge from the calling function to it."""
+        nodes, edges = self.parser.parse_file(FIXTURES / "sample_callback_refs.py")
+        refs = [e for e in edges if e.kind == "REFERENCES"]
+        ref_target_names = {e.target.rsplit("::", 1)[-1] for e in refs}
+        for callback in ("executor_callback", "filter_callback", "map_callback"):
+            assert callback in ref_target_names, (
+                f"Expected REFERENCES edge to {callback}, got targets: "
+                f"{ref_target_names}"
+            )
+
+    def test_python_callback_references_not_treated_as_dead(self):
+        """End-to-end: with REFERENCES edges in place, find_dead_code
+        should not flag callback functions as dead."""
+        from code_review_graph.graph import GraphStore
+        from code_review_graph.refactor import find_dead_code
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            db_path = Path(tmp_dir) / "graph.db"
+            store = GraphStore(db_path)
+            try:
+                nodes, edges = self.parser.parse_file(
+                    FIXTURES / "sample_callback_refs.py"
+                )
+                store.store_file_nodes_edges(
+                    str(FIXTURES / "sample_callback_refs.py"),
+                    nodes, edges, "",
+                )
+                dead = find_dead_code(store)
+                dead_names = {d["name"] for d in dead}
+                for callback in (
+                    "executor_callback", "filter_callback", "map_callback",
+                ):
+                    assert callback not in dead_names, (
+                        f"{callback} was flagged as dead but is used as a "
+                        f"callback. Dead names: {dead_names}"
+                    )
+            finally:
+                store.close()
+
     def test_non_test_file_describe_not_special(self):
         """describe() in a non-test file should NOT create Test nodes."""
         import tempfile