[RuntimeAsync] Do not hold on to the last used Continuation in the runtime async tasks. (#121460)

Fixes: #121459

The wrapped continuation is expected to be used only once - when the
corresponding async method is resumed. We can and should null-out the
continuation while fetching it in the dispatcher. There is no need to
keep it referenced from the task once fetched as it may cause "leaks"
observable via WeakReference/Finalization and the like.

The close analog of this behavior in the async1 is the C# state machine
zeroing out pointer-containing fields in the display struct upon
completing or faulting the task.


https://github.com/dotnet/roslyn/blob/f2df0ad6d3ef30ed033a794e7150a5600be50a95/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs#L186


https://github.com/dotnet/roslyn/blob/f2df0ad6d3ef30ed033a794e7150a5600be50a95/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs#L224

Author: VSadov

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

@@ -238,7 +238,7 @@ private static void TransparentAwait(object o)
         private interface IRuntimeAsyncTaskOps<T>
         {
             static abstract Action GetContinuationAction(T task);
-            static abstract Continuation GetContinuationState(T task);
+            static abstract Continuation MoveContinuationState(T task);
             static abstract void SetContinuationState(T task, Continuation value);
             static abstract bool SetCompleted(T task);
             static abstract void PostToSyncContext(T task, SynchronizationContext syncCtx);
@@ -297,9 +297,16 @@ void ITaskCompletionAction.Invoke(Task completingTask)
             private struct Ops : IRuntimeAsyncTaskOps<RuntimeAsyncTask<T>>
             {
                 public static Action GetContinuationAction(RuntimeAsyncTask<T> task) => (Action)task.m_action!;
-                public static Continuation GetContinuationState(RuntimeAsyncTask<T> task) => (Continuation)task.m_stateObject!;
+                public static Continuation MoveContinuationState(RuntimeAsyncTask<T> task)
+                {
+                    Continuation continuation = (Continuation)task.m_stateObject!;
+                    task.m_stateObject = null;
+                    return continuation;
+                }
+
                 public static void SetContinuationState(RuntimeAsyncTask<T> task, Continuation value)
                 {
+                    Debug.Assert(task.m_stateObject == null);
                     task.m_stateObject = value;
                 }
 
@@ -373,9 +380,16 @@ void ITaskCompletionAction.Invoke(Task completingTask)
             private struct Ops : IRuntimeAsyncTaskOps<RuntimeAsyncTask>
             {
                 public static Action GetContinuationAction(RuntimeAsyncTask task) => (Action)task.m_action!;
-                public static Continuation GetContinuationState(RuntimeAsyncTask task) => (Continuation)task.m_stateObject!;
+                public static Continuation MoveContinuationState(RuntimeAsyncTask task)
+                {
+                    Continuation continuation = (Continuation)task.m_stateObject!;
+                    task.m_stateObject = null;
+                    return continuation;
+                }
+
                 public static void SetContinuationState(RuntimeAsyncTask task, Continuation value)
                 {
+                    Debug.Assert(task.m_stateObject == null);
                     task.m_stateObject = value;
                 }
 
@@ -429,7 +443,7 @@ public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task,
 
                 DispatcherInfo dispatcherInfo;
                 dispatcherInfo.Next = t_dispatcherInfo;
-                dispatcherInfo.NextContinuation = TOps.GetContinuationState(task);
+                dispatcherInfo.NextContinuation = TOps.MoveContinuationState(task);
                 t_dispatcherInfo = &dispatcherInfo;
 
                 while (true)