protected virtual BoundStatement GenerateSetResultCall() { // builder.SetResult([RetVal]) return(F.ExpressionStatement( F.Call( F.Field(F.This(), _asyncMethodBuilderField), _asyncMethodBuilderMemberCollection.SetResult, _method.IsGenericTaskReturningAsync(F.Compilation) ? ImmutableArray.Create <BoundExpression>(F.Local(_exprRetValue)) : ImmutableArray <BoundExpression> .Empty))); }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, int methodOrdinal, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet <Symbol> hoistedVariables, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics) : base(F, method, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics, useFinalizerBookkeeping: false) { _method = method; _asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; _asyncMethodBuilderField = builder; _exprReturnLabel = F.GenerateLabel("exprReturn"); _exitLabel = F.GenerateLabel("exitLabel"); _exprRetValue = method.IsGenericTaskReturningAsync(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, syntax: F.Syntax, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; _dynamicFactory = new LoweredDynamicOperationFactory(F, methodOrdinal); _awaiterFields = new Dictionary <TypeSymbol, FieldSymbol>(TypeSymbol.EqualsIgnoringDynamicAndTupleNamesComparer); _nextAwaiterId = slotAllocatorOpt?.PreviousAwaiterSlotCount ?? 0; }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, HashSet <Symbol> variablesCaptured, Dictionary <Symbol, CapturedSymbolReplacement> initialProxies, DiagnosticBag diagnostics, bool generateDebugInfo) : base(F, method, state, variablesCaptured, initialProxies, diagnostics, useFinalizerBookkeeping: false, generateDebugInfo: generateDebugInfo) { this.method = method; this.asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; this.asyncMethodBuilderField = builder; this.exprReturnLabel = F.GenerateLabel("exprReturn"); this.exitLabel = F.GenerateLabel("exitLabel"); this.exprRetValue = method.IsGenericTaskReturningAsync(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; this.dynamicFactory = new LoweredDynamicOperationFactory(F); }
internal AsyncMethodToClassRewriter( MethodSymbol method, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory factory, FieldSymbol state, FieldSymbol builder, Dictionary <Symbol, CapturedSymbol> localProxies, DiagnosticBag diagnostics) : base(factory, state, localProxies, diagnostics) { this.method = method; this.asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; this.asyncMethodBuilderField = builder; this.exprReturnLabel = factory.GenerateLabel("exprReturn"); this.exprRetValue = method.IsGenericTaskReturningAsync() ? factory.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, GeneratedNames.AsyncExprRetValueFieldName()) : null; this.dynamicFactory = new LoweredDynamicOperationFactory(factory); }
/// <summary> /// Generate the body for <c>MoveNext()</c>. /// </summary> internal void GenerateMoveNext(BoundStatement body, MethodSymbol moveNextMethod) { F.CurrentMethod = moveNextMethod; BoundStatement rewrittenBody = (BoundStatement)Visit(body); ImmutableArray <StateMachineFieldSymbol> rootScopeHoistedLocals; TryUnwrapBoundStateMachineScope(ref rewrittenBody, out rootScopeHoistedLocals); var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance(); bodyBuilder.Add(F.HiddenSequencePoint()); bodyBuilder.Add(F.Assignment(F.Local(cachedState), F.Field(F.This(), stateField))); bodyBuilder.Add(CacheThisIfNeeded()); var exceptionLocal = F.SynthesizedLocal(F.WellKnownType(WellKnownType.System_Exception)); bodyBuilder.Add( F.Try( F.Block(ImmutableArray <LocalSymbol> .Empty, // switch (state) ... F.HiddenSequencePoint(), Dispatch(), // [body] rewrittenBody ), F.CatchBlocks( new BoundCatchBlock( F.Syntax, ImmutableArray.Create(exceptionLocal), F.Local(exceptionLocal), exceptionLocal.Type, exceptionFilterOpt: null, body: F.Block( // this.state = finishedState F.Assignment(F.Field(F.This(), stateField), F.Literal(StateMachineStates.FinishedStateMachine)), // builder.SetException(ex) F.ExpressionStatement( F.Call( F.Field(F.This(), _asyncMethodBuilderField), _asyncMethodBuilderMemberCollection.SetException, F.Local(exceptionLocal))), GenerateReturn(false)), isSynthesizedAsyncCatchAll: true) ) ) ); // ReturnLabel (for the rewritten return expressions in the user's method body) bodyBuilder.Add(F.Label(_exprReturnLabel)); // this.state = finishedState var stateDone = F.Assignment(F.Field(F.This(), stateField), F.Literal(StateMachineStates.FinishedStateMachine)); var block = body.Syntax as BlockSyntax; if (block == null) { // this happens, for example, in (async () => await e) where there is no block syntax bodyBuilder.Add(stateDone); } else { bodyBuilder.Add(F.SequencePointWithSpan(block, block.CloseBraceToken.Span, stateDone)); bodyBuilder.Add(F.HiddenSequencePoint()); // The remaining code is hidden to hide the fact that it can run concurrently with the task's continuation } // builder.SetResult([RetVal]) bodyBuilder.Add( F.ExpressionStatement( F.Call( F.Field(F.This(), _asyncMethodBuilderField), _asyncMethodBuilderMemberCollection.SetResult, _method.IsGenericTaskReturningAsync(F.Compilation) ? ImmutableArray.Create <BoundExpression>(F.Local(_exprRetValue)) : ImmutableArray <BoundExpression> .Empty))); // this code is hidden behind a hidden sequence point. bodyBuilder.Add(F.Label(_exitLabel)); bodyBuilder.Add(F.Return()); var newStatements = bodyBuilder.ToImmutableAndFree(); var locals = ArrayBuilder <LocalSymbol> .GetInstance(); locals.Add(cachedState); if ((object)cachedThis != null) { locals.Add(cachedThis); } if ((object)_exprRetValue != null) { locals.Add(_exprRetValue); } var newBody = F.SequencePoint( body.Syntax, F.Block( locals.ToImmutableAndFree(), newStatements)); if (rootScopeHoistedLocals.Length > 0) { newBody = MakeStateMachineScope(rootScopeHoistedLocals, newBody); } F.CloseMethod(newBody); }
internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method, TypeMap typeMap, out AsyncMethodBuilderMemberCollection collection) { if (method.IsVoidReturningAsync()) { var builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncVoidMethodBuilder); Debug.Assert((object)builderType != null); MethodSymbol createBuilderMethod; bool customBuilder = false; TryGetBuilderMember <MethodSymbol>( F, WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Create, builderType, customBuilder, out createBuilderMethod); if ((object)createBuilderMethod == null) { collection = default(AsyncMethodBuilderMemberCollection); return(false); } return(TryCreate( F, customBuilder: customBuilder, builderType: builderType, resultType: F.SpecialType(SpecialType.System_Void), createBuilderMethod: createBuilderMethod, taskProperty: null, setException: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetStateMachine, collection: out collection)); } if (method.IsTaskReturningAsync(F.Compilation)) { var returnType = (NamedTypeSymbol)method.ReturnType.TypeSymbol; NamedTypeSymbol builderType; MethodSymbol createBuilderMethod = null; PropertySymbol taskProperty = null; object builderArgument; bool customBuilder = returnType.IsCustomTaskType(out builderArgument); if (customBuilder) { builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: false); if ((object)builderType != null) { taskProperty = GetCustomTaskProperty(F, builderType, returnType); createBuilderMethod = GetCustomCreateMethod(F, builderType); } } else { builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder); Debug.Assert((object)builderType != null); TryGetBuilderMember <MethodSymbol>( F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Create, builderType, customBuilder, out createBuilderMethod); TryGetBuilderMember <PropertySymbol>( F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Task, builderType, customBuilder, out taskProperty); } if ((object)builderType == null || (object)createBuilderMethod == null || (object)taskProperty == null) { collection = default(AsyncMethodBuilderMemberCollection); return(false); } return(TryCreate( F, customBuilder: customBuilder, builderType: builderType, resultType: F.SpecialType(SpecialType.System_Void), createBuilderMethod: createBuilderMethod, taskProperty: taskProperty, setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetStateMachine, collection: out collection)); } if (method.IsGenericTaskReturningAsync(F.Compilation)) { var returnType = (NamedTypeSymbol)method.ReturnType.TypeSymbol; var resultType = returnType.TypeArgumentsNoUseSiteDiagnostics.Single().TypeSymbol; if (resultType.IsDynamic()) { resultType = F.SpecialType(SpecialType.System_Object); } if (typeMap != null) { resultType = typeMap.SubstituteType(resultType).TypeSymbol; } returnType = returnType.ConstructedFrom.Construct(resultType); NamedTypeSymbol builderType; MethodSymbol createBuilderMethod = null; PropertySymbol taskProperty = null; object builderArgument; bool customBuilder = returnType.IsCustomTaskType(out builderArgument); if (customBuilder) { builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: true); if ((object)builderType != null) { builderType = builderType.ConstructedFrom.Construct(resultType); taskProperty = GetCustomTaskProperty(F, builderType, returnType); createBuilderMethod = GetCustomCreateMethod(F, builderType); } } else { builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T); Debug.Assert((object)builderType != null); builderType = builderType.Construct(resultType); TryGetBuilderMember <MethodSymbol>( F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Create, builderType, customBuilder, out createBuilderMethod); TryGetBuilderMember <PropertySymbol>( F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Task, builderType, customBuilder, out taskProperty); } if ((object)builderType == null || (object)taskProperty == null || (object)createBuilderMethod == null) { collection = default(AsyncMethodBuilderMemberCollection); return(false); } return(TryCreate( F, customBuilder: customBuilder, builderType: builderType, resultType: resultType, createBuilderMethod: createBuilderMethod, taskProperty: taskProperty, setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetStateMachine, collection: out collection)); } throw ExceptionUtilities.UnexpectedValue(method); }
/// <summary> /// Generate the body for <c>MoveNext()</c>. /// </summary> internal void GenerateMoveNext(BoundStatement body, MethodSymbol moveNextMethod) { F.CurrentMethod = moveNextMethod; int initialState; GeneratedLabelSymbol initialLabel; AddState(out initialState, out initialLabel); var exceptionLocal = F.SynthesizedLocal(F.WellKnownType(WellKnownType.System_Exception)); var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance(); bodyBuilder.Add(F.HiddenSequencePoint()); bodyBuilder.Add(F.Assignment(F.Local(cachedState), F.Field(F.This(), stateField))); BoundStatement rewrittenBody = (BoundStatement)Visit(body); bodyBuilder.Add( F.Try( F.Block(ImmutableArray <LocalSymbol> .Empty, // switch (state) ... F.HiddenSequencePoint(), Dispatch(), F.Label(initialLabel), // [body] rewrittenBody ), F.CatchBlocks( F.Catch( exceptionLocal, F.Block( F.NoOp(method.ReturnsVoid ? NoOpStatementFlavor.AsyncMethodCatchHandler : NoOpStatementFlavor.Default), // this.state = finishedState F.Assignment(F.Field(F.This(), stateField), F.Literal(StateMachineStates.FinishedStateMachine)), // builder.SetException(ex) F.ExpressionStatement( F.Call( F.Field(F.This(), asyncMethodBuilderField), asyncMethodBuilderMemberCollection.SetException, F.Local(exceptionLocal))), GenerateReturn(false) ) ) ) )); // ReturnLabel (for the rewritten return expressions in the user's method body) bodyBuilder.Add(F.Label(exprReturnLabel)); // this.state = finishedState var stateDone = F.Assignment(F.Field(F.This(), stateField), F.Literal(StateMachineStates.FinishedStateMachine)); var block = body.Syntax as BlockSyntax; if (block == null) { // this happens, for example, in (async () => await e) where there is no block syntax bodyBuilder.Add(stateDone); } else { bodyBuilder.Add(F.SequencePointWithSpan(block, block.CloseBraceToken.Span, stateDone)); bodyBuilder.Add(F.HiddenSequencePoint()); // The remaining code is hidden to hide the fact that it can run concurrently with the task's continuation } // builder.SetResult([RetVal]) bodyBuilder.Add( F.ExpressionStatement( F.Call( F.Field(F.This(), asyncMethodBuilderField), asyncMethodBuilderMemberCollection.SetResult, method.IsGenericTaskReturningAsync(F.Compilation) ? ImmutableArray.Create <BoundExpression>(F.Local(exprRetValue)) : ImmutableArray <BoundExpression> .Empty))); // this code is hidden behind a hidden sequence point. bodyBuilder.Add(F.Label(this.exitLabel)); bodyBuilder.Add(F.Return()); var newBody = bodyBuilder.ToImmutableAndFree(); var locals = ArrayBuilder <LocalSymbol> .GetInstance(); locals.Add(cachedState); if ((object)exprRetValue != null) { locals.Add(exprRetValue); } F.CloseMethod( F.SequencePoint( body.Syntax, F.Block( locals.ToImmutableAndFree(), newBody))); }
/// <summary> /// Generate the body for MoveNext() /// </summary> internal void GenerateMoveNext(BoundStatement body, MethodSymbol moveNextMethod) { F.CurrentMethod = moveNextMethod; int initialState; GeneratedLabelSymbol initialLabel; AddState(out initialState, out initialLabel); var exceptionLocal = F.SynthesizedLocal(F.WellKnownType(WellKnownType.System_Exception), GeneratedNames.AsyncExceptionFieldName()); BoundStatement rewrittenBody = (BoundStatement)Visit(body); rewrittenBody = (BoundStatement) new AwaitLoweringRewriterPass1(F).Visit(rewrittenBody); rewrittenBody = (BoundStatement) new AwaitLoweringRewriterPass2(F, CompilationState).Visit(rewrittenBody); UnloweredSpillNodeVerifier.Verify(rewrittenBody); var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance(); bodyBuilder.Add( F.Try( F.Block( ReadOnlyArray <LocalSymbol> .Empty, // switch (state) ... Dispatch(), // TODO(t-liam) - debugging support... // dev11(LanguageAnalysis\Compiler\ResumableRewriter.cpp:325) does codegen here to add a // debug nop and the 'NoCullNormalExit' label F.Label(initialLabel), // [body] rewrittenBody ), F.CatchBlocks( // TODO(t-liam) - debugging support... // dev11(LanguageAnalysis\Compiler\ResumableRewriter.cpp:391) // // Async void method generated catch handlers have their IL start offset // // recorded to the PDB for special exception handling in the debugger. // // Mark the EXPRHANDLER as such so we know to record its offset later. F.Catch( F.WellKnownType(WellKnownType.System_Exception), exceptionLocal, F.Block( // state = finishedState F.Assignment(F.Field(F.This(), state), F.Literal(StateMachineStates.FinishedStateMachine)), // builder.SetException(ex) F.ExpressionStatement( F.Call( F.Field(F.This(), asyncMethodBuilderField), asyncMethodBuilderMemberCollection.SetException, ReadOnlyArray <BoundExpression> .CreateFrom(F.Local(exceptionLocal)))), F.Return() ) ) ) )); // ReturnLabel (for the rewritten return expressions in the user's method body) bodyBuilder.Add(F.Label(exprReturnLabel)); // state = finishedState bodyBuilder.Add(F.Assignment(F.Field(F.This(), state), F.Literal(StateMachineStates.FinishedStateMachine))); // builder.SetResult([RetVal]) bodyBuilder.Add( F.ExpressionStatement( F.Call( F.Field(F.This(), asyncMethodBuilderField), asyncMethodBuilderMemberCollection.SetResult, method.IsGenericTaskReturningAsync() ? ReadOnlyArray <BoundExpression> .CreateFrom(F.Local(exprRetValue)) : ReadOnlyArray <BoundExpression> .Empty))); bodyBuilder.Add(F.Return()); var newBody = bodyBuilder.ToReadOnlyAndFree(); F.CloseMethod( F.SequencePoint( body.Syntax, F.Block( exprRetValue != null ? ReadOnlyArray <LocalSymbol> .CreateFrom(exprRetValue) : ReadOnlyArray <LocalSymbol> .Empty, newBody))); }
internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method, TypeMap typeMap, out AsyncMethodBuilderMemberCollection collection) { if (method.IsVoidReturningAsync()) { return(TryCreate( F: F, builderType: F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncVoidMethodBuilder), resultType: F.SpecialType(SpecialType.System_Void), setException: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetStateMachine, task: null, collection: out collection)); } if (method.IsTaskReturningAsync(F.Compilation)) { NamedTypeSymbol builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder); PropertySymbol task; if (!TryGetWellKnownPropertyAsMember(F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Task, builderType, out task)) { collection = default(AsyncMethodBuilderMemberCollection); return(false); } return(TryCreate( F: F, builderType: F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder), resultType: F.SpecialType(SpecialType.System_Void), setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetStateMachine, task: task, collection: out collection)); } if (method.IsGenericTaskReturningAsync(F.Compilation)) { TypeSymbol resultType = method.ReturnType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single(); if (resultType.IsDynamic()) { resultType = F.SpecialType(SpecialType.System_Object); } if (typeMap != null) { resultType = typeMap.SubstituteType(resultType); } NamedTypeSymbol builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T).Construct(resultType); PropertySymbol task; if (!TryGetWellKnownPropertyAsMember(F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Task, builderType, out task)) { collection = default(AsyncMethodBuilderMemberCollection); return(false); } return(TryCreate( F: F, builderType: builderType, resultType: resultType, setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetException, setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetResult, awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitOnCompleted, awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitUnsafeOnCompleted, start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Start_T, setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetStateMachine, task: task, collection: out collection)); } throw ExceptionUtilities.UnexpectedValue(method); }