Improve asyncio tools to handle enhanced coroutine stack information

This commit updates the asyncio debugging tools to work with the enhanced
structured data from the remote debugging module. The tools now process
and display both internal coroutine stacks and external awaiter chains,
providing much more comprehensive debugging information.

The key improvements include:

1. Enhanced table display: Now shows both "coroutine stack" and "awaiter
   chain" columns, clearly separating what a task is doing internally vs
   what it's waiting for externally.

2. Improved tree rendering: Displays complete coroutine call stacks for
   leaf tasks, making it easier to understand the actual execution state
   of suspended coroutines.

3. Better cycle detection: Optimized DFS algorithm for detecting await
   cycles in the task dependency graph.

4. Structured data handling: Updated to work with the new FrameInfo,
   CoroInfo, TaskInfo, and AwaitedInfo structured types instead of raw
   tuples.

The enhanced output transforms debugging from showing only file paths to
revealing function names and complete call stacks, making it much easier
to understand complex async execution patterns and diagnose issues in
production asyncio applications.

Author: pablogsal

Lib/asyncio/tools.py

@@ -1,11 +1,10 @@
 """Tools to analyze tasks running in asyncio programs."""
 
-from collections import defaultdict
+from collections import defaultdict, namedtuple
 from itertools import count
 from enum import Enum
 import sys
-from _remote_debugging import RemoteUnwinder
-
+from _remote_debugging import RemoteUnwinder, FrameInfo
 
 class NodeType(Enum):
     COROUTINE = 1
