private void EnsureAsyncBuilder(Method method, List<Block> contractInitializationBlocks, Dictionary<TypeNode, Local> closureLocals, ref EmitAsyncClosure asyncBuilder)
{
if (asyncBuilder == null)
{
// create a wrapper
asyncBuilder = new EmitAsyncClosure(method, this);
contractInitializationBlocks.Add(asyncBuilder.ClosureInitializer);
closureLocals.Add(asyncBuilder.ClosureClass, asyncBuilder.ClosureLocal);
}
}
private void HandleContractResultErrors(EmitAsyncClosure asyncClosure)
{
if (asyncClosure == null)
{
return;
}
foreach (var context in asyncClosure.ContractResultCapturedInStaticContext)
{
this.HandleError(CreateContractResultWasCapturedInStaticContextWarning(context));
}
}
private void RecordEnsures(
Method method,
ref int oldLocalUniqueNameCounter,
List<Block> contractInitializationBlocks,
Dictionary<TypeNode, Local> closureLocals,
Block oldExpressionPreStateValues,
List<Ensures> postconditions,
List<Ensures> asyncPostconditions,
WrapParametersInOldExpressions wrap,
ref EmitAsyncClosure asyncBuilder,
MethodContract mc)
{
RewriteHelper.RecordClosureInitialization(method, mc.ContractInitializer, closureLocals);
if (this.Emit(RuntimeContractEmitFlags.Ensures) && mc.Ensures != null)
{
mc.Ensures = wrap.VisitEnsuresList(mc.Ensures);
Block oldInits = ProcessOldExpressions(method, mc.Ensures, closureLocals, ref oldLocalUniqueNameCounter);
if (oldInits != null)
{
oldExpressionPreStateValues.Statements.Add(oldInits);
}
if (mc.Ensures != null)
{
foreach (Ensures ensures in mc.Ensures)
{
if (!EmitEnsures(ensures, method.DeclaringType, this.skipQuantifiers)) continue;
postconditions.Add(ensures);
}
}
}
if (this.Emit(RuntimeContractEmitFlags.AsyncEnsures) && mc.AsyncEnsuresCount > 0)
{
mc.AsyncEnsures = wrap.VisitEnsuresList(mc.AsyncEnsures);
var found = false;
foreach (Ensures postcondition in mc.AsyncEnsures)
{
if (!EmitEnsures(postcondition, method.DeclaringType, this.skipQuantifiers) || asyncPostconditions.Contains(postcondition)) continue;
EnsureAsyncBuilder(method, contractInitializationBlocks, closureLocals, ref asyncBuilder);
found = true;
asyncPostconditions.Add(postcondition);
}
if (found)
{
Block oldInit = ProcessOldExpressionsInAsync(method, mc.AsyncEnsures, closureLocals, ref oldLocalUniqueNameCounter, asyncBuilder.ClosureClass);
if (oldInit != null && oldInit.Statements != null && oldInit.Statements.Count > 0)
{
oldExpressionPreStateValues.Statements.Add(oldInit);
}
}
}
}
public FieldRewriter(EmitAsyncClosure closure)
{
this.closure = closure;
}
