mcs/mcs/async.cs

   1 //
   2 // async.cs: Asynchronous functions
   3 //
   4 // Author:
   5 //   Marek Safar (marek.safar@gmail.com)
   6 //
   7 // Dual licensed under the terms of the MIT X11 or GNU GPL
   8 //
   9 // Copyright 2011 Novell, Inc.
  10 // Copyright 2011-2012 Xamarin Inc.
  11 //
  12
  13 using System;
  14 using System.Collections.Generic;
  15 using System.Linq;
  16 using System.Collections;
  17
  18 #if STATIC
  19 using IKVM.Reflection;
  20 using IKVM.Reflection.Emit;
  21 #else
  22 using System.Reflection;
  23 using System.Reflection.Emit;
  24 #endif
  25
  26 namespace Mono.CSharp
  27 {
  28         public class Await : ExpressionStatement
  29         {
  30                 Expression expr;
  31                 AwaitStatement stmt;
  32
  33                 public Await (Expression expr, Location loc)
  34                 {
  35                         this.expr = expr;
  36                         this.loc = loc;
  37                 }
  38
  39                 public Expression Expr {
  40                         get {
  41                                 return expr;
  42                         }
  43                 }
  44
  45                 public AwaitStatement Statement {
  46                         get {
  47                                 return stmt;
  48                         }
  49                 }
  50
  51                 protected override void CloneTo (CloneContext clonectx, Expression target)
  52                 {
  53                         var t = (Await) target;
  54
  55                         t.expr = expr.Clone (clonectx);
  56                 }
  57
  58                 public override Expression CreateExpressionTree (ResolveContext ec)
  59                 {
  60                         throw new NotImplementedException ("ET");
  61                 }
  62
  63                 public override bool ContainsEmitWithAwait ()
  64                 {
  65                         return true;
  66                 }
  67
  68                 public override void FlowAnalysis (FlowAnalysisContext fc)
  69                 {
  70                         stmt.Expr.FlowAnalysis (fc);
  71
  72                         stmt.RegisterResumePoint ();
  73                 }
  74
  75                 protected override Expression DoResolve (ResolveContext rc)
  76                 {
  77                         if (rc.HasSet (ResolveContext.Options.LockScope)) {
  78                                 rc.Report.Error (1996, loc,
  79                                         "The `await' operator cannot be used in the body of a lock statement");
  80                         }
  81
  82                         if (rc.IsUnsafe) {
  83                                 rc.Report.Error (4004, loc,
  84                                         "The `await' operator cannot be used in an unsafe context");
  85                         }
  86
  87                         var bc = (BlockContext) rc;
  88
  89                         stmt = new AwaitStatement (expr, loc);
  90                         if (!stmt.Resolve (bc))
  91                                 return null;
  92
  93                         if (rc.HasSet (ResolveContext.Options.FinallyScope) && rc.CurrentAnonymousMethod != null) {
  94                                 var ats = (AsyncTaskStorey)rc.CurrentAnonymousMethod.Storey;
  95                                 ats.HasAwaitInsideFinally = true;
  96                         }
  97
  98                         type = stmt.ResultType;
  99                         eclass = ExprClass.Variable;
 100                         return this;
 101                 }
 102
 103                 public override void Emit (EmitContext ec)
 104                 {
 105                         stmt.EmitPrologue (ec);
 106
 107                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 108                                 stmt.Emit (ec);
 109                         }
 110                 }
 111
 112                 public override Expression EmitToField (EmitContext ec)
 113                 {
 114                         stmt.EmitPrologue (ec);
 115                         return stmt.GetResultExpression (ec);
 116                 }
 117
 118                 public void EmitAssign (EmitContext ec, FieldExpr field)
 119                 {
 120                         stmt.EmitPrologue (ec);
 121                         field.InstanceExpression.Emit (ec);
 122                         stmt.Emit (ec);
 123                 }
 124
 125                 public override void EmitStatement (EmitContext ec)
 126                 {
 127                         stmt.EmitStatement (ec);
 128                 }
 129
 130                 public override void MarkReachable (Reachability rc)
 131                 {
 132                         base.MarkReachable (rc);
 133                         stmt.MarkReachable (rc);
 134                 }
 135
 136                 public override object Accept (StructuralVisitor visitor)
 137                 {
 138                         return visitor.Visit (this);
 139                 }
 140         }
 141
 142         public class AwaitStatement : YieldStatement<AsyncInitializer>
 143         {
 144                 public sealed class AwaitableMemberAccess : MemberAccess
 145                 {
 146                         public AwaitableMemberAccess (Expression expr)
 147                                 : base (expr, "GetAwaiter")
 148                         {
 149                         }
 150
 151                         public bool ProbingMode { get; set; }
 152
 153                         public override void Error_TypeDoesNotContainDefinition (ResolveContext rc, TypeSpec type, string name)
 154                         {
 155                                 Error_OperatorCannotBeApplied (rc, type);
 156                         }
 157
 158                         protected override void Error_OperatorCannotBeApplied (ResolveContext rc, TypeSpec type)
 159                         {
 160                                 if (ProbingMode)
 161                                         return;
 162
 163                                 var invocation = LeftExpression as Invocation;
 164                                 if (invocation != null && invocation.MethodGroup != null && (invocation.MethodGroup.BestCandidate.Modifiers & Modifiers.ASYNC) != 0) {
 165                                         rc.Report.Error (4008, loc, "Cannot await void method `{0}'. Consider changing method return type to `Task'",
 166                                                 invocation.GetSignatureForError ());
 167                                 } else if (type != InternalType.ErrorType) {
 168                                         rc.Report.Error (4001, loc, "Cannot await `{0}' expression", type.GetSignatureForError ());
 169                                 }
 170                         }
 171                 }
 172
 173                 sealed class GetResultInvocation : Invocation
 174                 {
 175                         public GetResultInvocation (MethodGroupExpr mge, Arguments arguments)
 176                                 : base (null, arguments)
 177                         {
 178                                 mg = mge;
 179                                 type = mg.BestCandidateReturnType;
 180                         }
 181
 182                         public override Expression EmitToField (EmitContext ec)
 183                         {
 184                                 return this;
 185                         }
 186                 }
 187
 188                 Field awaiter;
 189                 AwaiterDefinition awaiter_definition;
 190                 TypeSpec type;
 191                 TypeSpec result_type;
 192
 193                 public AwaitStatement (Expression expr, Location loc)
 194                         : base (expr, loc)
 195                 {
 196                         unwind_protect = true;
 197                 }
 198
 199                 #region Properties
 200
 201                 bool IsDynamic {
 202                         get {
 203                                 return awaiter_definition == null;
 204                         }
 205                 }
 206
 207                 public TypeSpec ResultType {
 208                         get {
 209                                 return result_type;
 210                         }
 211                 }
 212
 213                 #endregion
 214
 215                 protected override void DoEmit (EmitContext ec)
 216                 {
 217                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 218                                 GetResultExpression (ec).Emit (ec);
 219                         }
 220                 }
 221
 222                 public Expression GetResultExpression (EmitContext ec)
 223                 {
 224                         var fe_awaiter = new FieldExpr (awaiter, loc);
 225                         fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
 226
 227                         //
 228                         // result = awaiter.GetResult ();
 229                         //
 230                         if (IsDynamic) {
 231                                 var rc = new ResolveContext (ec.MemberContext);
 232                                 return new Invocation (new MemberAccess (fe_awaiter, "GetResult"), new Arguments (0)).Resolve (rc);
 233                         }
 234
 235                         var mg_result = MethodGroupExpr.CreatePredefined (awaiter_definition.GetResult, fe_awaiter.Type, loc);
 236                         mg_result.InstanceExpression = fe_awaiter;
 237
 238                         return new GetResultInvocation (mg_result, new Arguments (0));
 239                 }
 240
 241                 public void EmitPrologue (EmitContext ec)
 242                 {
 243                         awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (expr.Type);
 244
 245                         var fe_awaiter = new FieldExpr (awaiter, loc);
 246                         fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
 247
 248                         Label skip_continuation = ec.DefineLabel ();
 249
 250                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 251                                 //
 252                                 // awaiter = expr.GetAwaiter ();
 253                                 //
 254                                 fe_awaiter.EmitAssign (ec, expr, false, false);
 255
 256                                 Expression completed_expr;
 257                                 if (IsDynamic) {
 258                                         var rc = new ResolveContext (ec.MemberContext);
 259
 260                                         Arguments dargs = new Arguments (1);
 261                                         dargs.Add (new Argument (fe_awaiter));
 262                                         completed_expr = new DynamicMemberBinder ("IsCompleted", dargs, loc).Resolve (rc);
 263
 264                                         dargs = new Arguments (1);
 265                                         dargs.Add (new Argument (completed_expr));
 266                                         completed_expr = new DynamicConversion (ec.Module.Compiler.BuiltinTypes.Bool, 0, dargs, loc).Resolve (rc);
 267                                 } else {
 268                                         var pe = PropertyExpr.CreatePredefined (awaiter_definition.IsCompleted, loc);
 269                                         pe.InstanceExpression = fe_awaiter;
 270                                         completed_expr = pe;
 271                                 }
 272
 273                                 completed_expr.EmitBranchable (ec, skip_continuation, true);
 274                         }
 275
 276                         base.DoEmit (ec);
 277
 278                         //
 279                         // The stack has to be empty before calling await continuation. We handle this
 280                         // by lifting values which would be left on stack into class fields. The process
 281                         // is quite complicated and quite hard to test because any expression can possibly
 282                         // leave a value on the stack.
 283                         //
 284                         // Following assert fails when some of expression called before is missing EmitToField
 285                         // or parent expression fails to find await in children expressions
 286                         //
 287                         ec.AssertEmptyStack ();
 288
 289                         var storey = (AsyncTaskStorey) machine_initializer.Storey;
 290                         if (IsDynamic) {
 291                                 storey.EmitAwaitOnCompletedDynamic (ec, fe_awaiter);
 292                         } else {
 293                                 storey.EmitAwaitOnCompleted (ec, fe_awaiter);
 294                         }
 295
 296                         // Return ok
 297                         machine_initializer.EmitLeave (ec, unwind_protect);
 298
 299                         ec.MarkLabel (resume_point);
 300                         ec.MarkLabel (skip_continuation);
 301                 }
 302
 303                 public void EmitStatement (EmitContext ec)
 304                 {
 305                         EmitPrologue (ec);
 306                         DoEmit (ec);
 307
 308                         awaiter.IsAvailableForReuse = true;
 309
 310                         if (ResultType.Kind != MemberKind.Void)
 311                                 ec.Emit (OpCodes.Pop);
 312                 }
 313
 314                 void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter)
 315                 {
 316                         rc.Report.Error (4011, loc, "The awaiter type `{0}' must have suitable IsCompleted and GetResult members",
 317                                 awaiter.GetSignatureForError ());
 318                 }
 319
 320                 public override bool Resolve (BlockContext bc)
 321                 {
 322                         if (bc.CurrentBlock is Linq.QueryBlock) {
 323                                 bc.Report.Error (1995, loc,
 324                                         "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");
 325                                 return false;
 326                         }
 327
 328                         if (!base.Resolve (bc))
 329                                 return false;
 330
 331                         type = expr.Type;
 332                         Arguments args = new Arguments (0);
 333
 334                         //
 335                         // The await expression is of dynamic type
 336                         //
 337                         if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
 338                                 result_type = type;
 339                                 expr = new Invocation (new MemberAccess (expr, "GetAwaiter"), args).Resolve (bc);
 340                                 return true;
 341                         }
 342
 343                         //
 344                         // Check whether the expression is awaitable
 345                         //
 346                         Expression ama = new AwaitableMemberAccess (expr).Resolve (bc);
 347                         if (ama == null)
 348                                 return false;
 349
 350                         var errors_printer = new SessionReportPrinter ();
 351                         var old = bc.Report.SetPrinter (errors_printer);
 352
 353                         //
 354                         // The expression await t is classified the same way as the expression (t).GetAwaiter().GetResult().
 355                         //
 356                         ama = new Invocation (new ParenthesizedExpression (ama, Location.Null), args).Resolve (bc);
 357                         bc.Report.SetPrinter (old);
 358
 359                         if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression (ama.Type)) {
 360                                 bc.Report.Error (1986, expr.Location,
 361                                         "The `await' operand type `{0}' must have suitable GetAwaiter method",
 362                                         expr.Type.GetSignatureForError ());
 363
 364                                 return false;
 365                         }
 366
 367                         var awaiter_type = ama.Type;
 368
 369                         awaiter_definition = bc.Module.GetAwaiter (awaiter_type);
 370
 371                         if (!awaiter_definition.IsValidPattern) {
 372                                 Error_WrongAwaiterPattern (bc, awaiter_type);
 373                                 return false;
 374                         }
 375
 376                         if (!awaiter_definition.INotifyCompletion) {
 377                                 bc.Report.Error (4027, loc, "The awaiter type `{0}' must implement interface `{1}'",
 378                                         awaiter_type.GetSignatureForError (), bc.Module.PredefinedTypes.INotifyCompletion.GetSignatureForError ());
 379                                 return false;
 380                         }
 381
 382                         expr = ama;
 383                         result_type = awaiter_definition.GetResult.ReturnType;
 384
 385                         return true;
 386                 }
 387         }
 388
 389         class AsyncInitializerStatement : StatementExpression
 390         {
 391                 public AsyncInitializerStatement (AsyncInitializer expr)
 392                         : base (expr)
 393                 {
 394                 }
 395
 396                 protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
 397                 {
 398                         base.DoFlowAnalysis (fc);
 399
 400                         var init = (AsyncInitializer) Expr;
 401                         var res = !init.Block.HasReachableClosingBrace;
 402                         var storey = (AsyncTaskStorey) init.Storey;
 403
 404                         if (storey.ReturnType.IsGenericTask)
 405                                 return res;
 406
 407                         return true;
 408                 }
 409
 410                 public override Reachability MarkReachable (Reachability rc)
 411                 {
 412                         if (!rc.IsUnreachable)
 413                                 reachable = true;
 414
 415                         var init = (AsyncInitializer) Expr;
 416                         rc = init.Block.MarkReachable (rc);
 417
 418                         var storey = (AsyncTaskStorey) init.Storey;
 419
 420                         //
 421                         // Explicit return is required for Task<T> state machine
 422                         //
 423                         if (storey.ReturnType != null && storey.ReturnType.IsGenericTask)
 424                                 return rc;
 425
 426                     return Reachability.CreateUnreachable ();
 427                 }
 428         }
 429
 430         public class AsyncInitializer : StateMachineInitializer
 431         {
 432                 TypeInferenceContext return_inference;
 433
 434                 public AsyncInitializer (ParametersBlock block, TypeDefinition host, TypeSpec returnType)
 435                         : base (block, host, returnType)
 436                 {
 437                 }
 438
 439                 #region Properties
 440
 441                 public override string ContainerType {
 442                         get {
 443                                 return "async state machine block";
 444                         }
 445                 }
 446
 447                 public TypeSpec DelegateType {
 448                         get; set;
 449                 }
 450
 451                 public StackFieldExpr HoistedReturnState {
 452                         get; set;
 453                 }
 454
 455                 public override bool IsIterator {
 456                         get {
 457                                 return false;
 458                         }
 459                 }
 460
 461                 public TypeInferenceContext ReturnTypeInference {
 462                         get {
 463                                 return return_inference;
 464                         }
 465                 }
 466
 467                 #endregion
 468
 469                 protected override BlockContext CreateBlockContext (BlockContext bc)
 470                 {
 471                         var ctx = base.CreateBlockContext (bc);
 472                         var am = bc.CurrentAnonymousMethod as AnonymousMethodBody;
 473                         if (am != null)
 474                                 return_inference = am.ReturnTypeInference;
 475
 476                         ctx.Set (ResolveContext.Options.TryScope);
 477
 478                         return ctx;
 479                 }
 480
 481                 public override void Emit (EmitContext ec)
 482                 {
 483                         throw new NotImplementedException ();
 484                 }
 485
 486                 public void EmitCatchBlock (EmitContext ec)
 487                 {
 488                         var catch_value = LocalVariable.CreateCompilerGenerated (ec.Module.Compiler.BuiltinTypes.Exception, block, Location);
 489
 490                         ec.BeginCatchBlock (catch_value.Type);
 491                         catch_value.EmitAssign (ec);
 492
 493                         ec.EmitThis ();
 494                         ec.EmitInt ((int) IteratorStorey.State.After);
 495                         ec.Emit (OpCodes.Stfld, storey.PC.Spec);
 496
 497                         ((AsyncTaskStorey) Storey).EmitSetException (ec, new LocalVariableReference (catch_value, Location));
 498
 499                         ec.Emit (OpCodes.Leave, move_next_ok);
 500                         ec.EndExceptionBlock ();
 501
 502                 }
 503
 504                 protected override void EmitMoveNextEpilogue (EmitContext ec)
 505                 {
 506                         var storey = (AsyncTaskStorey) Storey;
 507                         storey.EmitSetResult (ec);
 508                 }
 509
 510                 public override void EmitStatement (EmitContext ec)
 511                 {
 512                         var storey = (AsyncTaskStorey) Storey;
 513                         storey.EmitInitializer (ec);
 514                         ec.Emit (OpCodes.Ret);
 515                 }
 516
 517                 public override void MarkReachable (Reachability rc)
 518                 {
 519                         //
 520                         // Reachability has been done in AsyncInitializerStatement
 521                         //
 522                 }
 523         }
 524
 525         class AsyncTaskStorey : StateMachine
 526         {
 527                 int awaiters;
 528                 Field builder;
 529                 readonly TypeSpec return_type;
 530                 MethodSpec set_result;
 531                 MethodSpec set_exception;
 532                 MethodSpec builder_factory;
 533                 MethodSpec builder_start;
 534                 PropertySpec task;
 535                 int locals_captured;
 536                 Dictionary<TypeSpec, List<Field>> stack_fields;
 537                 Dictionary<TypeSpec, List<Field>> awaiter_fields;
 538
 539                 public AsyncTaskStorey (ParametersBlock block, IMemberContext context, AsyncInitializer initializer, TypeSpec type)
 540                         : base (block, initializer.Host, context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async", MemberKind.Struct)
 541                 {
 542                         return_type = type;
 543                         awaiter_fields = new Dictionary<TypeSpec, List<Field>> ();
 544                 }
 545
 546                 #region Properties
 547
 548                 public bool HasAwaitInsideFinally { get; set; }
 549
 550                 public Expression HoistedReturnValue { get; set; }
 551
 552                 public TypeSpec ReturnType {
 553                         get {
 554                                 return return_type;
 555                         }
 556                 }
 557
 558                 public PropertySpec Task {
 559                         get {
 560                                 return task;
 561                         }
 562                 }
 563
 564                 protected override TypeAttributes TypeAttr {
 565                         get {
 566                                 return base.TypeAttr & ~TypeAttributes.SequentialLayout;
 567                         }
 568                 }
 569
 570                 #endregion
 571
 572                 public Field AddAwaiter (TypeSpec type)
 573                 {
 574                         if (mutator != null)
 575                                 type = mutator.Mutate (type);
 576
 577                         List<Field> existing_fields;
 578                         if (awaiter_fields.TryGetValue (type, out existing_fields)) {
 579                                 foreach (var f in existing_fields) {
 580                                         if (f.IsAvailableForReuse) {
 581                                                 f.IsAvailableForReuse = false;
 582                                                 return f;
 583                                         }
 584                                 }
 585                         }
 586
 587                         var field = AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, Location), true);
 588                         field.Define ();
 589
 590                         if (existing_fields == null) {
 591                                 existing_fields = new List<Field> ();
 592                                 awaiter_fields.Add (type, existing_fields);
 593                         }
 594
 595                         existing_fields.Add (field);
 596                         return field;
 597                 }
 598
 599                 public Field AddCapturedLocalVariable (TypeSpec type, bool requiresUninitialized = false)
 600                 {
 601                         if (mutator != null)
 602                                 type = mutator.Mutate (type);
 603
 604                         List<Field> existing_fields = null;
 605                         if (stack_fields == null) {
 606                                 stack_fields = new Dictionary<TypeSpec, List<Field>> ();
 607                         } else if (stack_fields.TryGetValue (type, out existing_fields) && !requiresUninitialized) {
 608                                 foreach (var f in existing_fields) {
 609                                         if (f.IsAvailableForReuse) {
 610                                                 f.IsAvailableForReuse = false;
 611                                                 return f;
 612                                         }
 613                                 }
 614                         }
 615
 616                         var field = AddCompilerGeneratedField ("$stack" + locals_captured++.ToString ("X"), new TypeExpression (type, Location), true);
 617                         field.Define ();
 618
 619                         if (existing_fields == null) {
 620                                 existing_fields = new List<Field> ();
 621                                 stack_fields.Add (type, existing_fields);
 622                         }
 623
 624                         existing_fields.Add (field);
 625
 626                         return field;
 627                 }
 628
 629                 protected override bool DoDefineMembers ()
 630                 {
 631                         PredefinedType builder_type;
 632                         PredefinedMember<MethodSpec> bf;
 633                         PredefinedMember<MethodSpec> bs;
 634                         PredefinedMember<MethodSpec> sr;
 635                         PredefinedMember<MethodSpec> se;
 636                         PredefinedMember<MethodSpec> sm;
 637                         bool has_task_return_type = false;
 638                         var pred_members = Module.PredefinedMembers;
 639
 640                         if (return_type.Kind == MemberKind.Void) {
 641                                 builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
 642                                 bf = pred_members.AsyncVoidMethodBuilderCreate;
 643                                 bs = pred_members.AsyncVoidMethodBuilderStart;
 644                                 sr = pred_members.AsyncVoidMethodBuilderSetResult;
 645                                 se = pred_members.AsyncVoidMethodBuilderSetException;
 646                                 sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
 647                         } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
 648                                 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
 649                                 bf = pred_members.AsyncTaskMethodBuilderCreate;
 650                                 bs = pred_members.AsyncTaskMethodBuilderStart;
 651                                 sr = pred_members.AsyncTaskMethodBuilderSetResult;
 652                                 se = pred_members.AsyncTaskMethodBuilderSetException;
 653                                 sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
 654                                 task = pred_members.AsyncTaskMethodBuilderTask.Get ();
 655                         } else {
 656                                 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
 657                                 bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
 658                                 bs = pred_members.AsyncTaskMethodBuilderGenericStart;
 659                                 sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
 660                                 se = pred_members.AsyncTaskMethodBuilderGenericSetException;
 661                                 sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
 662                                 task = pred_members.AsyncTaskMethodBuilderGenericTask.Get ();
 663                                 has_task_return_type = true;
 664                         }
 665
 666                         set_result = sr.Get ();
 667                         set_exception = se.Get ();
 668                         builder_factory = bf.Get ();
 669                         builder_start = bs.Get ();
 670
 671                         var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
 672                         var set_statemachine = sm.Get ();
 673
 674                         if (!builder_type.Define () || !istate_machine.Define () || set_result == null || builder_factory == null ||
 675                                 set_exception == null || set_statemachine == null || builder_start == null ||
 676                                 !Module.PredefinedTypes.INotifyCompletion.Define ()) {
 677                                 Report.Error (1993, Location,
 678                                         "Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
 679                                 return base.DoDefineMembers ();
 680                         }
 681
 682                         var bt = builder_type.TypeSpec;
 683
 684                         //
 685                         // Inflate generic Task types
 686                         //
 687                         if (has_task_return_type) {
 688                                 var task_return_type = return_type.TypeArguments;
 689                                 if (mutator != null)
 690                                         task_return_type = mutator.Mutate (task_return_type);
 691
 692                                 bt = bt.MakeGenericType (Module, task_return_type);
 693                                 set_result = MemberCache.GetMember (bt, set_result);
 694                                 set_exception = MemberCache.GetMember (bt, set_exception);
 695                                 set_statemachine = MemberCache.GetMember (bt, set_statemachine);
 696
 697                                 if (task != null)
 698                                         task = MemberCache.GetMember (bt, task);
 699                         }
 700
 701                         builder = AddCompilerGeneratedField ("$builder", new TypeExpression (bt, Location));
 702
 703                         Field rfield;
 704                         if (has_task_return_type && HasAwaitInsideFinally) {
 705                                 //
 706                                 // Special case async block with return value from finally clause. In such case
 707                                 // we rewrite all return expresison stores to stfld to $return. Instead of treating
 708                                 // returns outside of finally and inside of finally differently.
 709                                 //
 710                                 rfield = AddCompilerGeneratedField ("$return", new TypeExpression (bt.TypeArguments [0], Location));
 711                         } else {
 712                                 rfield = null;
 713                         }
 714
 715                         var set_state_machine = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Void, Location),
 716                                 Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
 717                                 new MemberName ("SetStateMachine"),
 718                                 ParametersCompiled.CreateFullyResolved (
 719                                         new Parameter (new TypeExpression (istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
 720                                         istate_machine.TypeSpec),
 721                                 null);
 722
 723                         ToplevelBlock block = new ToplevelBlock (Compiler, set_state_machine.ParameterInfo, Location);
 724                         block.IsCompilerGenerated = true;
 725                         set_state_machine.Block = block;
 726
 727                         Members.Add (set_state_machine);
 728
 729                         if (!base.DoDefineMembers ())
 730                                 return false;
 731
 732                         //
 733                         // Fabricates SetStateMachine method
 734                         //
 735                         // public void SetStateMachine (IAsyncStateMachine stateMachine)
 736                         // {
 737                         //    $builder.SetStateMachine (stateMachine);
 738                         // }
 739                         //
 740                         var mg = MethodGroupExpr.CreatePredefined (set_statemachine, bt, Location);
 741                         mg.InstanceExpression = new FieldExpr (builder, Location);
 742
 743                         var param_reference = block.GetParameterReference (0, Location);
 744                         param_reference.Type = istate_machine.TypeSpec;
 745                         param_reference.eclass = ExprClass.Variable;
 746
 747                         var args = new Arguments (1);
 748                         args.Add (new Argument (param_reference));
 749                         set_state_machine.Block.AddStatement (new StatementExpression (new Invocation (mg, args)));
 750
 751                         if (has_task_return_type) {
 752                                 if (rfield != null) {
 753                                         HoistedReturnValue = new FieldExpr (rfield, Location) {
 754                                                 InstanceExpression = new CompilerGeneratedThis (CurrentType, Location.Null)
 755                                         };
 756                                 } else {
 757                                         HoistedReturnValue = TemporaryVariableReference.Create (bt.TypeArguments [0], StateMachineMethod.Block, Location);
 758                                 }
 759                         }
 760
 761                         return true;
 762                 }
 763
 764                 public void EmitAwaitOnCompletedDynamic (EmitContext ec, FieldExpr awaiter)
 765                 {
 766                         var critical = Module.PredefinedTypes.ICriticalNotifyCompletion;
 767                         if (!critical.Define ()) {
 768                                 throw new NotImplementedException ();
 769                         }
 770
 771                         var temp_critical = new LocalTemporary (critical.TypeSpec);
 772                         var label_critical = ec.DefineLabel ();
 773                         var label_end = ec.DefineLabel ();
 774
 775                         //
 776                         // Special path for dynamic awaiters
 777                         //
 778                         // var awaiter = this.$awaiter as ICriticalNotifyCompletion;
 779                         // if (awaiter == null) {
 780                         //    var completion = (INotifyCompletion) this.$awaiter;
 781                         //    this.$builder.AwaitOnCompleted (ref completion, ref this);
 782                         // } else {
 783                         //    this.$builder.AwaitUnsafeOnCompleted (ref awaiter, ref this);
 784                         // }
 785                         //
 786                         awaiter.Emit (ec);
 787                         ec.Emit (OpCodes.Isinst, critical.TypeSpec);
 788                         temp_critical.Store (ec);
 789                         temp_critical.Emit (ec);
 790                         ec.Emit (OpCodes.Brtrue_S, label_critical);
 791
 792                         var temp = new LocalTemporary (Module.PredefinedTypes.INotifyCompletion.TypeSpec);
 793                         awaiter.Emit (ec);
 794                         ec.Emit (OpCodes.Castclass, temp.Type);
 795                         temp.Store (ec);
 796                         EmitOnCompleted (ec, temp, false);
 797                         temp.Release (ec);
 798                         ec.Emit (OpCodes.Br_S, label_end);
 799
 800                         ec.MarkLabel (label_critical);
 801
 802                         EmitOnCompleted (ec, temp_critical, true);
 803
 804                         ec.MarkLabel (label_end);
 805
 806                         temp_critical.Release (ec);
 807                 }
 808
 809                 public void EmitAwaitOnCompleted (EmitContext ec, FieldExpr awaiter)
 810                 {
 811                         bool unsafe_version = false;
 812                         if (Module.PredefinedTypes.ICriticalNotifyCompletion.Define ()) {
 813                                 unsafe_version = awaiter.Type.ImplementsInterface (Module.PredefinedTypes.ICriticalNotifyCompletion.TypeSpec, false);
 814                         }
 815
 816                         EmitOnCompleted (ec, awaiter, unsafe_version);
 817                 }
 818
 819                 void EmitOnCompleted (EmitContext ec, Expression awaiter, bool unsafeVersion)
 820                 {
 821                         var pm = Module.PredefinedMembers;
 822                         PredefinedMember<MethodSpec> predefined;
 823                         bool has_task_return_type = false;
 824                         if (return_type.Kind == MemberKind.Void) {
 825                                 predefined = unsafeVersion ? pm.AsyncVoidMethodBuilderOnCompletedUnsafe : pm.AsyncVoidMethodBuilderOnCompleted;
 826                         } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
 827                                 predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderOnCompletedUnsafe : pm.AsyncTaskMethodBuilderOnCompleted;
 828                         } else {
 829                                 predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderGenericOnCompletedUnsafe : pm.AsyncTaskMethodBuilderGenericOnCompleted;
 830                                 has_task_return_type = true;
 831                         }
 832
 833                         var on_completed = predefined.Resolve (Location);
 834                         if (on_completed == null)
 835                                 return;
 836
 837                         if (has_task_return_type)
 838                                 on_completed = MemberCache.GetMember<MethodSpec> (set_result.DeclaringType, on_completed);
 839
 840                         on_completed = on_completed.MakeGenericMethod (this, awaiter.Type, ec.CurrentType);
 841
 842                         var mg = MethodGroupExpr.CreatePredefined (on_completed, on_completed.DeclaringType, Location);
 843                         mg.InstanceExpression = new FieldExpr (builder, Location) {
 844                                 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
 845                         };
 846
 847                         var args = new Arguments (2);
 848                         args.Add (new Argument (awaiter, Argument.AType.Ref));
 849                         args.Add (new Argument (new CompilerGeneratedThis (CurrentType, Location), Argument.AType.Ref));
 850                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 851                                 mg.EmitCall (ec, args, true);
 852                         }
 853                 }
 854
 855                 public void EmitInitializer (EmitContext ec)
 856                 {
 857                         //
 858                         // Some predefined types are missing
 859                         //
 860                         if (builder == null)
 861                                 return;
 862
 863                         var instance = (TemporaryVariableReference) Instance;
 864                         var builder_field = builder.Spec;
 865                         if (MemberName.Arity > 0) {
 866                                 builder_field = MemberCache.GetMember (instance.Type, builder_field);
 867                         }
 868
 869                         //
 870                         // Inflated factory method when task is of generic type
 871                         //
 872                         if (builder_factory.DeclaringType.IsGeneric) {
 873                                 var task_return_type = return_type.TypeArguments;
 874                                 var bt = builder_factory.DeclaringType.MakeGenericType (Module, task_return_type);
 875                                 builder_factory = MemberCache.GetMember (bt, builder_factory);
 876                                 builder_start = MemberCache.GetMember (bt, builder_start);
 877                         }
 878
 879                         //
 880                         // stateMachine.$builder = AsyncTaskMethodBuilder<{task-type}>.Create();
 881                         //
 882                         instance.AddressOf (ec, AddressOp.Store);
 883                         ec.Emit (OpCodes.Call, builder_factory);
 884                         ec.Emit (OpCodes.Stfld, builder_field);
 885
 886                         //
 887                         // stateMachine.$builder.Start<{storey-type}>(ref stateMachine);
 888                         //
 889                         instance.AddressOf (ec, AddressOp.Store);
 890                         ec.Emit (OpCodes.Ldflda, builder_field);
 891                         if (Task != null)
 892                                 ec.Emit (OpCodes.Dup);
 893                         instance.AddressOf (ec, AddressOp.Store);
 894                         ec.Emit (OpCodes.Call, builder_start.MakeGenericMethod (Module, instance.Type));
 895
 896                         //
 897                         // Emits return stateMachine.$builder.Task;
 898                         //
 899                         if (Task != null) {
 900                                 var task_get = Task.Get;
 901
 902                                 if (MemberName.Arity > 0) {
 903                                         task_get = MemberCache.GetMember (builder_field.MemberType, task_get);
 904                                 }
 905
 906                                 var pe_task = new PropertyExpr (Task, Location) {
 907                                         InstanceExpression = EmptyExpression.Null,      // Comes from the dup above
 908                                         Getter = task_get
 909                                 };
 910
 911                                 pe_task.Emit (ec);
 912                         }
 913                 }
 914
 915                 public void EmitSetException (EmitContext ec, LocalVariableReference exceptionVariable)
 916                 {
 917                         //
 918                         // $builder.SetException (Exception)
 919                         //
 920                         var mg = MethodGroupExpr.CreatePredefined (set_exception, set_exception.DeclaringType, Location);
 921                         mg.InstanceExpression = new FieldExpr (builder, Location) {
 922                                 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
 923                         };
 924
 925                         Arguments args = new Arguments (1);
 926                         args.Add (new Argument (exceptionVariable));
 927
 928                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 929                                 mg.EmitCall (ec, args, true);
 930                         }
 931                 }
 932
 933                 public void EmitSetResult (EmitContext ec)
 934                 {
 935                         //
 936                         // $builder.SetResult ();
 937                         // $builder.SetResult<return-type> (value);
 938                         //
 939                         var mg = MethodGroupExpr.CreatePredefined (set_result, set_result.DeclaringType, Location);
 940                         mg.InstanceExpression = new FieldExpr (builder, Location) {
 941                                 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
 942                         };
 943
 944                         Arguments args;
 945                         if (HoistedReturnValue == null) {
 946                                 args = new Arguments (0);
 947                         } else {
 948                                 args = new Arguments (1);
 949                                 args.Add (new Argument (HoistedReturnValue));
 950                         }
 951
 952                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 953                                 mg.EmitCall (ec, args, true);
 954                         }
 955                 }
 956
 957                 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 958                 {
 959                         base_type = Compiler.BuiltinTypes.ValueType;
 960                         base_class = null;
 961
 962                         var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
 963                         if (istate_machine.Define ()) {
 964                                 return new[] { istate_machine.TypeSpec };
 965                         }
 966
 967                         return null;
 968                 }
 969         }
 970
 971         public class StackFieldExpr : FieldExpr, IExpressionCleanup
 972         {
 973                 public StackFieldExpr (Field field)
 974                         : base (field, Location.Null)
 975                 {
 976                 }
 977
 978                 public bool IsAvailableForReuse {
 979                         get {
 980                                 var field = (Field) spec.MemberDefinition;
 981                                 return field.IsAvailableForReuse;
 982                         }
 983                         set {
 984                                 var field = (Field) spec.MemberDefinition;
 985                                 field.IsAvailableForReuse = value;
 986                         }
 987                 }
 988
 989                 public override void AddressOf (EmitContext ec, AddressOp mode)
 990                 {
 991                         base.AddressOf (ec, mode);
 992
 993                         if (mode == AddressOp.Load) {
 994                                 IsAvailableForReuse = true;
 995                         }
 996                 }
 997
 998                 public override void Emit (EmitContext ec)
 999                 {
1000                         base.Emit (ec);
1001
1002                         PrepareCleanup (ec);
1003                 }
1004
1005                 public void EmitLoad (EmitContext ec)
1006                 {
1007                         base.Emit (ec);
1008                 }
1009
1010                 public void PrepareCleanup (EmitContext ec)
1011                 {
1012                         IsAvailableForReuse = true;
1013
1014                         //
1015                         // Release any captured reference type stack variables
1016                         // to imitate real stack behavour and help GC stuff early
1017                         //
1018                         if (TypeSpec.IsReferenceType (type)) {
1019                                 ec.AddStatementEpilog (this);
1020                         }
1021                 }
1022
1023                 void IExpressionCleanup.EmitCleanup (EmitContext ec)
1024                 {
1025                         EmitAssign (ec, new NullConstant (type, loc), false, false);
1026                 }
1027         }
1028 }