How do I return to the caller of a task?

[AnsisMalins]

When I put a breakpoint on a return statement of an async method, and step over, execution jumps to a seemingly random place in the code. How do I find the location of the caller of the currently executing task?

[tigran-sargsyan-w]

with async/await you don’t “return to the caller” like a normal stack frame. The compiler turns your method into a state machine and schedules a continuation that resumes wherever the UniTask/Task is awaited. So after you step over return, the debugger jumps to whatever continuation gets picked up next — which often looks random.

How to actually find the caller/continuation:

1. Use the Async Call Stack view in your IDE.

• Visual Studio: Debug → Windows → Parallel Stacks (Tasks) or Parallel Tasks. That shows which task resumed from which awaiting site; double-click to navigate the async call stack.
• Rider: enable async stacks in the Debug tool window (recent Rider versions show “Async call stacks” in Frames). It’s not perfect, but it lets you hop to the awaiting site instead of a random frame.

2. UniTask-specific: turn on the Tracker.
   Window → UniTask Tracker → enable Tracking and (temporarily) StackTrace. Tracking shows active/leaked UniTasks and, with StackTrace on, captures where they were started/awaited. It’s super helpful to locate “who awaited this thing”, just remember to turn it off after debugging (there’s overhead).
3. If it’s fire-and-forget (no one awaits it): there is no caller to jump back to. In that case:

• Search for where the method is called, or
• Pass a CancellationToken from the real owner (MonoBehaviour/Scope) so you can still trace lifetime/ownership, or
• Log when you start it with a captured stack (Editor-only), e.g. new System.Diagnostics.StackTrace(1, true).

Tiny repro & how I debug it

private async UniTask<int> LoadScoreAsync()
{
    await UniTask.DelayFrame(1); // break here and Step over
    return 42;
}

private async UniTask UseItAsync()
{
    var score = await LoadScoreAsync(); // <- this is the “caller” (awaiting site)
    Debug.Log(score);
}

• Put breakpoints on return 42; and on the await LoadScoreAsync();.
• In VS open Parallel Stacks (Tasks). You’ll see the continuation that leads back to UseItAsync() (the real “caller”).
• In Unity, open UniTask Tracker and tick Tracking + StackTrace. You’ll see LoadScoreAsync being awaited and can jump to where it was scheduled/awaited.

Why the jump looks random
Because after return the state machine posts a continuation to whatever scheduler/context UniTask captured (usually Unity’s PlayerLoop timing). The next frame/tick resumes the awaiting site, not the lexical caller frame you expect from synchronous code.

Practical tips

• Turn on “Show external code” (VS) if the async frames look too shallow.
• Avoid async void except for event handlers — it breaks the chain for both exceptions and call stacks. Prefer UniTask and Forget() only with an error handler.
• For long chains, sprinkle a few Debug.Log breadcrumbs with method names and a short operation id; combine with Tracker when hunting race conditions.

Hope that clears it up — you don’t step back to a caller; you navigate to the awaiting site via the async stack or UniTask Tracker. If you want, I can attach screenshots of Parallel Stacks / Tracker with a tiny sample.