source: stable/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Parser/mcs/async.cs

//
// async.cs: Asynchronous functions
//
// Author:
//   Marek Safar (marek.safar@gmail.com)
//
// Dual licensed under the terms of the MIT X11 or GNU GPL
//
// Copyright 2011 Novell, Inc.
// Copyright 2011-2012 Xamarin Inc.
//

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;

#if STATIC
using IKVM.Reflection;
using IKVM.Reflection.Emit;
#else
using System.Reflection;
using System.Reflection.Emit;
#endif

namespace Mono.CSharp
{
  public class Await : ExpressionStatement
  {
    Expression expr;
    AwaitStatement stmt;
    
    public Expression Expression {
      get {
        return expr;
      }
    }
    
    public Await (Expression expr, Location loc)
    {
      this.expr = expr;
      this.loc = loc;
    }

    public Expression Expr {
      get {
        return expr;
      }
    }

    public AwaitStatement Statement {
      get {
        return stmt;
      }
    }

    protected override void CloneTo (CloneContext clonectx, Expression target)
    {
      var t = (Await) target;

      t.expr = expr.Clone (clonectx);
    }

    public override Expression CreateExpressionTree (ResolveContext ec)
    {
      throw new NotImplementedException ("ET");
    }

    public override bool ContainsEmitWithAwait ()
    {
      return true;
    }

    public override void FlowAnalysis (FlowAnalysisContext fc)
    {
      stmt.Expr.FlowAnalysis (fc);

      stmt.RegisterResumePoint ();
    }

    protected override Expression DoResolve (ResolveContext rc)
    {
      if (rc.HasSet (ResolveContext.Options.LockScope)) {
        rc.Report.Error (1996, loc,
          "The `await' operator cannot be used in the body of a lock statement");
      }

      if (rc.IsUnsafe) {
        rc.Report.Error (4004, loc,
          "The `await' operator cannot be used in an unsafe context");
      }

      var bc = (BlockContext) rc;

      stmt = new AwaitStatement (expr, loc);
      if (!stmt.Resolve (bc))
        return null;

      type = stmt.ResultType;
      eclass = ExprClass.Variable;
      return this;
    }

    public override void Emit (EmitContext ec)
    {
      stmt.EmitPrologue (ec);

      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        stmt.Emit (ec);
      }
    }
    
    public override Expression EmitToField (EmitContext ec)
    {
      stmt.EmitPrologue (ec);
      return stmt.GetResultExpression (ec);
    }
    
    public void EmitAssign (EmitContext ec, FieldExpr field)
    {
      stmt.EmitPrologue (ec);
      field.InstanceExpression.Emit (ec);
      stmt.Emit (ec);
    }

    public override void EmitStatement (EmitContext ec)
    {
      stmt.EmitStatement (ec);
    }

    public override void MarkReachable (Reachability rc)
    {
      base.MarkReachable (rc);
      stmt.MarkReachable (rc);
    }

