internal static BoundStatement Rewrite(
BoundStatement body,
MethodSymbol method,
int methodOrdinal,
ArrayBuilder <StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
VariableSlotAllocator slotAllocatorOpt,
TypeCompilationState compilationState,
BindingDiagnosticBag diagnostics,
out IteratorStateMachine stateMachineType)
{
TypeWithAnnotations elementType = method.IteratorElementTypeWithAnnotations;
if (elementType.IsDefault || method.IsAsync)
{
stateMachineType = null;
return(body);
}
// Figure out what kind of iterator we are generating.
bool isEnumerable;
switch (method.ReturnType.OriginalDefinition.SpecialType)
{
case SpecialType.System_Collections_IEnumerable:
case SpecialType.System_Collections_Generic_IEnumerable_T:
isEnumerable = true;
break;
case SpecialType.System_Collections_IEnumerator:
case SpecialType.System_Collections_Generic_IEnumerator_T:
isEnumerable = false;
break;
default:
throw ExceptionUtilities.UnexpectedValue(method.ReturnType.OriginalDefinition.SpecialType);
}
stateMachineType = new IteratorStateMachine(slotAllocatorOpt, compilationState, method, methodOrdinal, isEnumerable, elementType);
compilationState.ModuleBuilderOpt.CompilationState.SetStateMachineType(method, stateMachineType);
var rewriter = new IteratorRewriter(body, method, isEnumerable, stateMachineType, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, compilationState, diagnostics);
if (!rewriter.VerifyPresenceOfRequiredAPIs())
{
return(body);
}
return(rewriter.Rewrite());
}
/// <summary>
/// Rewrite an iterator method into a state machine class.
/// </summary>
internal static BoundStatement Rewrite(
BoundStatement body,
MethodSymbol method,
int methodOrdinal,
VariableSlotAllocator slotAllocatorOpt,
TypeCompilationState compilationState,
DiagnosticBag diagnostics,
out IteratorStateMachine stateMachineType)
{
TypeSymbol elementType = method.IteratorElementType;
if ((object)elementType == null)
{
stateMachineType = null;
return body;
}
// Figure out what kind of iterator we are generating.
bool isEnumerable;
switch (method.ReturnType.OriginalDefinition.SpecialType)
{
case SpecialType.System_Collections_IEnumerable:
case SpecialType.System_Collections_Generic_IEnumerable_T:
isEnumerable = true;
break;
case SpecialType.System_Collections_IEnumerator:
case SpecialType.System_Collections_Generic_IEnumerator_T:
isEnumerable = false;
break;
default:
throw ExceptionUtilities.UnexpectedValue(method.ReturnType.OriginalDefinition.SpecialType);
}
stateMachineType = new IteratorStateMachine(slotAllocatorOpt, compilationState, method, methodOrdinal, isEnumerable, elementType);
compilationState.ModuleBuilderOpt.CompilationState.SetStateMachineType(method, stateMachineType);
var rewriter = new IteratorRewriter(body, method, isEnumerable, stateMachineType, slotAllocatorOpt, compilationState, diagnostics);
if (!rewriter.VerifyPresenceOfRequiredAPIs())
{
return body;
}
return rewriter.Rewrite();
}
internal static BoundStatement LowerStatement(
bool generateDebugInfo,
MethodSymbol method,
BoundStatement body,
SynthesizedSubmissionFields previousSubmissionFields,
TypeCompilationState compilationState,
DiagnosticBag diagnostics)
{
if (body.HasErrors)
{
return(body);
}
bool sawLambdas;
bool sawDynamicOperations;
bool sawAwaitInExceptionHandler;
var loweredBody = LocalRewriter.Rewrite(
method.DeclaringCompilation,
generateDebugInfo,
method,
method.ContainingType,
body,
compilationState,
diagnostics,
previousSubmissionFields,
out sawLambdas,
out sawDynamicOperations,
out sawAwaitInExceptionHandler);
if (sawDynamicOperations && compilationState.ModuleBuilder.IsENCDelta)
{
// Dynamic operations are not supported in ENC.
var location = method.Locations[0];
diagnostics.Add(new CSDiagnosticInfo(ErrorCode.ERR_EnCNoDynamicOperation), location);
}
if (loweredBody.HasErrors)
{
return(loweredBody);
}
if (sawAwaitInExceptionHandler)
{
// If we have awaits in handlers, we need to
// replace handlers with synthetic ones which can be consumed by async rewriter.
// The reason why this rewrite happens before the lambda rewrite
// is that we may need access to exception locals and it would be fairly hard to do
// if these locals are captured into closures (possibly nested ones).
Debug.Assert(method.IteratorElementType == null);
loweredBody = AsyncHandlerRewriter.Rewrite(
generateDebugInfo,
method,
method.ContainingType,
loweredBody,
compilationState,
diagnostics);
}
if (loweredBody.HasErrors)
{
return(loweredBody);
}
BoundStatement bodyWithoutLambdas = loweredBody;
if (sawLambdas)
{
LambdaRewriter.Analysis lambdaAnalysis = LambdaRewriter.Analysis.Analyze(loweredBody, method, out sawLambdas);
if (sawLambdas)
{
bodyWithoutLambdas = LambdaRewriter.Rewrite(loweredBody, method.ContainingType, method.ThisParameter, method, compilationState, diagnostics, lambdaAnalysis, generateDebugInfo);
}
}
if (bodyWithoutLambdas.HasErrors)
{
return(bodyWithoutLambdas);
}
BoundStatement bodyWithoutIterators = IteratorRewriter.Rewrite(bodyWithoutLambdas, method, compilationState, diagnostics, generateDebugInfo);
if (bodyWithoutIterators.HasErrors)
{
return(bodyWithoutIterators);
}
BoundStatement bodyWithoutAsync = AsyncRewriter2.Rewrite(bodyWithoutIterators, method, compilationState, diagnostics, generateDebugInfo);
return(bodyWithoutAsync);
}
