2 // async.cs: Asynchronous functions
5 // Marek Safar (marek.safar@gmail.com)
7 // Dual licensed under the terms of the MIT X11 or GNU GPL
9 // Copyright 2011 Novell, Inc.
10 // Copyright 2011-2012 Xamarin Inc.
14 using System.Collections.Generic;
16 using System.Collections;
19 using IKVM.Reflection;
20 using IKVM.Reflection.Emit;
22 using System.Reflection;
23 using System.Reflection.Emit;
28 public class Await : ExpressionStatement
33 public Await (Expression expr, Location loc)
39 public Expression Expr {
45 public AwaitStatement Statement {
51 protected override void CloneTo (CloneContext clonectx, Expression target)
53 var t = (Await) target;
55 t.expr = expr.Clone (clonectx);
58 public override Expression CreateExpressionTree (ResolveContext ec)
60 throw new NotImplementedException ("ET");
63 public override bool ContainsEmitWithAwait ()
68 public override void FlowAnalysis (FlowAnalysisContext fc)
70 stmt.Expr.FlowAnalysis (fc);
72 stmt.RegisterResumePoint ();
75 protected override Expression DoResolve (ResolveContext rc)
77 if (rc.HasSet (ResolveContext.Options.FinallyScope)) {
78 rc.Report.Error (1984, loc, "The `await' operator cannot be used in the body of a finally clause");
81 if (rc.HasSet (ResolveContext.Options.LockScope)) {
82 rc.Report.Error (1996, loc,
83 "The `await' operator cannot be used in the body of a lock statement");
87 rc.Report.Error (4004, loc,
88 "The `await' operator cannot be used in an unsafe context");
91 var bc = (BlockContext) rc;
93 stmt = new AwaitStatement (expr, loc);
94 if (!stmt.Resolve (bc))
97 type = stmt.ResultType;
98 eclass = ExprClass.Variable;
102 public override void Emit (EmitContext ec)
104 stmt.EmitPrologue (ec);
106 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
111 public override Expression EmitToField (EmitContext ec)
113 stmt.EmitPrologue (ec);
114 return stmt.GetResultExpression (ec);
117 public void EmitAssign (EmitContext ec, FieldExpr field)
119 stmt.EmitPrologue (ec);
120 field.InstanceExpression.Emit (ec);
124 public override void EmitStatement (EmitContext ec)
126 stmt.EmitStatement (ec);
129 public override void MarkReachable (Reachability rc)
131 base.MarkReachable (rc);
132 stmt.MarkReachable (rc);
135 public override object Accept (StructuralVisitor visitor)
137 return visitor.Visit (this);
141 public class AwaitStatement : YieldStatement<AsyncInitializer>
143 public sealed class AwaitableMemberAccess : MemberAccess
145 public AwaitableMemberAccess (Expression expr)
146 : base (expr, "GetAwaiter")
150 public bool ProbingMode { get; set; }
152 protected override void Error_TypeDoesNotContainDefinition (ResolveContext rc, TypeSpec type, string name)
154 Error_OperatorCannotBeApplied (rc, type);
157 protected override void Error_OperatorCannotBeApplied (ResolveContext rc, TypeSpec type)
162 var invocation = LeftExpression as Invocation;
163 if (invocation != null && invocation.MethodGroup != null && (invocation.MethodGroup.BestCandidate.Modifiers & Modifiers.ASYNC) != 0) {
164 rc.Report.Error (4008, loc, "Cannot await void method `{0}'. Consider changing method return type to `Task'",
165 invocation.GetSignatureForError ());
167 rc.Report.Error (4001, loc, "Cannot await `{0}' expression", type.GetSignatureForError ());
172 sealed class GetResultInvocation : Invocation
174 public GetResultInvocation (MethodGroupExpr mge, Arguments arguments)
175 : base (null, arguments)
178 type = mg.BestCandidateReturnType;
181 public override Expression EmitToField (EmitContext ec)
188 AwaiterDefinition awaiter_definition;
190 TypeSpec result_type;
192 public AwaitStatement (Expression expr, Location loc)
195 unwind_protect = true;
202 return awaiter_definition == null;
206 public TypeSpec ResultType {
214 protected override void DoEmit (EmitContext ec)
216 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
217 GetResultExpression (ec).Emit (ec);
221 public Expression GetResultExpression (EmitContext ec)
223 var fe_awaiter = new FieldExpr (awaiter, loc);
224 fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
227 // result = awaiter.GetResult ();
230 var rc = new ResolveContext (ec.MemberContext);
231 return new Invocation (new MemberAccess (fe_awaiter, "GetResult"), new Arguments (0)).Resolve (rc);
234 var mg_result = MethodGroupExpr.CreatePredefined (awaiter_definition.GetResult, fe_awaiter.Type, loc);
235 mg_result.InstanceExpression = fe_awaiter;
237 return new GetResultInvocation (mg_result, new Arguments (0));
240 public void EmitPrologue (EmitContext ec)
242 awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (expr.Type);
244 var fe_awaiter = new FieldExpr (awaiter, loc);
245 fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
247 Label skip_continuation = ec.DefineLabel ();
249 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
251 // awaiter = expr.GetAwaiter ();
253 fe_awaiter.EmitAssign (ec, expr, false, false);
255 Expression completed_expr;
257 var rc = new ResolveContext (ec.MemberContext);
259 Arguments dargs = new Arguments (1);
260 dargs.Add (new Argument (fe_awaiter));
261 completed_expr = new DynamicMemberBinder ("IsCompleted", dargs, loc).Resolve (rc);
263 dargs = new Arguments (1);
264 dargs.Add (new Argument (completed_expr));
265 completed_expr = new DynamicConversion (ec.Module.Compiler.BuiltinTypes.Bool, 0, dargs, loc).Resolve (rc);
267 var pe = PropertyExpr.CreatePredefined (awaiter_definition.IsCompleted, loc);
268 pe.InstanceExpression = fe_awaiter;
272 completed_expr.EmitBranchable (ec, skip_continuation, true);
278 // The stack has to be empty before calling await continuation. We handle this
279 // by lifting values which would be left on stack into class fields. The process
280 // is quite complicated and quite hard to test because any expression can possibly
281 // leave a value on the stack.
283 // Following assert fails when some of expression called before is missing EmitToField
284 // or parent expression fails to find await in children expressions
286 ec.AssertEmptyStack ();
288 var storey = (AsyncTaskStorey) machine_initializer.Storey;
290 storey.EmitAwaitOnCompletedDynamic (ec, fe_awaiter);
292 storey.EmitAwaitOnCompleted (ec, fe_awaiter);
296 machine_initializer.EmitLeave (ec, unwind_protect);
298 ec.MarkLabel (resume_point);
299 ec.MarkLabel (skip_continuation);
302 public void EmitStatement (EmitContext ec)
307 awaiter.IsAvailableForReuse = true;
309 if (ResultType.Kind != MemberKind.Void)
310 ec.Emit (OpCodes.Pop);
313 void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter)
315 rc.Report.Error (4011, loc, "The awaiter type `{0}' must have suitable IsCompleted and GetResult members",
316 awaiter.GetSignatureForError ());
319 public override bool Resolve (BlockContext bc)
321 if (bc.CurrentBlock is Linq.QueryBlock) {
322 bc.Report.Error (1995, loc,
323 "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");
327 if (bc.HasSet (ResolveContext.Options.CatchScope)) {
328 bc.Report.Error (1985, loc, "The `await' operator cannot be used in the body of a catch clause");
331 if (!base.Resolve (bc))
335 Arguments args = new Arguments (0);
338 // The await expression is of dynamic type
340 if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
342 expr = new Invocation (new MemberAccess (expr, "GetAwaiter"), args).Resolve (bc);
347 // Check whether the expression is awaitable
349 Expression ama = new AwaitableMemberAccess (expr).Resolve (bc);
353 var errors_printer = new SessionReportPrinter ();
354 var old = bc.Report.SetPrinter (errors_printer);
355 ama = new Invocation (ama, args).Resolve (bc);
356 bc.Report.SetPrinter (old);
358 if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression (ama.Type)) {
359 bc.Report.Error (1986, expr.Location,
360 "The `await' operand type `{0}' must have suitable GetAwaiter method",
361 expr.Type.GetSignatureForError ());
366 var awaiter_type = ama.Type;
368 awaiter_definition = bc.Module.GetAwaiter (awaiter_type);
370 if (!awaiter_definition.IsValidPattern) {
371 Error_WrongAwaiterPattern (bc, awaiter_type);
375 if (!awaiter_definition.INotifyCompletion) {
376 bc.Report.Error (4027, loc, "The awaiter type `{0}' must implement interface `{1}'",
377 awaiter_type.GetSignatureForError (), bc.Module.PredefinedTypes.INotifyCompletion.GetSignatureForError ());
382 result_type = awaiter_definition.GetResult.ReturnType;
388 class AsyncInitializerStatement : StatementExpression
390 public AsyncInitializerStatement (AsyncInitializer expr)
395 protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
397 base.DoFlowAnalysis (fc);
399 var init = (AsyncInitializer) Expr;
400 var res = !init.Block.HasReachableClosingBrace;
401 var storey = (AsyncTaskStorey) init.Storey;
403 if (storey.ReturnType.IsGenericTask)
409 public override Reachability MarkReachable (Reachability rc)
411 if (!rc.IsUnreachable)
414 var init = (AsyncInitializer) Expr;
415 rc = init.Block.MarkReachable (rc);
417 var storey = (AsyncTaskStorey) init.Storey;
420 // Explicit return is required for Task<T> state machine
422 if (storey.ReturnType != null && storey.ReturnType.IsGenericTask)
425 return Reachability.CreateUnreachable ();
429 public class AsyncInitializer : StateMachineInitializer
431 TypeInferenceContext return_inference;
433 public AsyncInitializer (ParametersBlock block, TypeDefinition host, TypeSpec returnType)
434 : base (block, host, returnType)
440 public override string ContainerType {
442 return "async state machine block";
446 public TypeSpec DelegateType {
450 public override bool IsIterator {
456 public TypeInferenceContext ReturnTypeInference {
458 return return_inference;
464 protected override BlockContext CreateBlockContext (BlockContext bc)
466 var ctx = base.CreateBlockContext (bc);
467 var lambda = bc.CurrentAnonymousMethod as LambdaMethod;
469 return_inference = lambda.ReturnTypeInference;
471 ctx.Set (ResolveContext.Options.TryScope);
476 public override void Emit (EmitContext ec)
478 throw new NotImplementedException ();
481 protected override void EmitMoveNextEpilogue (EmitContext ec)
483 var storey = (AsyncTaskStorey) Storey;
484 storey.EmitSetResult (ec);
487 public override void EmitStatement (EmitContext ec)
489 var storey = (AsyncTaskStorey) Storey;
490 storey.EmitInitializer (ec);
491 ec.Emit (OpCodes.Ret);
494 public override void MarkReachable (Reachability rc)
497 // Reachability has been done in AsyncInitializerStatement
502 class AsyncTaskStorey : StateMachine
506 readonly TypeSpec return_type;
507 MethodSpec set_result;
508 MethodSpec set_exception;
509 MethodSpec builder_factory;
510 MethodSpec builder_start;
512 LocalVariable hoisted_return;
514 Dictionary<TypeSpec, List<Field>> stack_fields;
515 Dictionary<TypeSpec, List<Field>> awaiter_fields;
517 public AsyncTaskStorey (ParametersBlock block, IMemberContext context, AsyncInitializer initializer, TypeSpec type)
518 : base (block, initializer.Host, context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async", MemberKind.Struct)
521 awaiter_fields = new Dictionary<TypeSpec, List<Field>> ();
526 public LocalVariable HoistedReturn {
528 return hoisted_return;
532 public TypeSpec ReturnType {
538 public PropertySpec Task {
544 protected override TypeAttributes TypeAttr {
546 return base.TypeAttr & ~TypeAttributes.SequentialLayout;
552 public Field AddAwaiter (TypeSpec type)
555 type = mutator.Mutate (type);
557 List<Field> existing_fields;
558 if (awaiter_fields.TryGetValue (type, out existing_fields)) {
559 foreach (var f in existing_fields) {
560 if (f.IsAvailableForReuse) {
561 f.IsAvailableForReuse = false;
567 var field = AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, Location), true);
570 if (existing_fields == null) {
571 existing_fields = new List<Field> ();
572 awaiter_fields.Add (type, existing_fields);
575 existing_fields.Add (field);
579 public Field AddCapturedLocalVariable (TypeSpec type)
582 type = mutator.Mutate (type);
584 List<Field> existing_fields = null;
585 if (stack_fields == null) {
586 stack_fields = new Dictionary<TypeSpec, List<Field>> ();
587 } else if (stack_fields.TryGetValue (type, out existing_fields)) {
588 foreach (var f in existing_fields) {
589 if (f.IsAvailableForReuse) {
590 f.IsAvailableForReuse = false;
596 var field = AddCompilerGeneratedField ("$stack" + locals_captured++.ToString ("X"), new TypeExpression (type, Location), true);
599 if (existing_fields == null) {
600 existing_fields = new List<Field> ();
601 stack_fields.Add (type, existing_fields);
604 existing_fields.Add (field);
609 protected override bool DoDefineMembers ()
611 PredefinedType builder_type;
612 PredefinedMember<MethodSpec> bf;
613 PredefinedMember<MethodSpec> bs;
614 PredefinedMember<MethodSpec> sr;
615 PredefinedMember<MethodSpec> se;
616 PredefinedMember<MethodSpec> sm;
617 bool has_task_return_type = false;
618 var pred_members = Module.PredefinedMembers;
620 if (return_type.Kind == MemberKind.Void) {
621 builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
622 bf = pred_members.AsyncVoidMethodBuilderCreate;
623 bs = pred_members.AsyncVoidMethodBuilderStart;
624 sr = pred_members.AsyncVoidMethodBuilderSetResult;
625 se = pred_members.AsyncVoidMethodBuilderSetException;
626 sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
627 } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
628 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
629 bf = pred_members.AsyncTaskMethodBuilderCreate;
630 bs = pred_members.AsyncTaskMethodBuilderStart;
631 sr = pred_members.AsyncTaskMethodBuilderSetResult;
632 se = pred_members.AsyncTaskMethodBuilderSetException;
633 sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
634 task = pred_members.AsyncTaskMethodBuilderTask.Get ();
636 builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
637 bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
638 bs = pred_members.AsyncTaskMethodBuilderGenericStart;
639 sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
640 se = pred_members.AsyncTaskMethodBuilderGenericSetException;
641 sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
642 task = pred_members.AsyncTaskMethodBuilderGenericTask.Get ();
643 has_task_return_type = true;
646 set_result = sr.Get ();
647 set_exception = se.Get ();
648 builder_factory = bf.Get ();
649 builder_start = bs.Get ();
651 var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
652 var set_statemachine = sm.Get ();
654 if (!builder_type.Define () || !istate_machine.Define () || set_result == null || builder_factory == null ||
655 set_exception == null || set_statemachine == null || builder_start == null ||
656 !Module.PredefinedTypes.INotifyCompletion.Define ()) {
657 Report.Error (1993, Location,
658 "Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
659 return base.DoDefineMembers ();
662 var bt = builder_type.TypeSpec;
665 // Inflate generic Task types
667 if (has_task_return_type) {
668 var task_return_type = return_type.TypeArguments;
670 task_return_type = mutator.Mutate (task_return_type);
672 bt = bt.MakeGenericType (Module, task_return_type);
673 set_result = MemberCache.GetMember (bt, set_result);
674 set_exception = MemberCache.GetMember (bt, set_exception);
675 set_statemachine = MemberCache.GetMember (bt, set_statemachine);
678 task = MemberCache.GetMember (bt, task);
681 builder = AddCompilerGeneratedField ("$builder", new TypeExpression (bt, Location));
683 var set_state_machine = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Void, Location),
684 Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
685 new MemberName ("SetStateMachine"),
686 ParametersCompiled.CreateFullyResolved (
687 new Parameter (new TypeExpression (istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
688 istate_machine.TypeSpec),
691 ToplevelBlock block = new ToplevelBlock (Compiler, set_state_machine.ParameterInfo, Location);
692 block.IsCompilerGenerated = true;
693 set_state_machine.Block = block;
695 Members.Add (set_state_machine);
697 if (!base.DoDefineMembers ())
701 // Fabricates SetStateMachine method
703 // public void SetStateMachine (IAsyncStateMachine stateMachine)
705 // $builder.SetStateMachine (stateMachine);
708 var mg = MethodGroupExpr.CreatePredefined (set_statemachine, bt, Location);
709 mg.InstanceExpression = new FieldExpr (builder, Location);
711 var param_reference = block.GetParameterReference (0, Location);
712 param_reference.Type = istate_machine.TypeSpec;
713 param_reference.eclass = ExprClass.Variable;
715 var args = new Arguments (1);
716 args.Add (new Argument (param_reference));
717 set_state_machine.Block.AddStatement (new StatementExpression (new Invocation (mg, args)));
719 if (has_task_return_type) {
720 hoisted_return = LocalVariable.CreateCompilerGenerated (bt.TypeArguments[0], StateMachineMethod.Block, Location);
726 public void EmitAwaitOnCompletedDynamic (EmitContext ec, FieldExpr awaiter)
728 var critical = Module.PredefinedTypes.ICriticalNotifyCompletion;
729 if (!critical.Define ()) {
730 throw new NotImplementedException ();
733 var temp_critical = new LocalTemporary (critical.TypeSpec);
734 var label_critical = ec.DefineLabel ();
735 var label_end = ec.DefineLabel ();
738 // Special path for dynamic awaiters
740 // var awaiter = this.$awaiter as ICriticalNotifyCompletion;
741 // if (awaiter == null) {
742 // var completion = (INotifyCompletion) this.$awaiter;
743 // this.$builder.AwaitOnCompleted (ref completion, ref this);
745 // this.$builder.AwaitUnsafeOnCompleted (ref awaiter, ref this);
749 ec.Emit (OpCodes.Isinst, critical.TypeSpec);
750 temp_critical.Store (ec);
751 temp_critical.Emit (ec);
752 ec.Emit (OpCodes.Brtrue_S, label_critical);
754 var temp = new LocalTemporary (Module.PredefinedTypes.INotifyCompletion.TypeSpec);
756 ec.Emit (OpCodes.Castclass, temp.Type);
758 EmitOnCompleted (ec, temp, false);
760 ec.Emit (OpCodes.Br_S, label_end);
762 ec.MarkLabel (label_critical);
764 EmitOnCompleted (ec, temp_critical, true);
766 ec.MarkLabel (label_end);
768 temp_critical.Release (ec);
771 public void EmitAwaitOnCompleted (EmitContext ec, FieldExpr awaiter)
773 bool unsafe_version = false;
774 if (Module.PredefinedTypes.ICriticalNotifyCompletion.Define ()) {
775 unsafe_version = awaiter.Type.ImplementsInterface (Module.PredefinedTypes.ICriticalNotifyCompletion.TypeSpec, false);
778 EmitOnCompleted (ec, awaiter, unsafe_version);
781 void EmitOnCompleted (EmitContext ec, Expression awaiter, bool unsafeVersion)
783 var pm = Module.PredefinedMembers;
784 PredefinedMember<MethodSpec> predefined;
785 bool has_task_return_type = false;
786 if (return_type.Kind == MemberKind.Void) {
787 predefined = unsafeVersion ? pm.AsyncVoidMethodBuilderOnCompletedUnsafe : pm.AsyncVoidMethodBuilderOnCompleted;
788 } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) {
789 predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderOnCompletedUnsafe : pm.AsyncTaskMethodBuilderOnCompleted;
791 predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderGenericOnCompletedUnsafe : pm.AsyncTaskMethodBuilderGenericOnCompleted;
792 has_task_return_type = true;
795 var on_completed = predefined.Resolve (Location);
796 if (on_completed == null)
799 if (has_task_return_type)
800 on_completed = MemberCache.GetMember<MethodSpec> (set_result.DeclaringType, on_completed);
802 on_completed = on_completed.MakeGenericMethod (this, awaiter.Type, ec.CurrentType);
804 var mg = MethodGroupExpr.CreatePredefined (on_completed, on_completed.DeclaringType, Location);
805 mg.InstanceExpression = new FieldExpr (builder, Location) {
806 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
809 var args = new Arguments (2);
810 args.Add (new Argument (awaiter, Argument.AType.Ref));
811 args.Add (new Argument (new CompilerGeneratedThis (CurrentType, Location), Argument.AType.Ref));
812 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
813 mg.EmitCall (ec, args);
817 public void EmitInitializer (EmitContext ec)
820 // Some predefined types are missing
825 var instance = (TemporaryVariableReference) Instance;
826 var builder_field = builder.Spec;
827 if (MemberName.Arity > 0) {
828 builder_field = MemberCache.GetMember (instance.Type, builder_field);
832 // Inflated factory method when task is of generic type
834 if (builder_factory.DeclaringType.IsGeneric) {
835 var task_return_type = return_type.TypeArguments;
836 var bt = builder_factory.DeclaringType.MakeGenericType (Module, task_return_type);
837 builder_factory = MemberCache.GetMember (bt, builder_factory);
838 builder_start = MemberCache.GetMember (bt, builder_start);
842 // stateMachine.$builder = AsyncTaskMethodBuilder<{task-type}>.Create();
844 instance.AddressOf (ec, AddressOp.Store);
845 ec.Emit (OpCodes.Call, builder_factory);
846 ec.Emit (OpCodes.Stfld, builder_field);
849 // stateMachine.$builder.Start<{storey-type}>(ref stateMachine);
851 instance.AddressOf (ec, AddressOp.Store);
852 ec.Emit (OpCodes.Ldflda, builder_field);
854 ec.Emit (OpCodes.Dup);
855 instance.AddressOf (ec, AddressOp.Store);
856 ec.Emit (OpCodes.Call, builder_start.MakeGenericMethod (Module, instance.Type));
859 // Emits return stateMachine.$builder.Task;
862 var task_get = Task.Get;
864 if (MemberName.Arity > 0) {
865 task_get = MemberCache.GetMember (builder_field.MemberType, task_get);
868 var pe_task = new PropertyExpr (Task, Location) {
869 InstanceExpression = EmptyExpression.Null, // Comes from the dup above
877 public void EmitSetException (EmitContext ec, LocalVariableReference exceptionVariable)
880 // $builder.SetException (Exception)
882 var mg = MethodGroupExpr.CreatePredefined (set_exception, set_exception.DeclaringType, Location);
883 mg.InstanceExpression = new FieldExpr (builder, Location) {
884 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
887 Arguments args = new Arguments (1);
888 args.Add (new Argument (exceptionVariable));
890 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
891 mg.EmitCall (ec, args);
895 public void EmitSetResult (EmitContext ec)
898 // $builder.SetResult ();
899 // $builder.SetResult<return-type> (value);
901 var mg = MethodGroupExpr.CreatePredefined (set_result, set_result.DeclaringType, Location);
902 mg.InstanceExpression = new FieldExpr (builder, Location) {
903 InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location)
907 if (hoisted_return == null) {
908 args = new Arguments (0);
910 args = new Arguments (1);
911 args.Add (new Argument (new LocalVariableReference (hoisted_return, Location)));
914 using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
915 mg.EmitCall (ec, args);
919 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
921 base_type = Compiler.BuiltinTypes.ValueType;
924 var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
925 if (istate_machine.Define ()) {
926 return new[] { istate_machine.TypeSpec };
933 public class StackFieldExpr : FieldExpr, IExpressionCleanup
935 public StackFieldExpr (Field field)
936 : base (field, Location.Null)
940 public bool IsAvailableForReuse {
942 var field = (Field) spec.MemberDefinition;
943 return field.IsAvailableForReuse;
946 var field = (Field) spec.MemberDefinition;
947 field.IsAvailableForReuse = value;
951 public override void AddressOf (EmitContext ec, AddressOp mode)
953 base.AddressOf (ec, mode);
955 if (mode == AddressOp.Load) {
956 IsAvailableForReuse = true;
960 public override void Emit (EmitContext ec)
962 EmitWithCleanup (ec, true);
965 public void EmitWithCleanup (EmitContext ec, bool release)
970 IsAvailableForReuse = true;
973 // Release any captured reference type stack variables
974 // to imitate real stack behavour and help GC stuff early
976 if (TypeSpec.IsReferenceType (type)) {
977 ec.AddStatementEpilog (this);
981 void IExpressionCleanup.EmitCleanup (EmitContext ec)
983 EmitAssign (ec, new NullConstant (type, loc), false, false);