    public override object Accept (StructuralVisitor visitor)
    {
      return visitor.Visit (this);
    }
  }

  public class AwaitStatement : YieldStatement<AsyncInitializer>
  {
    public sealed class AwaitableMemberAccess : MemberAccess
    {
      public AwaitableMemberAccess (Expression expr)
        : base (expr, "GetAwaiter")
      {
      }

      public bool ProbingMode { get; set; }

      protected override void Error_TypeDoesNotContainDefinition (ResolveContext rc, TypeSpec type, string name)
      {
        Error_OperatorCannotBeApplied (rc, type);
      }

      protected override void Error_OperatorCannotBeApplied (ResolveContext rc, TypeSpec type)
      {
        if (ProbingMode)
          return;

        var invocation = LeftExpression as Invocation;
        if (invocation != null && invocation.MethodGroup != null && (invocation.MethodGroup.BestCandidate.Modifiers & Modifiers.ASYNC) != 0) {
          rc.Report.Error (4008, loc, "Cannot await void method `{0}'. Consider changing method return type to `Task'",
            invocation.GetSignatureForError ());
        } else {
          rc.Report.Error (4001, loc, "Cannot await `{0}' expression", type.GetSignatureForError ());
        }
      }
    }

    sealed class GetResultInvocation : Invocation
    {
      public GetResultInvocation (MethodGroupExpr mge, Arguments arguments)
        : base (null, arguments)
      {
        mg = mge;
        type = mg.BestCandidateReturnType;
      }

      public override Expression EmitToField (EmitContext ec)
      {
        return this;
      }
    }

    Field awaiter;
    AwaiterDefinition awaiter_definition;
    TypeSpec type;
    TypeSpec result_type;

    public AwaitStatement (Expression expr, Location loc)
      : base (expr, loc)
    {
      unwind_protect = true;
    }

    #region Properties

    bool IsDynamic {
      get {
        return awaiter_definition == null;
      }
    }

    public TypeSpec ResultType {
      get {
        return result_type;
      }
    }

    #endregion

    protected override void DoEmit (EmitContext ec)
    {
      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        GetResultExpression (ec).Emit (ec);
      }
    }

    public Expression GetResultExpression (EmitContext ec)
    {
      var fe_awaiter = new FieldExpr (awaiter, loc);
      fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);

      //
      // result = awaiter.GetResult ();
      //
      if (IsDynamic) {
        var rc = new ResolveContext (ec.MemberContext);
        return new Invocation (new MemberAccess (fe_awaiter, "GetResult"), new Arguments (0)).Resolve (rc);
      }
      
      var mg_result = MethodGroupExpr.CreatePredefined (awaiter_definition.GetResult, fe_awaiter.Type, loc);
      mg_result.InstanceExpression = fe_awaiter;

      return new GetResultInvocation (mg_result, new Arguments (0));
    }

    public void EmitPrologue (EmitContext ec)
    {
      awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (expr.Type);

      var fe_awaiter = new FieldExpr (awaiter, loc);
      fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);

      Label skip_continuation = ec.DefineLabel ();

      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        //
        // awaiter = expr.GetAwaiter ();
        //
        fe_awaiter.EmitAssign (ec, expr, false, false);

        Expression completed_expr;
        if (IsDynamic) {
          var rc = new ResolveContext (ec.MemberContext);

          Arguments dargs = new Arguments (1);
          dargs.Add (new Argument (fe_awaiter));
          completed_expr = new DynamicMemberBinder ("IsCompleted", dargs, loc).Resolve (rc);

          dargs = new Arguments (1);
          dargs.Add (new Argument (completed_expr));
          completed_expr = new DynamicConversion (ec.Module.Compiler.BuiltinTypes.Bool, 0, dargs, loc).Resolve (rc);
        } else {
          var pe = PropertyExpr.CreatePredefined (awaiter_definition.IsCompleted, loc);
          pe.InstanceExpression = fe_awaiter;
          completed_expr = pe;
        }

        completed_expr.EmitBranchable (ec, skip_continuation, true);
      }

      base.DoEmit (ec);

      //
      // The stack has to be empty before calling await continuation. We handle this
      // by lifting values which would be left on stack into class fields. The process
      // is quite complicated and quite hard to test because any expression can possibly
      // leave a value on the stack.
      //
      // Following assert fails when some of expression called before is missing EmitToField
      // or parent expression fails to find await in children expressions
      //
      ec.AssertEmptyStack ();

      var storey = (AsyncTaskStorey) machine_initializer.Storey;
      if (IsDynamic) {
        storey.EmitAwaitOnCompletedDynamic (ec, fe_awaiter);
      } else {
        storey.EmitAwaitOnCompleted (ec, fe_awaiter);
      }

      // Return ok
      machine_initializer.EmitLeave (ec, unwind_protect);

      ec.MarkLabel (resume_point);
      ec.MarkLabel (skip_continuation);
    }

    public void EmitStatement (EmitContext ec)
    {
      EmitPrologue (ec);
      DoEmit (ec);

      awaiter.IsAvailableForReuse = true;

      if (ResultType.Kind != MemberKind.Void)
        ec.Emit (OpCodes.Pop);
    }

    void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter)
    {
      rc.Report.Error (4011, loc, "The awaiter type `{0}' must have suitable IsCompleted and GetResult members",
        awaiter.GetSignatureForError ());
    }

    public override bool Resolve (BlockContext bc)
    {
      if (bc.CurrentBlock is Linq.QueryBlock) {
        bc.Report.Error (1995, loc,
          "The `await' operator may only be used in a query expression within the first collection expression of the initial `from' clause or within the collection expression of a `join' clause");
        return false;
      }

      if (!base.Resolve (bc))
        return false;

      type = expr.Type;
      Arguments args = new Arguments (0);

      //
      // The await expression is of dynamic type
      //
      if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
        result_type = type;
        expr = new Invocation (new MemberAccess (expr, "GetAwaiter"), args).Resolve (bc);
        return true;
      }

      //
      // Check whether the expression is awaitable
      //
      Expression ama = new AwaitableMemberAccess (expr).Resolve (bc);
      if (ama == null)
        return false;

      var errors_printer = new SessionReportPrinter ();
      var old = bc.Report.SetPrinter (errors_printer);
      ama = new Invocation (ama, args).Resolve (bc);
      bc.Report.SetPrinter (old);

      if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression (ama.Type)) {
        bc.Report.Error (1986, expr.Location,
          "The `await' operand type `{0}' must have suitable GetAwaiter method",
          expr.Type.GetSignatureForError ());

        return false;
      }

      var awaiter_type = ama.Type;

      awaiter_definition = bc.Module.GetAwaiter (awaiter_type);

      if (!awaiter_definition.IsValidPattern) {
        Error_WrongAwaiterPattern (bc, awaiter_type);
        return false;
      }

      if (!awaiter_definition.INotifyCompletion) {
        bc.Report.Error (4027, loc, "The awaiter type `{0}' must implement interface `{1}'",
          awaiter_type.GetSignatureForError (), bc.Module.PredefinedTypes.INotifyCompletion.GetSignatureForError ());
        return false;
      }

      expr = ama;
      result_type = awaiter_definition.GetResult.ReturnType;

      return true;
    }
  }

  class AsyncInitializerStatement : StatementExpression
  {
    public AsyncInitializerStatement (AsyncInitializer expr)
      : base (expr)
    {
    }

    protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
    {
      base.DoFlowAnalysis (fc);

      var init = (AsyncInitializer) Expr;
      var res = !init.Block.HasReachableClosingBrace;
      var storey = (AsyncTaskStorey) init.Storey;

      if (storey.ReturnType.IsGenericTask)
        return res;

      return true;
    }

    public override Reachability MarkReachable (Reachability rc)
    {
      if (!rc.IsUnreachable)
        reachable = true;

      var init = (AsyncInitializer) Expr;
      rc = init.Block.MarkReachable (rc);

      var storey = (AsyncTaskStorey) init.Storey;

      //
      // Explicit return is required for Task<T> state machine
      //
      if (storey.ReturnType != null && storey.ReturnType.IsGenericTask)
        return rc;

        return Reachability.CreateUnreachable ();
    }
  }

  public class AsyncInitializer : StateMachineInitializer
  {
    TypeInferenceContext return_inference;

    public AsyncInitializer (ParametersBlock block, TypeDefinition host, TypeSpec returnType)
      : base (block, host, returnType)
    {
    }

    #region Properties

    public override string ContainerType {
      get {
        return "async state machine block";
      }
    }

    public TypeSpec DelegateType {
      get; set;
    }

    public StackFieldExpr HoistedReturnState {
      get; set;
    }

    public override bool IsIterator {
      get {
        return false;
      }
    }

    public TypeInferenceContext ReturnTypeInference {
      get {
        return return_inference;
      }
    }

    #endregion

    protected override BlockContext CreateBlockContext (BlockContext bc)
    {
      var ctx = base.CreateBlockContext (bc);
      var am = bc.CurrentAnonymousMethod as AnonymousMethodBody;
      if (am != null)
        return_inference = am.ReturnTypeInference;

      ctx.Set (ResolveContext.Options.TryScope);

      return ctx;
    }

    public override void Emit (EmitContext ec)
    {
      throw new NotImplementedException ();
    }

    public void EmitCatchBlock (EmitContext ec)
    {
      var catch_value = LocalVariable.CreateCompilerGenerated (ec.Module.Compiler.BuiltinTypes.Exception, block, Location);

      ec.BeginCatchBlock (catch_value.Type);
      catch_value.EmitAssign (ec);

      ec.EmitThis ();
      ec.EmitInt ((int) IteratorStorey.State.After);
      ec.Emit (OpCodes.Stfld, storey.PC.Spec);

      ((AsyncTaskStorey) Storey).EmitSetException (ec, new LocalVariableReference (catch_value, Location));

      ec.Emit (OpCodes.Leave, move_next_ok);
      ec.EndExceptionBlock ();

    }

    protected override void EmitMoveNextEpilogue (EmitContext ec)
    {
      var storey = (AsyncTaskStorey) Storey;
      storey.EmitSetResult (ec);
    }

    public override void EmitStatement (EmitContext ec)
    {
      var storey = (AsyncTaskStorey) Storey;
      storey.EmitInitializer (ec);
      ec.Emit (OpCodes.Ret);
    }

    public override void MarkReachable (Reachability rc)
    {
      //
      // Reachability has been done in AsyncInitializerStatement
      //
    }
  }

  class AsyncTaskStorey : StateMachine
  {
    int awaiters;
    Field builder;
    readonly TypeSpec return_type;
    MethodSpec set_result;
    MethodSpec set_exception;
    MethodSpec builder_factory;
    MethodSpec builder_start;
    PropertySpec task;
    int locals_captured;
    Dictionary<TypeSpec, List<Field>> stack_fields;
    Dictionary<TypeSpec, List<Field>> awaiter_fields;

    public AsyncTaskStorey (ParametersBlock block, IMemberContext context, AsyncInitializer initializer, TypeSpec type)
      : base (block, initializer.Host, context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async", MemberKind.Struct)
    {
      return_type = type;
      awaiter_fields = new Dictionary<TypeSpec, List<Field>> ();
    }

    #region Properties

    public Expression HoistedReturnValue { get; set; }

    public TypeSpec ReturnType {
      get {
        return return_type;
      }
    }

    public PropertySpec Task {
      get {
        return task;
      }
    }

    protected override TypeAttributes TypeAttr {
      get {
        return base.TypeAttr & ~TypeAttributes.SequentialLayout;
      }
    }

    #endregion

    public Field AddAwaiter (TypeSpec type)
    {
      if (mutator != null)
        type = mutator.Mutate (type);

      List<Field> existing_fields;
      if (awaiter_fields.TryGetValue (type, out existing_fields)) {
        foreach (var f in existing_fields) {
          if (f.IsAvailableForReuse) {
            f.IsAvailableForReuse = false;
            return f;
          }
        }
      }

      var field = AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, Location), true);
      field.Define ();

      if (existing_fields == null) {
        existing_fields = new List<Field> ();
        awaiter_fields.Add (type, existing_fields);
      }

      existing_fields.Add (field);
      return field;
    }

    public Field AddCapturedLocalVariable (TypeSpec type, bool requiresUninitialized = false)
    {
      if (mutator != null)
        type = mutator.Mutate (type);

      List<Field> existing_fields = null;
      if (stack_fields == null) {
        stack_fields = new Dictionary<TypeSpec, List<Field>> ();
      } else if (stack_fields.TryGetValue (type, out existing_fields) && !requiresUninitialized) {
        foreach (var f in existing_fields) {
          if (f.IsAvailableForReuse) {
            f.IsAvailableForReuse = false;
            return f;
          }
        }
      }

      var field = AddCompilerGeneratedField ("$stack" + locals_captured++.ToString ("X"), new TypeExpression (type, Location), true);
      field.Define ();

      if (existing_fields == null) {
        existing_fields = new List<Field> ();
        stack_fields.Add (type, existing_fields);
      }

      existing_fields.Add (field);

      return field;
    }

    protected override bool DoDefineMembers ()
    {
      PredefinedType builder_type;
      PredefinedMember<MethodSpec> bf;
      PredefinedMember<MethodSpec> bs;
      PredefinedMember<MethodSpec> sr;
      PredefinedMember<MethodSpec> se;
      PredefinedMember<MethodSpec> sm;
      bool has_task_return_type = false;
      var pred_members = Module.PredefinedMembers;

      if (return_type.Kind == MemberKind.Void) {
        builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
        bf = pred_members.AsyncVoidMethodBuilderCreate;
        bs = pred_members.AsyncVoidMethodBuilderStart;
        sr = pred_members.AsyncVoidMethodBuilderSetResult;
        se = pred_members.AsyncVoidMethodBuilderSetException;
        sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
      } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
        builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
        bf = pred_members.AsyncTaskMethodBuilderCreate;
        bs = pred_members.AsyncTaskMethodBuilderStart;
        sr = pred_members.AsyncTaskMethodBuilderSetResult;
        se = pred_members.AsyncTaskMethodBuilderSetException;
        sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
        task = pred_members.AsyncTaskMethodBuilderTask.Get ();
      } else {
        builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
        bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
        bs = pred_members.AsyncTaskMethodBuilderGenericStart;
        sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
        se = pred_members.AsyncTaskMethodBuilderGenericSetException;
        sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
        task = pred_members.AsyncTaskMethodBuilderGenericTask.Get ();
        has_task_return_type = true;
      }

      set_result = sr.Get ();
      set_exception = se.Get ();
      builder_factory = bf.Get ();
      builder_start = bs.Get ();

      var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
      var set_statemachine = sm.Get ();

      if (!builder_type.Define () || !istate_machine.Define () || set_result == null || builder_factory == null ||
        set_exception == null || set_statemachine == null || builder_start == null ||
        !Module.PredefinedTypes.INotifyCompletion.Define ()) {
        Report.Error (1993, Location,
          "Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
        return base.DoDefineMembers ();
      }

      var bt = builder_type.TypeSpec;

      //
      // Inflate generic Task types
      //
      if (has_task_return_type) {
        var task_return_type = return_type.TypeArguments;
        if (mutator != null)
          task_return_type = mutator.Mutate (task_return_type);

        bt = bt.MakeGenericType (Module, task_return_type);
        set_result = MemberCache.GetMember (bt, set_result);
        set_exception = MemberCache.GetMember (bt, set_exception);
        set_statemachine = MemberCache.GetMember (bt, set_statemachine);

        if (task != null)
          task = MemberCache.GetMember (bt, task);
      }

      builder = AddCompilerGeneratedField ("$builder", new TypeExpression (bt, Location));

      var set_state_machine = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Void, Location),
        Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
        new MemberName ("SetStateMachine"),
        ParametersCompiled.CreateFullyResolved (
          new Parameter (new TypeExpression (istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
          istate_machine.TypeSpec),
        null);

      ToplevelBlock block = new ToplevelBlock (Compiler, set_state_machine.ParameterInfo, Location);
      block.IsCompilerGenerated = true;
      set_state_machine.Block = block;

      Members.Add (set_state_machine);

      if (!base.DoDefineMembers ())
        return false;

      //
      // Fabricates SetStateMachine method
      //
      // public void SetStateMachine (IAsyncStateMachine stateMachine)
      // {
      //    $builder.SetStateMachine (stateMachine);
      // }
      //
      var mg = MethodGroupExpr.CreatePredefined (set_statemachine, bt, Location);
      mg.InstanceExpression = new FieldExpr (builder, Location);

      var param_reference = block.GetParameterReference (0, Location);
      param_reference.Type = istate_machine.TypeSpec;
      param_reference.eclass = ExprClass.Variable;

      var args = new Arguments (1);
      args.Add (new Argument (param_reference));
      set_state_machine.Block.AddStatement (new StatementExpression (new Invocation (mg, args)));

      if (has_task_return_type) {
        HoistedReturnValue = TemporaryVariableReference.Create (bt.TypeArguments [0], StateMachineMethod.Block, Location);
      }

      return true;
    }

    public void EmitAwaitOnCompletedDynamic (EmitContext ec, FieldExpr awaiter)
    {
      var critical = Module.PredefinedTypes.ICriticalNotifyCompletion;
      if (!critical.Define ()) {
        throw new NotImplementedException ();
      }

      var temp_critical = new LocalTemporary (critical.TypeSpec);
      var label_critical = ec.DefineLabel ();
      var label_end = ec.DefineLabel ();

      //
      // Special path for dynamic awaiters
      //
      // var awaiter = this.$awaiter as ICriticalNotifyCompletion;
      // if (awaiter == null) {
      //    var completion = (INotifyCompletion) this.$awaiter;
      //    this.$builder.AwaitOnCompleted (ref completion, ref this);
      // } else {
      //    this.$builder.AwaitUnsafeOnCompleted (ref awaiter, ref this);
      // }
      //
      awaiter.Emit (ec);
      ec.Emit (OpCodes.Isinst, critical.TypeSpec);
      temp_critical.Store (ec);
      temp_critical.Emit (ec);
      ec.Emit (OpCodes.Brtrue_S, label_critical);

      var temp = new LocalTemporary (Module.PredefinedTypes.INotifyCompletion.TypeSpec);
      awaiter.Emit (ec);
      ec.Emit (OpCodes.Castclass, temp.Type);
      temp.Store (ec);
      EmitOnCompleted (ec, temp, false);
      temp.Release (ec);
      ec.Emit (OpCodes.Br_S, label_end);

      ec.MarkLabel (label_critical);

      EmitOnCompleted (ec, temp_critical, true);

      ec.MarkLabel (label_end);

      temp_critical.Release (ec);
    }

    public void EmitAwaitOnCompleted (EmitContext ec, FieldExpr awaiter)
    {
      bool unsafe_version = false;
      if (Module.PredefinedTypes.ICriticalNotifyCompletion.Define ()) {
        unsafe_version = awaiter.Type.ImplementsInterface (Module.PredefinedTypes.ICriticalNotifyCompletion.TypeSpec, false);
      }

      EmitOnCompleted (ec, awaiter, unsafe_version);
    }

    void EmitOnCompleted (EmitContext ec, Expression awaiter, bool unsafeVersion)
    {
      var pm = Module.PredefinedMembers;
      PredefinedMember<MethodSpec> predefined;
      bool has_task_return_type = false;
      if (return_type.Kind == MemberKind.Void) {
        predefined = unsafeVersion ? pm.AsyncVoidMethodBuilderOnCompletedUnsafe : pm.AsyncVoidMethodBuilderOnCompleted;
      } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
        predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderOnCompletedUnsafe : pm.AsyncTaskMethodBuilderOnCompleted;
      } else {
        predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderGenericOnCompletedUnsafe : pm.AsyncTaskMethodBuilderGenericOnCompleted;
        has_task_return_type = true;
      }

      var on_completed = predefined.Resolve (Location);
      if (on_completed == null)
        return;

      if (has_task_return_type)
        on_completed = MemberCache.GetMember<MethodSpec> (set_result.DeclaringType, on_completed);

      on_completed = on_completed.MakeGenericMethod (this, awaiter.Type, ec.CurrentType);

      var mg = MethodGroupExpr.CreatePredefined (on_completed, on_completed.DeclaringType, Location);
      mg.InstanceExpression = new FieldExpr (builder, Location) {
        InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
      };

      var args = new Arguments (2);
      args.Add (new Argument (awaiter, Argument.AType.Ref));
      args.Add (new Argument (new CompilerGeneratedThis (CurrentType, Location), Argument.AType.Ref));
      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        mg.EmitCall (ec, args, true);
      }
    }

    public void EmitInitializer (EmitContext ec)
    {
      //
      // Some predefined types are missing
      //
      if (builder == null)
        return;

      var instance = (TemporaryVariableReference) Instance;
      var builder_field = builder.Spec;
      if (MemberName.Arity > 0) {
        builder_field = MemberCache.GetMember (instance.Type, builder_field);
      }

      //
      // Inflated factory method when task is of generic type
      //
      if (builder_factory.DeclaringType.IsGeneric) {
        var task_return_type = return_type.TypeArguments;
        var bt = builder_factory.DeclaringType.MakeGenericType (Module, task_return_type);
        builder_factory = MemberCache.GetMember (bt, builder_factory);
        builder_start = MemberCache.GetMember (bt, builder_start);
      }

      //
      // stateMachine.$builder = AsyncTaskMethodBuilder<{task-type}>.Create();
      //
      instance.AddressOf (ec, AddressOp.Store);
      ec.Emit (OpCodes.Call, builder_factory);
      ec.Emit (OpCodes.Stfld, builder_field);

      //
      // stateMachine.$builder.Start<{storey-type}>(ref stateMachine);
      //
      instance.AddressOf (ec, AddressOp.Store);
      ec.Emit (OpCodes.Ldflda, builder_field);
      if (Task != null)
        ec.Emit (OpCodes.Dup);
      instance.AddressOf (ec, AddressOp.Store);
      ec.Emit (OpCodes.Call, builder_start.MakeGenericMethod (Module, instance.Type));

      //
      // Emits return stateMachine.$builder.Task;
      //
      if (Task != null) {
        var task_get = Task.Get;

        if (MemberName.Arity > 0) {
          task_get = MemberCache.GetMember (builder_field.MemberType, task_get);
        }

        var pe_task = new PropertyExpr (Task, Location) {
          InstanceExpression = EmptyExpression.Null,  // Comes from the dup above
          Getter = task_get
        };

        pe_task.Emit (ec);
      }
    }

    public void EmitSetException (EmitContext ec, LocalVariableReference exceptionVariable)
    {
      //
      // $builder.SetException (Exception)
      //
      var mg = MethodGroupExpr.CreatePredefined (set_exception, set_exception.DeclaringType, Location);
      mg.InstanceExpression = new FieldExpr (builder, Location) {
        InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
      };

      Arguments args = new Arguments (1);
      args.Add (new Argument (exceptionVariable));

      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        mg.EmitCall (ec, args, true);
      }
    }

    public void EmitSetResult (EmitContext ec)
    {
      //
      // $builder.SetResult ();
      // $builder.SetResult<return-type> (value);
      //
      var mg = MethodGroupExpr.CreatePredefined (set_result, set_result.DeclaringType, Location);
      mg.InstanceExpression = new FieldExpr (builder, Location) {
        InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
      };

      Arguments args;
      if (HoistedReturnValue == null) {
        args = new Arguments (0);
      } else {
        args = new Arguments (1);
        args.Add (new Argument (HoistedReturnValue));
      }

      using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
        mg.EmitCall (ec, args, true);
      }
    }

    protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
    {
      base_type = Compiler.BuiltinTypes.ValueType;
      base_class = null;

      var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
      if (istate_machine.Define ()) {
        return new[] { istate_machine.TypeSpec };
      }

      return null;
    }
  }

  public class StackFieldExpr : FieldExpr, IExpressionCleanup
  {
    public StackFieldExpr (Field field)
      : base (field, Location.Null)
    {
    }

    public bool IsAvailableForReuse {
      get {
        var field = (Field) spec.MemberDefinition;
        return field.IsAvailableForReuse;
      }
      set {
        var field = (Field) spec.MemberDefinition;
        field.IsAvailableForReuse = value;
      }
    }

    public override void AddressOf (EmitContext ec, AddressOp mode)
    {
      base.AddressOf (ec, mode);

      if (mode == AddressOp.Load) {
        IsAvailableForReuse = true;
      }
    }

    public override void Emit (EmitContext ec)
    {
      base.Emit (ec);

      PrepareCleanup (ec);
    }

    public void EmitLoad (EmitContext ec)
    {
      base.Emit (ec);
    }

    public void PrepareCleanup (EmitContext ec)
    {
      IsAvailableForReuse = true;

      //
      // Release any captured reference type stack variables
      // to imitate real stack behavour and help GC stuff early
      //
      if (TypeSpec.IsReferenceType (type)) {
        ec.AddStatementEpilog (this);
      }
    }

    void IExpressionCleanup.EmitCleanup (EmitContext ec)
    {
      EmitAssign (ec, new NullConstant (type, loc), false, false);
    }
  }
}