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 //
  11
  12 using System;
  13 using System.Collections.Generic;
  14 using System.Linq;
  15 using System.Collections;
  16
  17 #if STATIC
  18 using IKVM.Reflection.Emit;
  19 #else
  20 using System.Reflection.Emit;
  21 #endif
  22
  23 namespace Mono.CSharp
  24 {
  25         class Await : ExpressionStatement
  26         {
  27                 Expression expr;
  28                 AwaitStatement stmt;
  29
  30                 public Await (Expression expr, Location loc)
  31                 {
  32                         this.expr = expr;
  33                         this.loc = loc;
  34                 }
  35
  36                 protected override void CloneTo (CloneContext clonectx, Expression target)
  37                 {
  38                         var t = (Await) target;
  39
  40                         t.expr = expr.Clone (clonectx);
  41                 }
  42
  43                 public override Expression CreateExpressionTree (ResolveContext ec)
  44                 {
  45                         throw new NotImplementedException ("ET");
  46                 }
  47
  48                 public override bool ContainsEmitWithAwait ()
  49                 {
  50                         return true;
  51                 }
  52
  53                 protected override Expression DoResolve (ResolveContext rc)
  54                 {
  55                         if (rc.HasSet (ResolveContext.Options.FinallyScope)) {
  56                                 rc.Report.Error (1984, loc,
  57                                         "The `await' operator cannot be used in the body of a finally clause");
  58                         }
  59
  60                         if (rc.HasSet (ResolveContext.Options.CatchScope)) {
  61                                 rc.Report.Error (1985, loc,
  62                                         "The `await' operator cannot be used in the body of a catch clause");
  63                         }
  64
  65                         if (rc.HasSet (ResolveContext.Options.LockScope)) {
  66                                 rc.Report.Error (1996, loc,
  67                                         "The `await' operator cannot be used in the body of a lock statement");
  68                         }
  69
  70                         if (rc.HasSet (ResolveContext.Options.ExpressionTreeConversion)) {
  71                                 rc.Report.Error (1989, loc, "An expression tree cannot contain an await operator");
  72                                 return null;
  73                         }
  74
  75                         if (rc.IsUnsafe) {
  76                                 // TODO: New error code
  77                                 rc.Report.Error (-1900, loc,
  78                                         "The `await' operator cannot be used in an unsafe context");
  79                         }
  80
  81                         var bc = (BlockContext) rc;
  82
  83                         if (!bc.CurrentBlock.ParametersBlock.IsAsync) {
  84                                 // TODO: Should check for existence of await type but
  85                                 // what to do with it
  86                         }
  87
  88                         stmt = new AwaitStatement (expr, loc);
  89                         if (!stmt.Resolve (bc))
  90                                 return null;
  91
  92                         type = stmt.ResultType;
  93                         eclass = ExprClass.Variable;
  94                         return this;
  95                 }
  96
  97                 public override void Emit (EmitContext ec)
  98                 {
  99                         stmt.EmitPrologue (ec);
 100                         stmt.Emit (ec);
 101                 }
 102
 103                 public override Expression EmitToField (EmitContext ec)
 104                 {
 105                         stmt.EmitPrologue (ec);
 106                         return stmt.GetResultExpression (ec);
 107                 }
 108
 109                 public void EmitAssign (EmitContext ec, FieldExpr field)
 110                 {
 111                         stmt.EmitPrologue (ec);
 112                         field.InstanceExpression.Emit (ec);
 113                         stmt.Emit (ec);
 114                 }
 115
 116                 public override void EmitStatement (EmitContext ec)
 117                 {
 118                         stmt.EmitStatement (ec);
 119                 }
 120         }
 121
 122         class AwaitStatement : YieldStatement<AsyncInitializer>
 123         {
 124                 sealed class AwaitableMemberAccess : MemberAccess
 125                 {
 126                         public AwaitableMemberAccess (Expression expr)
 127                                 : base (expr, "GetAwaiter")
 128                         {
 129                         }
 130
 131                         protected override void Error_TypeDoesNotContainDefinition (ResolveContext rc, TypeSpec type, string name)
 132                         {
 133                                 Error_WrongGetAwaiter (rc, loc, type);
 134                         }
 135
 136                         protected override void Error_OperatorCannotBeApplied (ResolveContext rc, TypeSpec type)
 137                         {
 138                                 rc.Report.Error (1991, loc, "Cannot await `{0}' expression", type.GetSignatureForError ());
 139                         }
 140                 }
 141
 142                 sealed class GetResultInvocation : Invocation
 143                 {
 144                         public GetResultInvocation (MethodGroupExpr mge, Arguments arguments)
 145                                 : base (null, arguments)
 146                         {
 147                                 mg = mge;
 148                                 type = mg.BestCandidateReturnType;
 149                         }
 150
 151                         public override Expression EmitToField (EmitContext ec)
 152                         {
 153                                 return this;
 154                         }
 155                 }
 156
 157                 Field awaiter;
 158                 PropertyExpr is_completed;
 159                 MethodSpec on_completed;
 160                 MethodSpec get_result;
 161                 TypeSpec type;
 162
 163                 public AwaitStatement (Expression expr, Location loc)
 164                         : base (expr, loc)
 165                 {
 166                 }
 167
 168                 #region Properties
 169
 170                 public TypeSpec Type {
 171                         get {
 172                                 return type;
 173                         }
 174                 }
 175
 176                 public TypeSpec ResultType {
 177                         get {
 178                                 return get_result.ReturnType;
 179                         }
 180                 }
 181
 182                 #endregion
 183
 184                 protected override void DoEmit (EmitContext ec)
 185                 {
 186                         GetResultExpression (ec).Emit (ec);
 187                 }
 188
 189                 public Invocation GetResultExpression (EmitContext ec)
 190                 {
 191                         var fe_awaiter = new FieldExpr (awaiter, loc);
 192                         fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
 193
 194                         //
 195                         // result = awaiter.GetResult ();
 196                         //
 197                         var mg_result = MethodGroupExpr.CreatePredefined (get_result, fe_awaiter.Type, loc);
 198                         mg_result.InstanceExpression = fe_awaiter;
 199
 200                         return new GetResultInvocation (mg_result, new Arguments (0));
 201                 }
 202
 203                 public void EmitPrologue (EmitContext ec)
 204                 {
 205                         var fe_awaiter = new FieldExpr (awaiter, loc);
 206                         fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
 207
 208                         //
 209                         // awaiter = expr.GetAwaiter ();
 210                         //
 211                         fe_awaiter.EmitAssign (ec, expr, false, false);
 212
 213                         Label skip_continuation = ec.DefineLabel ();
 214
 215                         is_completed.InstanceExpression = fe_awaiter;
 216                         is_completed.EmitBranchable (ec, skip_continuation, true);
 217
 218                         base.DoEmit (ec);
 219
 220                         FieldSpec[] stack_fields = null;
 221                         TypeSpec[] stack = null;
 222
 223                         //
 224                         // The stack has to be empty before calling await continuation. We handle this
 225                         // by lifting values which would be left on stack into class fields. The process
 226                         // is quite complicated and quite hard to test because any expression can possibly
 227                         // leave a value on the stack.
 228                         //
 229                         // Following assert fails when some of expression called before is missing EmitToField
 230                         // or parent expression fails to find await in children expressions
 231                         //
 232                         ec.AssertEmptyStack ();
 233
 234                         var mg_completed = MethodGroupExpr.CreatePredefined (on_completed, fe_awaiter.Type, loc);
 235                         mg_completed.InstanceExpression = fe_awaiter;
 236
 237                         var args = new Arguments (1);
 238                         var storey = (AsyncTaskStorey) machine_initializer.Storey;
 239                         var fe_cont = new FieldExpr (storey.Continuation, loc);
 240                         fe_cont.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
 241
 242                         args.Add (new Argument (fe_cont));
 243
 244                         //
 245                         // awaiter.OnCompleted (continuation);
 246                         //
 247                         mg_completed.EmitCall (ec, args);
 248
 249                         // Return ok
 250                         machine_initializer.EmitLeave (ec, unwind_protect);
 251
 252                         ec.MarkLabel (resume_point);
 253
 254                         if (stack_fields != null) {
 255                                 for (int i = 0; i < stack_fields.Length; ++i) {
 256                                         ec.EmitThis ();
 257
 258                                         var field = stack_fields[i];
 259
 260                                         //
 261                                         // We don't store `this' because it can be easily re-created
 262                                         //
 263                                         if (field == null)
 264                                                 continue;
 265
 266                                         if (stack[i] is ReferenceContainer)
 267                                                 ec.Emit (OpCodes.Ldflda, field);
 268                                         else
 269                                                 ec.Emit (OpCodes.Ldfld, field);
 270                                 }
 271                         }
 272
 273                         ec.MarkLabel (skip_continuation);
 274                 }
 275
 276                 public void EmitStatement (EmitContext ec)
 277                 {
 278                         EmitPrologue (ec);
 279                         Emit (ec);
 280
 281                         if (ResultType.Kind != MemberKind.Void) {
 282                                 var storey = (AsyncTaskStorey) machine_initializer.Storey;
 283
 284                             if (storey.HoistedReturn != null)
 285                                 storey.HoistedReturn.EmitAssign (ec);
 286                                 else
 287                                         ec.Emit (OpCodes.Pop);
 288                         }
 289                 }
 290
 291                 static void Error_WrongGetAwaiter (ResolveContext rc, Location loc, TypeSpec type)
 292                 {
 293                         rc.Report.Error (1986, loc,
 294                                 "The `await' operand type `{0}' must have suitable GetAwaiter method",
 295                                 type.GetSignatureForError ());
 296                 }
 297
 298                 void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter)
 299                 {
 300                         rc.Report.Error (1999, loc, "The awaiter type `{0}' must have suitable IsCompleted, OnCompleted, and GetResult members",
 301                                 awaiter.GetSignatureForError ());
 302                 }
 303
 304                 public override bool Resolve (BlockContext bc)
 305                 {
 306                         if (!base.Resolve (bc))
 307                                 return false;
 308
 309                         type = expr.Type;
 310
 311                         //
 312                         // The task result is of dynamic type
 313                         //
 314                         if (expr.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
 315                                 throw new NotImplementedException ("dynamic await");
 316
 317                         //
 318                         // Check whether the expression is awaitable
 319                         //
 320                         Expression ama = new AwaitableMemberAccess (expr).Resolve (bc);
 321                         if (ama == null)
 322                                 return false;
 323
 324                         Arguments args = new Arguments (0);
 325
 326                         var errors_printer = new SessionReportPrinter ();
 327                         var old = bc.Report.SetPrinter (errors_printer);
 328                         ama = new Invocation (ama, args).Resolve (bc);
 329
 330                         if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression (ama.Type)) {
 331                                 bc.Report.SetPrinter (old);
 332                                 Error_WrongGetAwaiter (bc, loc, expr.Type);
 333                                 return false;
 334                         }
 335
 336                         var awaiter_type = ama.Type;
 337                         awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (awaiter_type, loc);
 338                         expr = ama;
 339
 340                         //
 341                         // Predefined: bool IsCompleted { get; }
 342                         //
 343                         var is_completed_ma = new MemberAccess (expr, "IsCompleted").Resolve (bc);
 344                         if (is_completed_ma != null) {
 345                                 is_completed = is_completed_ma as PropertyExpr;
 346                                 if (is_completed != null && is_completed.Type.BuiltinType == BuiltinTypeSpec.Type.Bool && is_completed.IsInstance && is_completed.Getter != null) {
 347                                         // valid
 348                                 } else {
 349                                         bc.Report.SetPrinter (old);
 350                                         Error_WrongAwaiterPattern (bc, awaiter_type);
 351                                         return false;
 352                                 }
 353                         }
 354
 355                         bc.Report.SetPrinter (old);
 356
 357                         if (errors_printer.ErrorsCount > 0) {
 358                                 Error_WrongAwaiterPattern (bc, awaiter_type);
 359                                 return false;
 360                         }
 361
 362                         //
 363                         // Predefined: OnCompleted (Action)
 364                         //
 365                         if (bc.Module.PredefinedTypes.Action.Define ()) {
 366                                 on_completed = MemberCache.FindMember (awaiter_type, MemberFilter.Method ("OnCompleted", 0,
 367                                         ParametersCompiled.CreateFullyResolved (bc.Module.PredefinedTypes.Action.TypeSpec), bc.Module.Compiler.BuiltinTypes.Void),
 368                                         BindingRestriction.InstanceOnly) as MethodSpec;
 369
 370                                 if (on_completed == null) {
 371                                         Error_WrongAwaiterPattern (bc, awaiter_type);
 372                                         return false;
 373                                 }
 374                         }
 375
 376                         //
 377                         // Predefined: GetResult ()
 378                         //
 379                         // The method return type is also result type of await expression
 380                         //
 381                         get_result = MemberCache.FindMember (awaiter_type, MemberFilter.Method ("GetResult", 0,
 382                                 ParametersCompiled.EmptyReadOnlyParameters, null),
 383                                 BindingRestriction.InstanceOnly) as MethodSpec;
 384
 385                         if (get_result == null) {
 386                                 Error_WrongAwaiterPattern (bc, awaiter_type);
 387                                 return false;
 388                         }
 389
 390                         return true;
 391                 }
 392         }
 393
 394         public class AsyncInitializer : StateMachineInitializer
 395         {
 396                 TypeInferenceContext return_inference;
 397
 398                 public AsyncInitializer (ParametersBlock block, TypeContainer host, TypeSpec returnType)
 399                         : base (block, host, returnType)
 400                 {
 401                 }
 402
 403                 #region Properties
 404
 405                 public override string ContainerType {
 406                         get {
 407                                 return "async state machine block";
 408                         }
 409                 }
 410
 411                 public override bool IsIterator {
 412                         get {
 413                                 return false;
 414                         }
 415                 }
 416
 417                 public Block OriginalBlock {
 418                         get {
 419                                 return block.Parent;
 420                         }
 421                 }
 422
 423                 public TypeInferenceContext ReturnTypeInference {
 424                         get {
 425                                 return return_inference;
 426                         }
 427                 }
 428
 429                 #endregion
 430
 431                 public static void Create (IMemberContext context, ParametersBlock block, ParametersCompiled parameters, TypeContainer host, TypeSpec returnType, Location loc)
 432                 {
 433                         if (returnType != null && returnType.Kind != MemberKind.Void &&
 434                                 returnType != host.Module.PredefinedTypes.Task.TypeSpec &&
 435                                 !returnType.IsGenericTask) {
 436                                 host.Compiler.Report.Error (1983, loc, "The return type of an async method must be void, Task, or Task<T>");
 437                         }
 438
 439                         for (int i = 0; i < parameters.Count; i++) {
 440                                 Parameter p = parameters[i];
 441                                 Parameter.Modifier mod = p.ModFlags;
 442                                 if ((mod & Parameter.Modifier.ISBYREF) != 0) {
 443                                         host.Compiler.Report.Error (1988, p.Location,
 444                                                 "Async methods cannot have ref or out parameters");
 445                                         return;
 446                                 }
 447
 448                                 // TODO:
 449                                 if (p is ArglistParameter) {
 450                                         host.Compiler.Report.Error (1636, p.Location,
 451                                                 "__arglist is not allowed in parameter list of iterators");
 452                                         return;
 453                                 }
 454
 455                                 // TODO:
 456                                 if (parameters.Types[i].IsPointer) {
 457                                         host.Compiler.Report.Error (1637, p.Location,
 458                                                 "Iterators cannot have unsafe parameters or yield types");
 459                                         return;
 460                                 }
 461                         }
 462
 463                         // TODO: Warning
 464                         //if (!block.HasAwait) {
 465                         //}
 466
 467                         block.WrapIntoAsyncTask (context, host, returnType);
 468                 }
 469
 470                 protected override BlockContext CreateBlockContext (ResolveContext rc)
 471                 {
 472                         var ctx = base.CreateBlockContext (rc);
 473                         var lambda = rc.CurrentAnonymousMethod as LambdaMethod;
 474                         if (lambda != null)
 475                                 return_inference = lambda.ReturnTypeInference;
 476
 477                         return ctx;
 478                 }
 479
 480                 public override Expression CreateExpressionTree (ResolveContext ec)
 481                 {
 482                         return base.CreateExpressionTree (ec);
 483                 }
 484
 485                 public override void Emit (EmitContext ec)
 486                 {
 487                         throw new NotImplementedException ();
 488                 }
 489
 490                 protected override void EmitMoveNextEpilogue (EmitContext ec)
 491                 {
 492                         var storey = (AsyncTaskStorey) Storey;
 493                         storey.EmitSetResult (ec);
 494                 }
 495
 496                 public override void EmitStatement (EmitContext ec)
 497                 {
 498                         var storey = (AsyncTaskStorey) Storey;
 499                         storey.Instance.Emit (ec);
 500
 501                         var move_next_entry = storey.StateMachineMethod.Spec;
 502                         if (storey.MemberName.Arity > 0) {
 503                                 move_next_entry = MemberCache.GetMember (storey.Instance.Type, move_next_entry);
 504                         }
 505
 506                         ec.Emit (OpCodes.Call, move_next_entry);
 507
 508                         //
 509                         // Emits return <async-storey-instance>.$builder.Task;
 510                         //
 511                         if (storey.Task != null) {
 512                                 var builder_field = storey.Builder.Spec;
 513                                 var task_get = storey.Task.Get;
 514
 515                                 if (storey.MemberName.Arity > 0) {
 516                                         builder_field = MemberCache.GetMember (storey.Instance.Type, builder_field);
 517                                         task_get = MemberCache.GetMember (builder_field.MemberType, task_get);
 518                                 }
 519
 520                                 var pe_task = new PropertyExpr (storey.Task, loc) {
 521                                         InstanceExpression = new FieldExpr (builder_field, loc) {
 522                                                 InstanceExpression = storey.Instance
 523                                         },
 524                                         Getter = task_get
 525                                 };
 526
 527                                 pe_task.Emit (ec);
 528                         }
 529
 530                         ec.Emit (OpCodes.Ret);
 531                 }
 532         }
 533
 534         class AsyncTaskStorey : StateMachine
 535         {
 536                 sealed class ParametersLoadStatement : Statement
 537                 {
 538                         readonly FieldSpec[] fields;
 539                         readonly TypeSpec[] parametersTypes;
 540                         readonly int thisParameterIndex;
 541
 542                         public ParametersLoadStatement (FieldSpec[] fields, TypeSpec[] parametersTypes, int thisParameterIndex)
 543                         {
 544                                 this.fields = fields;
 545                                 this.parametersTypes = parametersTypes;
 546                                 this.thisParameterIndex = thisParameterIndex;
 547                         }
 548
 549                         protected override void CloneTo (CloneContext clonectx, Statement target)
 550                         {
 551                                 throw new NotImplementedException ();
 552                         }
 553
 554                         protected override void DoEmit (EmitContext ec)
 555                         {
 556                                 for (int i = 0; i < fields.Length; ++i) {
 557                                         var field = fields[i];
 558                                         if (field == null)
 559                                                 continue;
 560
 561                                         ec.EmitArgumentLoad (thisParameterIndex);
 562                                         ec.EmitArgumentLoad (i);
 563                                         if (parametersTypes[i] is ReferenceContainer)
 564                                                 ec.EmitLoadFromPtr (field.MemberType);
 565
 566                                         ec.Emit (OpCodes.Stfld, field);
 567                                 }
 568                         }
 569                 }
 570
 571                 int awaiters;
 572                 Field builder, continuation;
 573                 readonly TypeSpec return_type;
 574                 MethodSpec set_result;
 575                 PropertySpec task;
 576                 LocalVariable hoisted_return;
 577                 int locals_captured;
 578
 579                 public AsyncTaskStorey (IMemberContext context, AsyncInitializer initializer, TypeSpec type)
 580                         : base (initializer.OriginalBlock, initializer.Host,context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async")
 581                 {
 582                         return_type = type;
 583                 }
 584
 585                 #region Properties
 586
 587                 public Field Builder {
 588                         get {
 589                                 return builder;
 590                         }
 591                 }
 592
 593                 public Field Continuation {
 594                         get {
 595                                 return continuation;
 596                         }
 597                 }
 598
 599                 public LocalVariable HoistedReturn {
 600                         get {
 601                                 return hoisted_return;
 602                         }
 603                 }
 604
 605                 public TypeSpec ReturnType {
 606                         get {
 607                                 return return_type;
 608                         }
 609                 }
 610
 611                 public PropertySpec Task {
 612                         get {
 613                                 return task;
 614                         }
 615                 }
 616
 617                 #endregion
 618
 619                 public Field AddAwaiter (TypeSpec type, Location loc)
 620                 {
 621                         return AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, loc));
 622                 }
 623
 624                 public Field AddCapturedLocalVariable (TypeSpec type)
 625                 {
 626                         if (mutator != null)
 627                                 type = mutator.Mutate (type);
 628
 629                         var field = AddCompilerGeneratedField ("<s>$" + locals_captured++.ToString ("X"), new TypeExpression (type, Location));
 630                         field.Define ();
 631
 632                         return field;
 633                 }
 634
 635                 protected override bool DoDefineMembers ()
 636                 {
 637                         var action = Module.PredefinedTypes.Action.Resolve ();
 638                         if (action != null) {
 639                                 continuation = AddCompilerGeneratedField ("$continuation", new TypeExpression (action, Location));
 640                                 continuation.ModFlags |= Modifiers.READONLY;
 641                         }
 642
 643                         PredefinedType builder_type;
 644                         PredefinedMember<MethodSpec> bf;
 645                         PredefinedMember<MethodSpec> sr;
 646                         bool has_task_return_type = false;
 647                         var pred_members = Module.PredefinedMembers;
 648
 649                         if (return_type.Kind == MemberKind.Void) {
 650                                 builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
 651                                 bf = pred_members.AsyncVoidMethodBuilderCreate;
 652                                 sr = pred_members.AsyncVoidMethodBuilderSetResult;
 653                         } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
 654                                 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
 655                                 bf = pred_members.AsyncTaskMethodBuilderCreate;
 656                                 sr = pred_members.AsyncTaskMethodBuilderSetResult;
 657                                 task = pred_members.AsyncTaskMethodBuilderTask.Resolve (Location);
 658                         } else {
 659                                 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
 660                                 bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
 661                                 sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
 662                                 task = pred_members.AsyncTaskMethodBuilderGenericTask.Resolve (Location);
 663                                 has_task_return_type = true;
 664                         }
 665
 666                         set_result = sr.Resolve (Location);
 667                         var builder_factory = bf.Resolve (Location);
 668                         var bt = builder_type.Resolve ();
 669                         if (bt == null || set_result == null || builder_factory == null)
 670                                 return false;
 671
 672                         //
 673                         // Inflate generic Task types
 674                         //
 675                         if (has_task_return_type) {
 676                                 var task_return_type = return_type.TypeArguments;
 677                                 if (mutator != null)
 678                                         task_return_type = mutator.Mutate (task_return_type);
 679
 680                                 bt = bt.MakeGenericType (Module, task_return_type);
 681                                 builder_factory = MemberCache.GetMember<MethodSpec> (bt, builder_factory);
 682                                 set_result = MemberCache.GetMember<MethodSpec> (bt, set_result);
 683
 684                                 if (task != null)
 685                                         task = MemberCache.GetMember<PropertySpec> (bt, task);
 686                         }
 687
 688                         builder = AddCompilerGeneratedField ("$builder", new TypeExpression (bt, Location));
 689                         builder.ModFlags |= Modifiers.READONLY;
 690
 691                         if (!base.DoDefineMembers ())
 692                                 return false;
 693
 694                         MethodGroupExpr mg;
 695                         var block = instance_constructors[0].Block;
 696
 697                         //
 698                         // Initialize continuation with state machine method
 699                         //
 700                         if (continuation != null) {
 701                                 var args = new Arguments (1);
 702                                 mg = MethodGroupExpr.CreatePredefined (StateMachineMethod.Spec, spec, Location);
 703                                 args.Add (new Argument (mg));
 704
 705                                 block.AddStatement (
 706                                         new StatementExpression (new SimpleAssign (
 707                                                 new FieldExpr (continuation, Location),
 708                                                 new NewDelegate (action, args, Location),
 709                                                 Location
 710                                 )));
 711                         }
 712
 713                         mg = MethodGroupExpr.CreatePredefined (builder_factory, bt, Location);
 714                         block.AddStatement (
 715                                 new StatementExpression (new SimpleAssign (
 716                                 new FieldExpr (builder, Location),
 717                                 new Invocation (mg, new Arguments (0)),
 718                                 Location)));
 719
 720                         if (has_task_return_type) {
 721                                 hoisted_return = LocalVariable.CreateCompilerGenerated (bt.TypeArguments[0], block, Location);
 722                         }
 723
 724                         return true;
 725                 }
 726
 727                 public void EmitSetResult (EmitContext ec)
 728                 {
 729                         //
 730                         // $builder.SetResult ();
 731                         // $builder.SetResult<return-type> (value);
 732                         //
 733                         var mg = MethodGroupExpr.CreatePredefined (set_result, set_result.DeclaringType, Location);
 734                         mg.InstanceExpression = new FieldExpr (Builder, Location) {
 735                                 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
 736                         };
 737
 738                         Arguments args;
 739                         if (hoisted_return == null) {
 740                                 args = new Arguments (0);
 741                         } else {
 742                                 args = new Arguments (1);
 743                                 args.Add (new Argument (new LocalVariableReference (hoisted_return, Location)));
 744                         }
 745
 746                         mg.EmitCall (ec, args);
 747                 }
 748         }
 749 }