@@ -26,26 +25,41 @@ def __init__(
 
 
 # ─── indexing helpers ───────────────────────────────────────────
-def _format_stack_entry(elem: tuple[str, str, int] | str) -> str:
-    if isinstance(elem, tuple):
-        fqname, path, line_no = elem
-        return f"{fqname} {path}:{line_no}"
-
+def _format_stack_entry(elem: str|FrameInfo) -> str:
+    if not isinstance(elem, str):
+        if elem.lineno == 0 and elem.filename == "":
+            return f"{elem.funcname}"
+        else:
+            return f"{elem.funcname} {elem.filename}:{elem.lineno}"
     return elem
 
 
 def _index(result):
-    id2name, awaits = {}, []
-    for _thr_id, tasks in result:
-        for tid, tname, awaited in tasks:
-            id2name[tid] = tname
-            for stack, parent_id in awaited:
-                stack = [_format_stack_entry(elem) for elem in stack]
-                awaits.append((parent_id, stack, tid))
-    return id2name, awaits
-
-
-def _build_tree(id2name, awaits):
+    id2name, awaits, task_stacks = {}, [], {}
+    for awaited_info in result:
+        for task_info in awaited_info.awaited_by:
+            task_id = task_info.task_id
+            task_name = task_info.task_name
+            id2name[task_id] = task_name
+            
+            # Store the internal coroutine stack for this task
+            if task_info.coroutine_stack:
+                for coro_info in task_info.coroutine_stack:
+                    call_stack = coro_info.call_stack
+                    internal_stack = [_format_stack_entry(frame) for frame in call_stack]
+                    task_stacks[task_id] = internal_stack
+                    
+            # Add the awaited_by relationships (external dependencies)
+            if task_info.awaited_by:
+                for coro_info in task_info.awaited_by:
+                    call_stack = coro_info.call_stack
+                    parent_task_id = coro_info.task_name
+                    stack = [_format_stack_entry(frame) for frame in call_stack]
+                    awaits.append((parent_task_id, stack, task_id))
+    return id2name, awaits, task_stacks
+
+
+def _build_tree(id2name, awaits, task_stacks):
     id2label = {(NodeType.TASK, tid): name for tid, name in id2name.items()}
     children = defaultdict(list)
     cor_names = defaultdict(dict)  # (parent) -> {frame: node}
@@ -71,6 +85,16 @@ def _cor_node(parent_key, frame_name):
         if child_key not in children[cur]:
             children[cur].append(child_key)
 
+    # Add internal coroutine stacks for leaf tasks (tasks that don't await other tasks)
+    leaf_tasks = set(id2name.keys()) - set(parent_id for parent_id, _, _ in awaits)
+    for task_id in leaf_tasks:
+        if task_id in task_stacks:
+            task_key = (NodeType.TASK, task_id)
+            cur = task_key
+            # Add the internal stack frames in reverse order (outermost to innermost)
+            for frame in reversed(task_stacks[task_id]):
+                cur = _cor_node(cur, frame)
+
     return id2label, children
 
 
@@ -99,14 +123,17 @@ def _find_cycles(graph):
     path, cycles = [], []
 
     def dfs(v):
+        if color[v] == GREY:            # back-edge → cycle!
+            i = path.index(v)
+            cycles.append(path[i:] + [v])  # make a copy
+            return
+        if color[v] == BLACK:
+            return
+            
         color[v] = GREY
         path.append(v)
         for w in graph.get(v, ()):
-            if color[w] == WHITE:
-                dfs(w)
-            elif color[w] == GREY:            # back-edge → cycle!
-                i = path.index(w)
-                cycles.append(path[i:] + [w])  # make a copy
+            dfs(w)
         color[v] = BLACK
         path.pop()
 
@@ -129,12 +156,12 @@ def build_async_tree(result, task_emoji="(T)", cor_emoji=""):
     The call tree is produced by `get_all_async_stacks()`, prefixing tasks
     with `task_emoji` and coroutine frames with `cor_emoji`.
     """
-    id2name, awaits = _index(result)
+    id2name, awaits, task_stacks = _index(result)
     g = _task_graph(awaits)
     cycles = _find_cycles(g)
     if cycles:
         raise CycleFoundException(cycles, id2name)
-    labels, children = _build_tree(id2name, awaits)
+    labels, children = _build_tree(id2name, awaits, task_stacks)
 
     def pretty(node):
         flag = task_emoji if node[0] == NodeType.TASK else cor_emoji
@@ -154,35 +181,65 @@ def render(node, prefix="", last=True, buf=None):
 
 
 def build_task_table(result):
-    id2name, awaits = _index(result)
+    id2name, _, _= _index(result)
     table = []
-    for tid, tasks in result:
-        for task_id, task_name, awaited in tasks:
-            if not awaited:
+    for awaited_info in result:
+        thread_id = awaited_info.thread_id
+        for task_info in awaited_info.awaited_by:
+            task_id = task_info.task_id
+            task_name = task_info.task_name
+            
+            # Interpret the data structure correctly:
+            # If 3 elements: (task_id, name, awaited_by)
+            # If 4 elements: (task_id, name, coroutine_stack, awaited_by)
+            if len(task_info.coroutine_stack) == 0:
+                coroutine_stack = []
+                awaited_by = task_info.awaited_by
+            else:
+                coroutine_stack = task_info.coroutine_stack
+                awaited_by = task_info.awaited_by
+            
+            # Add coroutine stack information for the current task
+            if coroutine_stack:
+                coro_stack = []
+                for coro_info in coroutine_stack:
+                    call_stack = coro_info.call_stack
+                    frame_names = [frame for frame in call_stack]
+                    coro_stack.extend(frame_names)
+                coroutine_stack_str = " -> ".join([_format_stack_entry(x).split(" ")[0] for x in coro_stack])
+            else:
+                coroutine_stack_str = ""
+            
+            if not awaited_by:
                 table.append(
                     [
-                        tid,
+                        thread_id,
                         hex(task_id),
                         task_name,
+                        coroutine_stack_str,
                         "",
                         "",
                         "0x0"
                     ]
                 )
-            for stack, awaiter_id in awaited:
-                stack = [elem[0] if isinstance(elem, tuple) else elem for elem in stack]
-                coroutine_chain = " -> ".join(stack)
-                awaiter_name = id2name.get(awaiter_id, "Unknown")
-                table.append(
-                    [
-                        tid,
-                        hex(task_id),
-                        task_name,
-                        coroutine_chain,
-                        awaiter_name,
-                        hex(awaiter_id),
-                    ]
-                )
+            else:
+                for coro_info in awaited_by:
+                    call_stack = coro_info.call_stack
+                    parent_task_id = coro_info.task_name
+                    awaiter_stack = [frame for frame in call_stack]
+                    awaiter_chain = " -> ".join([_format_stack_entry(x).split(" ")[0] for x in awaiter_stack])
+                    awaiter_name = id2name.get(parent_task_id, "Unknown")
+                    table.append(
+                        [
+                            thread_id,
+                            hex(task_id),
+                            task_name,
+                            coroutine_stack_str,
+                            awaiter_chain,
+                            awaiter_name,
+                            hex(parent_task_id) if isinstance(parent_task_id, int) else str(parent_task_id),
+                        ]
+                    )
 
     return table
 
@@ -211,11 +268,11 @@ def display_awaited_by_tasks_table(pid: int) -> None:
     table = build_task_table(tasks)
     # Print the table in a simple tabular format
     print(
-        f"{'tid':<10} {'task id':<20} {'task name':<20} {'coroutine chain':<50} {'awaiter name':<20} {'awaiter id':<15}"
+        f"{'tid':<10} {'task id':<20} {'task name':<20} {'coroutine stack':<50} {'awaiter chain':<50} {'awaiter name':<15} {'awaiter id':<15}"
     )
-    print("-" * 135)
+    print("-" * 180)
     for row in table:
-        print(f"{row[0]:<10} {row[1]:<20} {row[2]:<20} {row[3]:<50} {row[4]:<20} {row[5]:<15}")
+        print(f"{row[0]:<10} {row[1]:<20} {row[2]:<20} {row[3]:<50} {row[4]:<50} {row[5]:<15} {row[6]:<15}")
 
 
 def display_awaited_by_tasks_tree(pid: int) -> None: