protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType)
{
try
{
var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// If the async method's result type is a type parameter of the method, then the AsyncTaskMethodBuilder<T>
// needs to use the method's type parameters inside the rewritten method body. All other methods generated
// during async rewriting are members of the synthesized state machine struct, and use the type parameters
// structs type parameters.
AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection;
if (!AsyncMethodBuilderMemberCollection.TryCreate(F, method, null, out methodScopeAsyncMethodBuilderMemberCollection))
{
return(new BoundBadStatement(F.Syntax, ImmutableArray <BoundNode> .Empty, hasErrors: true));
}
var builderVariable = F.SynthesizedLocal(methodScopeAsyncMethodBuilderMemberCollection.BuilderType, null);
// local.$builder = System.Runtime.CompilerServices.AsyncTaskMethodBuilder<typeArgs>.Create();
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)),
F.StaticCall(_ignoreAccessibility ? BinderFlags.IgnoreAccessibility : BinderFlags.None, methodScopeAsyncMethodBuilderMemberCollection.BuilderType, "Create", ImmutableArray <TypeSymbol> .Empty)));
// local.$stateField = NotStartedStateMachine
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), stateField.AsMember(frameType)),
F.Literal(StateMachineStates.NotStartedStateMachine)));
bodyBuilder.Add(
F.Assignment(
F.Local(builderVariable),
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType))));
// local.$builder.Start(ref local) -- binding to the method AsyncTaskMethodBuilder<typeArgs>.Start()
bodyBuilder.Add(
F.ExpressionStatement(
F.Call(
F.Local(builderVariable),
methodScopeAsyncMethodBuilderMemberCollection.Start.Construct(frameType),
ImmutableArray.Create <BoundExpression>(F.Local(stateMachineVariable)))));
bodyBuilder.Add(method.IsVoidReturningAsync()
? F.Return()
: F.Return(F.Property(F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)), "Task")));
return(F.Block(
ImmutableArray.Create(builderVariable),
bodyBuilder.ToImmutableAndFree()));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
F.Diagnostics.Add(ex.Diagnostic);
return(new BoundBadStatement(F.Syntax, ImmutableArray <BoundNode> .Empty, hasErrors: true));
}
}
protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> proxies)
{
// If the async method's result type is a type parameter of the method, then the AsyncTaskMethodBuilder<T>
// needs to use the method's type parameters inside the rewritten method body. All other methods generated
// during async rewriting are members of the synthesized state machine struct, and use the type parameters
// structs type parameters.
AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection;
if (!AsyncMethodBuilderMemberCollection.TryCreate(F, method, null, out methodScopeAsyncMethodBuilderMemberCollection))
{
return(new BoundBadStatement(F.Syntax, ImmutableArray <BoundNode> .Empty, hasErrors: true));
}
var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// local.$builder = System.Runtime.CompilerServices.AsyncTaskMethodBuilder<typeArgs>.Create();
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)),
F.StaticCall(
null,
methodScopeAsyncMethodBuilderMemberCollection.CreateBuilder)));
bodyBuilder.Add(GenerateParameterStorage(stateMachineVariable, proxies));
// local.$stateField = NotStartedStateMachine
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), stateField.AsMember(frameType)),
F.Literal(StateMachineStates.NotStartedStateMachine)));
// local.$builder.Start(ref local) -- binding to the method AsyncTaskMethodBuilder<typeArgs>.Start()
var startMethod = methodScopeAsyncMethodBuilderMemberCollection.Start.Construct(frameType);
if (methodScopeAsyncMethodBuilderMemberCollection.CheckGenericMethodConstraints)
{
startMethod.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(F.Compilation, F.Compilation.Conversions, includeNullability: false, F.Syntax.Location, diagnostics));
}
bodyBuilder.Add(
F.ExpressionStatement(
F.Call(
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)),
startMethod,
ImmutableArray.Create <BoundExpression>(F.Local(stateMachineVariable)))));
bodyBuilder.Add(method.IsAsyncReturningVoid()
? F.Return()
: F.Return(
F.Property(
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)),
methodScopeAsyncMethodBuilderMemberCollection.Task)));
return(F.Block(bodyBuilder.ToImmutableAndFree()));
}
protected override void GenerateConstructor()
{
// Produces:
// .ctor(int state)
// {
// this.state = state;
// this.initialThreadId = {managedThreadId};
// this.builder = System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create();
// this.valueOrEndPromise = new ManualResetValueTaskSourceLogic<bool>(this);
// }
Debug.Assert(stateMachineType.Constructor is IteratorConstructor);
F.CurrentFunction = stateMachineType.Constructor;
var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance();
bodyBuilder.Add(F.BaseInitialization());
bodyBuilder.Add(F.Assignment(F.Field(F.This(), stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state;
var managedThreadId = MakeCurrentThreadId();
if (managedThreadId != null && (object)initialThreadIdField != null)
{
// this.initialThreadId = {managedThreadId};
bodyBuilder.Add(F.Assignment(F.Field(F.This(), initialThreadIdField), managedThreadId));
}
// this.builder = System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create();
AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection;
bool found = AsyncMethodBuilderMemberCollection.TryCreate(F, method, typeMap: null, out methodScopeAsyncMethodBuilderMemberCollection);
Debug.Assert(found);
bodyBuilder.Add(
F.Assignment(
F.Field(F.This(), _builderField),
F.StaticCall(
null,
methodScopeAsyncMethodBuilderMemberCollection.CreateBuilder)));
// this._valueOrEndPromise = new ManualResetValueTaskSourceLogic<bool>(this);
MethodSymbol mrvtslCtor =
F.WellKnownMethod(WellKnownMember.System_Threading_Tasks_ManualResetValueTaskSourceLogic_T__ctor)
.AsMember((NamedTypeSymbol)_promiseOfValueOrEndField.Type.TypeSymbol);
bodyBuilder.Add(
F.Assignment(
F.Field(F.This(), _promiseOfValueOrEndField),
F.New(mrvtslCtor, F.This())));
bodyBuilder.Add(F.Return());
F.CloseMethod(F.Block(bodyBuilder.ToImmutableAndFree()));
bodyBuilder = null;
}
private AsyncRewriter(
BoundStatement body,
MethodSymbol method,
int methodOrdinal,
AsyncStateMachine stateMachineType,
VariableSlotAllocator slotAllocatorOpt,
TypeCompilationState compilationState,
BindingDiagnosticBag diagnostics)
: base(body, method, stateMachineType, slotAllocatorOpt, compilationState, diagnostics)
{
_constructedSuccessfully = AsyncMethodBuilderMemberCollection.TryCreate(F, method, this.stateMachineType.TypeMap, out _asyncMethodBuilderMemberCollection);
_methodOrdinal = methodOrdinal;
}
/// <summary>
/// Generates the body of the replacement method, which initializes the state machine. Unlike regular async methods, we won't start it.
/// </summary>
protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType)
{
// If the async method's result type is a type parameter of the method, then the AsyncTaskMethodBuilder<T>
// needs to use the method's type parameters inside the rewritten method body. All other methods generated
// during async rewriting are members of the synthesized state machine struct, and use the type parameters
// from the struct.
AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection;
if (!AsyncMethodBuilderMemberCollection.TryCreate(F, method, null, out methodScopeAsyncMethodBuilderMemberCollection))
{
return(new BoundBadStatement(F.Syntax, ImmutableArray <BoundNode> .Empty, hasErrors: true));
}
var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// local.$builder = System.Runtime.CompilerServices.AsyncTaskMethodBuilder<typeArgs>.Create();
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), _builderField.AsMember(frameType)),
F.StaticCall(
null,
methodScopeAsyncMethodBuilderMemberCollection.CreateBuilder)));
// local.$stateField = NotStartedStateMachine;
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), stateField.AsMember(frameType)),
F.Literal(StateMachineStates.NotStartedStateMachine)));
// local._valueOrEndPromise = new ManualResetValueTaskSourceLogic<bool>(stateMachine);
MethodSymbol mrvtslCtor =
F.WellKnownMethod(WellKnownMember.System_Threading_Tasks_ManualResetValueTaskSourceLogic_T__ctor)
.AsMember((NamedTypeSymbol)_promiseOfValueOrEndField.Type.TypeSymbol);
bodyBuilder.Add(
F.Assignment(
F.Field(F.Local(stateMachineVariable), _promiseOfValueOrEndField.AsMember(frameType)),
F.New(mrvtslCtor, F.Local(stateMachineVariable))));
// return local;
bodyBuilder.Add(F.Return(F.Local(stateMachineVariable)));
return(F.Block(
bodyBuilder.ToImmutableAndFree()));
}
private AsyncRewriter(
BoundStatement body,
MethodSymbol method,
AsyncStateMachine stateMachineClass,
TypeCompilationState compilationState,
DiagnosticBag diagnostics,
bool generateDebugInfo)
: base(body, method, stateMachineClass, compilationState, diagnostics, generateDebugInfo)
{
try
{
constructedSuccessfully = AsyncMethodBuilderMemberCollection.TryCreate(F, method, this.stateMachineClass.TypeMap, out this.asyncMethodBuilderMemberCollection);
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
constructedSuccessfully = false;
}
}
private AsyncRewriter(
BoundStatement body,
MethodSymbol method,
AsyncStateMachine stateMachineType,
VariableSlotAllocator variableSlotAllocatorOpt,
TypeCompilationState compilationState,
DiagnosticBag diagnostics)
: base(body, method, stateMachineType, variableSlotAllocatorOpt, compilationState, diagnostics)
{
try
{
constructedSuccessfully = AsyncMethodBuilderMemberCollection.TryCreate(F, method, this.stateMachineType.TypeMap, out this.asyncMethodBuilderMemberCollection);
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
constructedSuccessfully = false;
}
}
protected override void GenerateConstructor()
{
// Produces:
// .ctor(int state)
// {
// this.state = state;
// this.initialThreadId = {managedThreadId};
// this.builder = System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create();
// }
Debug.Assert(stateMachineType.Constructor is IteratorConstructor);
F.CurrentFunction = stateMachineType.Constructor;
var bodyBuilder = ArrayBuilder <BoundStatement> .GetInstance();
bodyBuilder.Add(F.BaseInitialization());
bodyBuilder.Add(F.Assignment(F.Field(F.This(), stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state;
var managedThreadId = MakeCurrentThreadId();
if (managedThreadId != null && (object)initialThreadIdField != null)
{
// this.initialThreadId = {managedThreadId};
bodyBuilder.Add(F.Assignment(F.Field(F.This(), initialThreadIdField), managedThreadId));
}
// this.builder = System.Runtime.CompilerServices.AsyncVoidMethodBuilder.Create();
AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection;
bool found = AsyncMethodBuilderMemberCollection.TryCreate(F, method, typeMap: null, out methodScopeAsyncMethodBuilderMemberCollection);
Debug.Assert(found);
bodyBuilder.Add(
F.Assignment(
F.Field(F.This(), _builderField),
F.StaticCall(
null,
methodScopeAsyncMethodBuilderMemberCollection.CreateBuilder)));
bodyBuilder.Add(F.Return());
F.CloseMethod(F.Block(bodyBuilder.ToImmutableAndFree()));
bodyBuilder = null;
}
private AsyncRewriter(
BoundStatement body,
MethodSymbol method,
int methodOrdinal,
AsyncStateMachine stateMachineType,
VariableSlotAllocator slotAllocatorOpt,
TypeCompilationState compilationState,
DiagnosticBag diagnostics)
: base(body, method, stateMachineType, slotAllocatorOpt, compilationState, diagnostics)
{
try
{
_constructedSuccessfully = AsyncMethodBuilderMemberCollection.TryCreate(F, method, this.stateMachineType.TypeMap, out _asyncMethodBuilderMemberCollection);
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
_constructedSuccessfully = false;
}
_methodOrdinal = methodOrdinal;
_ignoreAccessibility = compilationState.ModuleBuilderOpt.IgnoreAccessibility;
}