Async-streams: Disposal in async-iterator methods #31527

jcouv · 2018-12-04T21:51:29Z

Overview of the change:

moved async-iterator rewriter into its own class (AsyncIteratorMethodToStateMachineRewriter, instead of mixed in AsyncMethodToStateMachineRewriter)
implement VisitTryStatement, which includes adding jumps after finallys
- to support that, updated AsyncExceptionHandlerRewriter to wrap extracted finally blocks with BoundExtractedFinallyBlock
adjust VisitYieldReturnStatement and VisitYieldBreakStatement with logic to jump to relevant finally
- to support that, updated BoundTryStatement to record the label for extracted finally blocks
fixed the implementation of DisposeAsync() method
- to support that, added implementation of IValueTaskSource to state machine (which previously implemented IValueTaskSource<T>

Please read the design doc (updated in this PR) for more details.

Note: I didn't test continue/break/goto yet (tracked in #24037)

Here's an example of lowering (input and pseudo-C# output):

        try
        {
            yield return 1;
            Write(""Try "");
            yield break;
        }
        finally
        {
            Write(""Finally "");
            await System.Threading.Tasks.Task.CompletedTask;
        }

{
    int temp1;
    temp1 = this.<>1__state;
    try
    {
        switch (temp1)
        {
            case 0:
                goto <tryDispatch-45>;
                break;
            case 1:
                goto <stateMachine-48>;
                break;
        }
        {
            {
                {
                    this.<>s__1 = default;
                    this.<>s__2 = default;
                    {
                        <tryDispatch-45>: ;
                        try
                        {
                            switch (temp1)
                            {
                                case 0:
                                    goto <stateMachine-43>;
                                    break;
                            }
                            {
                                {
                                    {
                                        this.<>2__current = 1;
                                        this.<>1__state = temp1 = 0;
                                        goto <yieldReturn-42>;
                                        <stateMachine-43>: ;
                                        this.<>1__state = temp1 = -1;
                                        {
                                            if (!this.<>w__disposeMode) goto <afterif-44>;
                                            goto <finallyLabel-37>;
                                            <afterif-44>: ;
                                        }
                                    }
                                    Write("Try ");
                                    {
                                        this.<>w__disposeMode = True;
                                        goto <finallyLabel-37>;
                                    }
                                }
                                goto <finallyLabel-37>;
                                {
                                }
                            }
                        }
                        catch (Object) 
                        {
                        }
                    }
                    {
                        {
                            <finallyLabel-37>: ;
                            {
                                Write("Finally ");
                                {
                                    System.Runtime.CompilerServices.TaskAwaiter temp2;
                                    {
                                        temp2 = Task.get_CompletedTask().GetAwaiter();
                                        {
                                            if (! BoolLogicalNegation temp2.get_IsCompleted()) goto <afterif-49>;
                                            {
                                                this.<>1__state = temp1 = 1;
                                                this.<>u__1 = temp2;
                                                { temp3 = this; this.<>t__builder.AwaitUnsafeOnCompleted(temp2, temp3) };
                                                goto <exitLabel-41>;
                                                <stateMachine-48>: ;
                                                temp2 = this.<>u__1;
                                                this.<>u__1 = default;
                                                this.<>1__state = temp1 = -1;
                                            }
                                            <afterif-49>: ;
                                        }
                                    }
                                    temp2.GetResult();
                                }
                            }
                            {
                                object temp4;
                                temp4 = this.<>s__1;
                                {
                                    if (!temp4 ObjectNotEqual null) goto <afterif-39>;
                                    {
                                        System.Exception temp5;
                                        temp5 = AsOperator
                                        ;
                                        {
                                            if (!temp5 ObjectEqual null) goto <afterif-38>;
                                            throw temp4;
                                            <afterif-38>: ;
                                        }
                                        Capture(temp5).Throw();
                                    }
                                    <afterif-39>: ;
                                }
                            }
                            this.<>s__2;
                        }
                        {
                            if (!this.<>w__disposeMode) goto <afterif-50>;
                            goto <exprReturn-40>;
                            <afterif-50>: ;
                        }
                    }
                }
                this.<>s__1 = null;
            }
        }
    }
    catch (Exception) 
    {
        this.<>1__state = -2;
        this.<>v__promiseOfValueOrEnd.SetException(temp6);
        goto <exitLabel-41>;
    }
    <exprReturn-40>: ;
    this.<>1__state = -2;
    {
        this.<>v__promiseOfValueOrEnd.SetResult(False);
        return;
        <yieldReturn-42>: ;
        this.<>v__promiseOfValueOrEnd.SetResult(True);
    }
    <exitLabel-41>: ;
    return;
}

Async-streams umbrella: #24037

jcouv · 2018-12-04T22:31:10Z

src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs

-                    // if (State == StateMachineStates.FinishedStateMachine)
+                TypeSymbol returnType = IAsyncEnumerableOfElementType_MoveNextAsync.ReturnType.TypeSymbol;
+
+                GetPartsForStartingMachine(returnType,


GetPartsForStartingMachine [](start = 16, length = 26)

📝 extracted a number of locals to this helper method, so that it could be re-used in implementation of DisposeAsync(). #Resolved

jcouv · 2018-12-05T01:55:26Z

src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs

-        /// finally blocks in case the state machine is disposed.  The Dispose method computes the new state
-        /// and then runs MoveNext.  Not used if !this.useFinalizerBookkeeping.
-        /// </summary>
-        protected Dictionary<int, int> finalizerStateMap = new Dictionary<int, int>();


finalizerStateMap [](start = 39, length = 17)

📝 removed as it was unused (only added to, but never read from) #Resolved

jcouv · 2018-12-05T21:00:52Z

@agocke @cston @dotnet/roslyn-compiler for review. Thanks
I'm happy to walk you through the design. Let me know. #Resolved

cston · 2018-12-10T22:39:55Z