X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fasync.cs;h=6997d7ca85042729b61b8a0204ee01dc54ae584a;hb=60979ce4a41d1be8f9d3d4d38162c0803207b4d5;hp=3577c64ec16118fda5e263c944e359c4b299ad17;hpb=0db8e3bf7f06f3d8e93b7c2c5df0c8811a6c0d5c;p=mono.git diff --git a/mcs/mcs/async.cs b/mcs/mcs/async.cs index 3577c64ec16..6997d7ca850 100644 --- a/mcs/mcs/async.cs +++ b/mcs/mcs/async.cs @@ -1,4 +1,4 @@ -// +// // async.cs: Asynchronous functions // // Author: @@ -7,6 +7,7 @@ // Dual licensed under the terms of the MIT X11 or GNU GPL // // Copyright 2011 Novell, Inc. +// Copyright 2011-2012 Xamarin Inc. // using System; @@ -15,14 +16,16 @@ using System.Linq; using System.Collections; #if STATIC +using IKVM.Reflection; using IKVM.Reflection.Emit; #else +using System.Reflection; using System.Reflection.Emit; #endif namespace Mono.CSharp { - class Await : ExpressionStatement + public class Await : ExpressionStatement { Expression expr; AwaitStatement stmt; @@ -33,6 +36,18 @@ namespace Mono.CSharp this.loc = loc; } + public Expression Expr { + get { + return expr; + } + } + + public AwaitStatement Statement { + get { + return stmt; + } + } + protected override void CloneTo (CloneContext clonectx, Expression target) { var t = (Await) target; @@ -52,39 +67,18 @@ namespace Mono.CSharp protected override Expression DoResolve (ResolveContext rc) { - if (rc.HasSet (ResolveContext.Options.FinallyScope)) { - rc.Report.Error (1984, loc, - "The `await' operator cannot be used in the body of a finally clause"); - } - - if (rc.HasSet (ResolveContext.Options.CatchScope)) { - rc.Report.Error (1985, loc, - "The `await' operator cannot be used in the body of a catch clause"); - } - if (rc.HasSet (ResolveContext.Options.LockScope)) { rc.Report.Error (1996, loc, "The `await' operator cannot be used in the body of a lock statement"); } - if (rc.HasSet (ResolveContext.Options.ExpressionTreeConversion)) { - rc.Report.Error (1989, loc, "An expression tree cannot contain an await operator"); - return null; - } - if (rc.IsUnsafe) { - // TODO: New error code - rc.Report.Error (-1900, loc, + rc.Report.Error (4004, loc, "The `await' operator cannot be used in an unsafe context"); } var bc = (BlockContext) rc; - if (!bc.CurrentBlock.ParametersBlock.IsAsync) { - // TODO: Should check for existence of await type but - // what to do with it - } - stmt = new AwaitStatement (expr, loc); if (!stmt.Resolve (bc)) return null; @@ -97,7 +91,10 @@ namespace Mono.CSharp public override void Emit (EmitContext ec) { stmt.EmitPrologue (ec); - stmt.Emit (ec); + + using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) { + stmt.Emit (ec); + } } public override Expression EmitToField (EmitContext ec) @@ -117,25 +114,41 @@ namespace Mono.CSharp { stmt.EmitStatement (ec); } + + public override object Accept (StructuralVisitor visitor) + { + return visitor.Visit (this); + } } - class AwaitStatement : YieldStatement + public class AwaitStatement : YieldStatement { - sealed class AwaitableMemberAccess : MemberAccess + public sealed class AwaitableMemberAccess : MemberAccess { public AwaitableMemberAccess (Expression expr) : base (expr, "GetAwaiter") { } + public bool ProbingMode { get; set; } + protected override void Error_TypeDoesNotContainDefinition (ResolveContext rc, TypeSpec type, string name) { - Error_WrongGetAwaiter (rc, loc, type); + Error_OperatorCannotBeApplied (rc, type); } protected override void Error_OperatorCannotBeApplied (ResolveContext rc, TypeSpec type) { - rc.Report.Error (1991, loc, "Cannot await `{0}' expression", type.GetSignatureForError ()); + if (ProbingMode) + return; + + var invocation = LeftExpression as Invocation; + if (invocation != null && invocation.MethodGroup != null && (invocation.MethodGroup.BestCandidate.Modifiers & Modifiers.ASYNC) != 0) { + rc.Report.Error (4008, loc, "Cannot await void method `{0}'. Consider changing method return type to `Task'", + invocation.GetSignatureForError ()); + } else { + rc.Report.Error (4001, loc, "Cannot await `{0}' expression", type.GetSignatureForError ()); + } } } @@ -155,10 +168,9 @@ namespace Mono.CSharp } Field awaiter; - PropertyExpr is_completed; - MethodSpec on_completed; - MethodSpec get_result; + AwaiterDefinition awaiter_definition; TypeSpec type; + TypeSpec result_type; public AwaitStatement (Expression expr, Location loc) : base (expr, loc) @@ -167,15 +179,15 @@ namespace Mono.CSharp #region Properties - public TypeSpec Type { + bool IsDynamic { get { - return type; + return awaiter_definition == null; } } public TypeSpec ResultType { get { - return get_result.ReturnType; + return result_type; } } @@ -186,7 +198,7 @@ namespace Mono.CSharp GetResultExpression (ec).Emit (ec); } - public Invocation GetResultExpression (EmitContext ec) + public Expression GetResultExpression (EmitContext ec) { var fe_awaiter = new FieldExpr (awaiter, loc); fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc); @@ -194,7 +206,12 @@ namespace Mono.CSharp // // result = awaiter.GetResult (); // - var mg_result = MethodGroupExpr.CreatePredefined (get_result, fe_awaiter.Type, loc); + if (IsDynamic) { + var rc = new ResolveContext (ec.MemberContext); + return new Invocation (new MemberAccess (fe_awaiter, "GetResult"), new Arguments (0)).Resolve (rc); + } + + var mg_result = MethodGroupExpr.CreatePredefined (awaiter_definition.GetResult, fe_awaiter.Type, loc); mg_result.InstanceExpression = fe_awaiter; return new GetResultInvocation (mg_result, new Arguments (0)); @@ -202,23 +219,40 @@ namespace Mono.CSharp public void EmitPrologue (EmitContext ec) { + awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (expr.Type, loc); + var fe_awaiter = new FieldExpr (awaiter, loc); fe_awaiter.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc); // // awaiter = expr.GetAwaiter (); // - fe_awaiter.EmitAssign (ec, expr, false, false); + using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) { + fe_awaiter.EmitAssign (ec, expr, false, false); + } Label skip_continuation = ec.DefineLabel (); - is_completed.InstanceExpression = fe_awaiter; - is_completed.EmitBranchable (ec, skip_continuation, true); + Expression completed_expr; + if (IsDynamic) { + var rc = new ResolveContext (ec.MemberContext); - base.DoEmit (ec); + Arguments dargs = new Arguments (1); + dargs.Add (new Argument (fe_awaiter)); + completed_expr = new DynamicMemberBinder ("IsCompleted", dargs, loc).Resolve (rc); + + dargs = new Arguments (1); + dargs.Add (new Argument (completed_expr)); + completed_expr = new DynamicConversion (ec.Module.Compiler.BuiltinTypes.Bool, 0, dargs, loc).Resolve (rc); + } else { + var pe = PropertyExpr.CreatePredefined (awaiter_definition.IsCompleted, loc); + pe.InstanceExpression = fe_awaiter; + completed_expr = pe; + } + + completed_expr.EmitBranchable (ec, skip_continuation, true); - FieldSpec[] stack_fields = null; - TypeSpec[] stack = null; + base.DoEmit (ec); // // The stack has to be empty before calling await continuation. We handle this @@ -231,88 +265,59 @@ namespace Mono.CSharp // ec.AssertEmptyStack (); - var mg_completed = MethodGroupExpr.CreatePredefined (on_completed, fe_awaiter.Type, loc); - mg_completed.InstanceExpression = fe_awaiter; - - var args = new Arguments (1); var storey = (AsyncTaskStorey) machine_initializer.Storey; - var fe_cont = new FieldExpr (storey.Continuation, loc); - fe_cont.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc); - - args.Add (new Argument (fe_cont)); - - // - // awaiter.OnCompleted (continuation); - // - mg_completed.EmitCall (ec, args); + if (IsDynamic) { + storey.EmitAwaitOnCompletedDynamic (ec, fe_awaiter); + } else { + storey.EmitAwaitOnCompleted (ec, fe_awaiter); + } // Return ok machine_initializer.EmitLeave (ec, unwind_protect); ec.MarkLabel (resume_point); - - if (stack_fields != null) { - for (int i = 0; i < stack_fields.Length; ++i) { - ec.EmitThis (); - - var field = stack_fields[i]; - - // - // We don't store `this' because it can be easily re-created - // - if (field == null) - continue; - - if (stack[i] is ReferenceContainer) - ec.Emit (OpCodes.Ldflda, field); - else - ec.Emit (OpCodes.Ldfld, field); - } - } - ec.MarkLabel (skip_continuation); } public void EmitStatement (EmitContext ec) { EmitPrologue (ec); - Emit (ec); + DoEmit (ec); - if (ResultType.Kind != MemberKind.Void) { - var storey = (AsyncTaskStorey) machine_initializer.Storey; + awaiter.IsAvailableForReuse = true; - if (storey.HoistedReturn != null) - storey.HoistedReturn.EmitAssign (ec); - else - ec.Emit (OpCodes.Pop); - } - } - - static void Error_WrongGetAwaiter (ResolveContext rc, Location loc, TypeSpec type) - { - rc.Report.Error (1986, loc, - "The `await' operand type `{0}' must have suitable GetAwaiter method", - type.GetSignatureForError ()); + if (ResultType.Kind != MemberKind.Void) + ec.Emit (OpCodes.Pop); } void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter) { - rc.Report.Error (1999, loc, "The awaiter type `{0}' must have suitable IsCompleted, OnCompleted, and GetResult members", + rc.Report.Error (4011, loc, "The awaiter type `{0}' must have suitable IsCompleted and GetResult members", awaiter.GetSignatureForError ()); } public override bool Resolve (BlockContext bc) { + if (bc.CurrentBlock is Linq.QueryBlock) { + bc.Report.Error (1995, loc, + "The `await' operator may only be used in a query expression within the first collection expression of the initial `from' clause or within the collection expression of a `join' clause"); + return false; + } + if (!base.Resolve (bc)) return false; type = expr.Type; + Arguments args = new Arguments (0); // - // The task result is of dynamic type + // The await expression is of dynamic type // - if (expr.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) - throw new NotImplementedException ("dynamic await"); + if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { + result_type = type; + expr = new Invocation (new MemberAccess (expr, "GetAwaiter"), args).Resolve (bc); + return true; + } // // Check whether the expression is awaitable @@ -321,72 +326,37 @@ namespace Mono.CSharp if (ama == null) return false; - Arguments args = new Arguments (0); - var errors_printer = new SessionReportPrinter (); var old = bc.Report.SetPrinter (errors_printer); ama = new Invocation (ama, args).Resolve (bc); + bc.Report.SetPrinter (old); if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression (ama.Type)) { - bc.Report.SetPrinter (old); - Error_WrongGetAwaiter (bc, loc, expr.Type); + bc.Report.Error (1986, expr.Location, + "The `await' operand type `{0}' must have suitable GetAwaiter method", + expr.Type.GetSignatureForError ()); + return false; } var awaiter_type = ama.Type; - awaiter = ((AsyncTaskStorey) machine_initializer.Storey).AddAwaiter (awaiter_type, loc); - expr = ama; - - // - // Predefined: bool IsCompleted { get; } - // - var is_completed_ma = new MemberAccess (expr, "IsCompleted").Resolve (bc); - if (is_completed_ma != null) { - is_completed = is_completed_ma as PropertyExpr; - if (is_completed != null && is_completed.Type.BuiltinType == BuiltinTypeSpec.Type.Bool && is_completed.IsInstance && is_completed.Getter != null) { - // valid - } else { - bc.Report.SetPrinter (old); - Error_WrongAwaiterPattern (bc, awaiter_type); - return false; - } - } - bc.Report.SetPrinter (old); + awaiter_definition = bc.Module.GetAwaiter (awaiter_type); - if (errors_printer.ErrorsCount > 0) { + if (!awaiter_definition.IsValidPattern) { Error_WrongAwaiterPattern (bc, awaiter_type); return false; } - // - // Predefined: OnCompleted (Action) - // - if (bc.Module.PredefinedTypes.Action.Define ()) { - on_completed = MemberCache.FindMember (awaiter_type, MemberFilter.Method ("OnCompleted", 0, - ParametersCompiled.CreateFullyResolved (bc.Module.PredefinedTypes.Action.TypeSpec), bc.Module.Compiler.BuiltinTypes.Void), - BindingRestriction.InstanceOnly) as MethodSpec; - - if (on_completed == null) { - Error_WrongAwaiterPattern (bc, awaiter_type); - return false; - } - } - - // - // Predefined: GetResult () - // - // The method return type is also result type of await expression - // - get_result = MemberCache.FindMember (awaiter_type, MemberFilter.Method ("GetResult", 0, - ParametersCompiled.EmptyReadOnlyParameters, null), - BindingRestriction.InstanceOnly) as MethodSpec; - - if (get_result == null) { - Error_WrongAwaiterPattern (bc, awaiter_type); + if (!awaiter_definition.INotifyCompletion) { + bc.Report.Error (4027, loc, "The awaiter type `{0}' must implement interface `{1}'", + awaiter_type.GetSignatureForError (), bc.Module.PredefinedTypes.INotifyCompletion.GetSignatureForError ()); return false; } + expr = ama; + result_type = awaiter_definition.GetResult.ReturnType; + return true; } } @@ -395,7 +365,7 @@ namespace Mono.CSharp { TypeInferenceContext return_inference; - public AsyncInitializer (ParametersBlock block, TypeContainer host, TypeSpec returnType) + public AsyncInitializer (ParametersBlock block, TypeDefinition host, TypeSpec returnType) : base (block, host, returnType) { } @@ -408,15 +378,13 @@ namespace Mono.CSharp } } - public override bool IsIterator { - get { - return false; - } + public TypeSpec DelegateType { + get; set; } - public Block OriginalBlock { + public override bool IsIterator { get { - return block.Parent; + return false; } } @@ -428,45 +396,6 @@ namespace Mono.CSharp #endregion - public static void Create (IMemberContext context, ParametersBlock block, ParametersCompiled parameters, TypeContainer host, TypeSpec returnType, Location loc) - { - if (returnType != null && returnType.Kind != MemberKind.Void && - returnType != host.Module.PredefinedTypes.Task.TypeSpec && - !returnType.IsGenericTask) { - host.Compiler.Report.Error (1983, loc, "The return type of an async method must be void, Task, or Task"); - } - - for (int i = 0; i < parameters.Count; i++) { - Parameter p = parameters[i]; - Parameter.Modifier mod = p.ModFlags; - if ((mod & Parameter.Modifier.ISBYREF) != 0) { - host.Compiler.Report.Error (1988, p.Location, - "Async methods cannot have ref or out parameters"); - return; - } - - // TODO: - if (p is ArglistParameter) { - host.Compiler.Report.Error (1636, p.Location, - "__arglist is not allowed in parameter list of iterators"); - return; - } - - // TODO: - if (parameters.Types[i].IsPointer) { - host.Compiler.Report.Error (1637, p.Location, - "Iterators cannot have unsafe parameters or yield types"); - return; - } - } - - // TODO: Warning - //if (!block.HasAwait) { - //} - - block.WrapIntoAsyncTask (context, host, returnType); - } - protected override BlockContext CreateBlockContext (ResolveContext rc) { var ctx = base.CreateBlockContext (rc); @@ -474,6 +403,7 @@ namespace Mono.CSharp if (lambda != null) return_inference = lambda.ReturnTypeInference; + ctx.StartFlowBranching (this, rc.CurrentBranching); return ctx; } @@ -496,107 +426,35 @@ namespace Mono.CSharp public override void EmitStatement (EmitContext ec) { var storey = (AsyncTaskStorey) Storey; - storey.Instance.Emit (ec); - - var move_next_entry = storey.StateMachineMethod.Spec; - if (storey.MemberName.Arity > 0) { - move_next_entry = MemberCache.GetMember (storey.Instance.Type, move_next_entry); - } - - ec.Emit (OpCodes.Call, move_next_entry); - - // - // Emits return .$builder.Task; - // - if (storey.Task != null) { - var builder_field = storey.Builder.Spec; - var task_get = storey.Task.Get; - - if (storey.MemberName.Arity > 0) { - builder_field = MemberCache.GetMember (storey.Instance.Type, builder_field); - task_get = MemberCache.GetMember (builder_field.MemberType, task_get); - } - - var pe_task = new PropertyExpr (storey.Task, loc) { - InstanceExpression = new FieldExpr (builder_field, loc) { - InstanceExpression = storey.Instance - }, - Getter = task_get - }; - - pe_task.Emit (ec); - } - + storey.EmitInitializer (ec); ec.Emit (OpCodes.Ret); } } class AsyncTaskStorey : StateMachine { - sealed class ParametersLoadStatement : Statement - { - readonly FieldSpec[] fields; - readonly TypeSpec[] parametersTypes; - readonly int thisParameterIndex; - - public ParametersLoadStatement (FieldSpec[] fields, TypeSpec[] parametersTypes, int thisParameterIndex) - { - this.fields = fields; - this.parametersTypes = parametersTypes; - this.thisParameterIndex = thisParameterIndex; - } - - protected override void CloneTo (CloneContext clonectx, Statement target) - { - throw new NotImplementedException (); - } - - protected override void DoEmit (EmitContext ec) - { - for (int i = 0; i < fields.Length; ++i) { - var field = fields[i]; - if (field == null) - continue; - - ec.EmitArgumentLoad (thisParameterIndex); - ec.EmitArgumentLoad (i); - if (parametersTypes[i] is ReferenceContainer) - ec.EmitLoadFromPtr (field.MemberType); - - ec.Emit (OpCodes.Stfld, field); - } - } - } - int awaiters; - Field builder, continuation; + Field builder; readonly TypeSpec return_type; MethodSpec set_result; MethodSpec set_exception; + MethodSpec builder_factory; + MethodSpec builder_start; PropertySpec task; LocalVariable hoisted_return; int locals_captured; + Dictionary> stack_fields; + Dictionary> awaiter_fields; - public AsyncTaskStorey (IMemberContext context, AsyncInitializer initializer, TypeSpec type) - : base (initializer.OriginalBlock, initializer.Host,context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async") + public AsyncTaskStorey (ParametersBlock block, IMemberContext context, AsyncInitializer initializer, TypeSpec type) + : base (block, initializer.Host, context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async", MemberKind.Struct) { return_type = type; + awaiter_fields = new Dictionary> (); } #region Properties - public Field Builder { - get { - return builder; - } - } - - public Field Continuation { - get { - return continuation; - } - } - public LocalVariable HoistedReturn { get { return hoisted_return; @@ -615,11 +473,39 @@ namespace Mono.CSharp } } + protected override TypeAttributes TypeAttr { + get { + return base.TypeAttr & ~TypeAttributes.SequentialLayout; + } + } + #endregion public Field AddAwaiter (TypeSpec type, Location loc) { - return AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, loc)); + if (mutator != null) + type = mutator.Mutate (type); + + List existing_fields = null; + if (awaiter_fields.TryGetValue (type, out existing_fields)) { + foreach (var f in existing_fields) { + if (f.IsAvailableForReuse) { + f.IsAvailableForReuse = false; + return f; + } + } + } + + var field = AddCompilerGeneratedField ("$awaiter" + awaiters++.ToString ("X"), new TypeExpression (type, Location), true); + field.Define (); + + if (existing_fields == null) { + existing_fields = new List (); + awaiter_fields.Add (type, existing_fields); + } + + existing_fields.Add (field); + return field; } public Field AddCapturedLocalVariable (TypeSpec type) @@ -627,53 +513,85 @@ namespace Mono.CSharp if (mutator != null) type = mutator.Mutate (type); - var field = AddCompilerGeneratedField ("$" + locals_captured++.ToString ("X"), new TypeExpression (type, Location)); + List existing_fields = null; + if (stack_fields == null) { + stack_fields = new Dictionary> (); + } else if (stack_fields.TryGetValue (type, out existing_fields)) { + foreach (var f in existing_fields) { + if (f.IsAvailableForReuse) { + f.IsAvailableForReuse = false; + return f; + } + } + } + + var field = AddCompilerGeneratedField ("$stack" + locals_captured++.ToString ("X"), new TypeExpression (type, Location), true); field.Define (); + if (existing_fields == null) { + existing_fields = new List (); + stack_fields.Add (type, existing_fields); + } + + existing_fields.Add (field); + return field; } protected override bool DoDefineMembers () { - var action = Module.PredefinedTypes.Action.Resolve (); - if (action != null) { - continuation = AddCompilerGeneratedField ("$continuation", new TypeExpression (action, Location)); - continuation.ModFlags |= Modifiers.READONLY; - } - PredefinedType builder_type; PredefinedMember bf; + PredefinedMember bs; PredefinedMember sr; PredefinedMember se; + PredefinedMember sm; bool has_task_return_type = false; var pred_members = Module.PredefinedMembers; if (return_type.Kind == MemberKind.Void) { builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder; bf = pred_members.AsyncVoidMethodBuilderCreate; + bs = pred_members.AsyncVoidMethodBuilderStart; sr = pred_members.AsyncVoidMethodBuilderSetResult; se = pred_members.AsyncVoidMethodBuilderSetException; + sm = pred_members.AsyncVoidMethodBuilderSetStateMachine; } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) { builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder; bf = pred_members.AsyncTaskMethodBuilderCreate; + bs = pred_members.AsyncTaskMethodBuilderStart; sr = pred_members.AsyncTaskMethodBuilderSetResult; se = pred_members.AsyncTaskMethodBuilderSetException; - task = pred_members.AsyncTaskMethodBuilderTask.Resolve (Location); + sm = pred_members.AsyncTaskMethodBuilderSetStateMachine; + task = pred_members.AsyncTaskMethodBuilderTask.Get (); } else { builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric; bf = pred_members.AsyncTaskMethodBuilderGenericCreate; + bs = pred_members.AsyncTaskMethodBuilderGenericStart; sr = pred_members.AsyncTaskMethodBuilderGenericSetResult; se = pred_members.AsyncTaskMethodBuilderGenericSetException; - task = pred_members.AsyncTaskMethodBuilderGenericTask.Resolve (Location); + sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine; + task = pred_members.AsyncTaskMethodBuilderGenericTask.Get (); has_task_return_type = true; } - set_result = sr.Resolve (Location); - set_exception = se.Resolve (Location); - var builder_factory = bf.Resolve (Location); - var bt = builder_type.Resolve (); - if (bt == null || set_result == null || builder_factory == null || set_exception == null) - return false; + set_result = sr.Get (); + set_exception = se.Get (); + builder_factory = bf.Get (); + builder_start = bs.Get (); + + var istate_machine = Module.PredefinedTypes.IAsyncStateMachine; + var set_statemachine = sm.Get (); + + if (!builder_type.Define () || !istate_machine.Define () || set_result == null || builder_factory == null || + set_exception == null || set_statemachine == null || builder_start == null || + !Module.PredefinedTypes.INotifyCompletion.Define ()) { + Report.Error (1993, Location, + "Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?"); + return base.DoDefineMembers (); + } + + var bt = builder_type.TypeSpec; // // Inflate generic Task types @@ -684,60 +602,215 @@ namespace Mono.CSharp task_return_type = mutator.Mutate (task_return_type); bt = bt.MakeGenericType (Module, task_return_type); - builder_factory = MemberCache.GetMember (bt, builder_factory); - set_result = MemberCache.GetMember (bt, set_result); - set_exception = MemberCache.GetMember (bt, set_exception); + set_result = MemberCache.GetMember (bt, set_result); + set_exception = MemberCache.GetMember (bt, set_exception); + set_statemachine = MemberCache.GetMember (bt, set_statemachine); if (task != null) - task = MemberCache.GetMember (bt, task); + task = MemberCache.GetMember (bt, task); } builder = AddCompilerGeneratedField ("$builder", new TypeExpression (bt, Location)); - builder.ModFlags |= Modifiers.READONLY; + + var set_state_machine = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Void, Location), + Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC, + new MemberName ("SetStateMachine"), + ParametersCompiled.CreateFullyResolved ( + new Parameter (new TypeExpression (istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location), + istate_machine.TypeSpec), + null); + + ToplevelBlock block = new ToplevelBlock (Compiler, set_state_machine.ParameterInfo, Location); + block.IsCompilerGenerated = true; + set_state_machine.Block = block; + + Members.Add (set_state_machine); if (!base.DoDefineMembers ()) return false; - MethodGroupExpr mg; - var block = instance_constructors[0].Block; - // - // Initialize continuation with state machine method + // Fabricates SetStateMachine method + // + // public void SetStateMachine (IAsyncStateMachine stateMachine) + // { + // $builder.SetStateMachine (stateMachine); + // } // - if (continuation != null) { - var args = new Arguments (1); - mg = MethodGroupExpr.CreatePredefined (StateMachineMethod.Spec, spec, Location); - args.Add (new Argument (mg)); + var mg = MethodGroupExpr.CreatePredefined (set_statemachine, bt, Location); + mg.InstanceExpression = new FieldExpr (builder, Location); - block.AddStatement ( - new StatementExpression (new SimpleAssign ( - new FieldExpr (continuation, Location), - new NewDelegate (action, args, Location), - Location - ))); - } + var param_reference = block.GetParameterReference (0, Location); + param_reference.Type = istate_machine.TypeSpec; + param_reference.eclass = ExprClass.Variable; - mg = MethodGroupExpr.CreatePredefined (builder_factory, bt, Location); - block.AddStatement ( - new StatementExpression (new SimpleAssign ( - new FieldExpr (builder, Location), - new Invocation (mg, new Arguments (0)), - Location))); + var args = new Arguments (1); + args.Add (new Argument (param_reference)); + set_state_machine.Block.AddStatement (new StatementExpression (new Invocation (mg, args))); if (has_task_return_type) { - hoisted_return = LocalVariable.CreateCompilerGenerated (bt.TypeArguments[0], block, Location); + hoisted_return = LocalVariable.CreateCompilerGenerated (bt.TypeArguments[0], StateMachineMethod.Block, Location); } return true; } + public void EmitAwaitOnCompletedDynamic (EmitContext ec, FieldExpr awaiter) + { + var critical = Module.PredefinedTypes.ICriticalNotifyCompletion; + if (!critical.Define ()) { + throw new NotImplementedException (); + } + + var temp_critical = new LocalTemporary (critical.TypeSpec); + var label_critical = ec.DefineLabel (); + var label_end = ec.DefineLabel (); + + // + // Special path for dynamic awaiters + // + // var awaiter = this.$awaiter as ICriticalNotifyCompletion; + // if (awaiter == null) { + // var completion = (INotifyCompletion) this.$awaiter; + // this.$builder.AwaitOnCompleted (ref completion, ref this); + // } else { + // this.$builder.AwaitUnsafeOnCompleted (ref awaiter, ref this); + // } + // + awaiter.Emit (ec); + ec.Emit (OpCodes.Isinst, critical.TypeSpec); + temp_critical.Store (ec); + temp_critical.Emit (ec); + ec.Emit (OpCodes.Brtrue_S, label_critical); + + var temp = new LocalTemporary (Module.PredefinedTypes.INotifyCompletion.TypeSpec); + awaiter.Emit (ec); + ec.Emit (OpCodes.Castclass, temp.Type); + temp.Store (ec); + EmitOnCompleted (ec, temp, false); + temp.Release (ec); + ec.Emit (OpCodes.Br_S, label_end); + + ec.MarkLabel (label_critical); + + EmitOnCompleted (ec, temp_critical, true); + + ec.MarkLabel (label_end); + + temp_critical.Release (ec); + } + + public void EmitAwaitOnCompleted (EmitContext ec, FieldExpr awaiter) + { + bool unsafe_version = false; + if (Module.PredefinedTypes.ICriticalNotifyCompletion.Define ()) { + unsafe_version = awaiter.Type.ImplementsInterface (Module.PredefinedTypes.ICriticalNotifyCompletion.TypeSpec, false); + } + + EmitOnCompleted (ec, awaiter, unsafe_version); + } + + void EmitOnCompleted (EmitContext ec, Expression awaiter, bool unsafeVersion) + { + var pm = Module.PredefinedMembers; + PredefinedMember predefined; + bool has_task_return_type = false; + if (return_type.Kind == MemberKind.Void) { + predefined = unsafeVersion ? pm.AsyncVoidMethodBuilderOnCompletedUnsafe : pm.AsyncVoidMethodBuilderOnCompleted; + } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) { + predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderOnCompletedUnsafe : pm.AsyncTaskMethodBuilderOnCompleted; + } else { + predefined = unsafeVersion ? pm.AsyncTaskMethodBuilderGenericOnCompletedUnsafe : pm.AsyncTaskMethodBuilderGenericOnCompleted; + has_task_return_type = true; + } + + var on_completed = predefined.Resolve (Location); + if (on_completed == null) + return; + + if (has_task_return_type) + on_completed = MemberCache.GetMember (set_result.DeclaringType, on_completed); + + on_completed = on_completed.MakeGenericMethod (this, awaiter.Type, ec.CurrentType); + + var mg = MethodGroupExpr.CreatePredefined (on_completed, on_completed.DeclaringType, Location); + mg.InstanceExpression = new FieldExpr (builder, Location) { + InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location) + }; + + var args = new Arguments (2); + args.Add (new Argument (awaiter, Argument.AType.Ref)); + args.Add (new Argument (new CompilerGeneratedThis (CurrentType, Location), Argument.AType.Ref)); + mg.EmitCall (ec, args); + } + + public void EmitInitializer (EmitContext ec) + { + // + // Some predefined types are missing + // + if (builder == null) + return; + + var instance = (TemporaryVariableReference) Instance; + var builder_field = builder.Spec; + if (MemberName.Arity > 0) { + builder_field = MemberCache.GetMember (instance.Type, builder_field); + } + + // + // Inflated factory method when task is of generic type + // + if (builder_factory.DeclaringType.IsGeneric) { + var task_return_type = return_type.TypeArguments; + var bt = builder_factory.DeclaringType.MakeGenericType (Module, task_return_type); + builder_factory = MemberCache.GetMember (bt, builder_factory); + builder_start = MemberCache.GetMember (bt, builder_start); + } + + // + // stateMachine.$builder = AsyncTaskMethodBuilder<{task-type}>.Create(); + // + instance.AddressOf (ec, AddressOp.Store); + ec.Emit (OpCodes.Call, builder_factory); + ec.Emit (OpCodes.Stfld, builder_field); + + // + // stateMachine.$builder.Start<{storey-type}>(ref stateMachine); + // + instance.AddressOf (ec, AddressOp.Store); + ec.Emit (OpCodes.Ldflda, builder_field); + if (Task != null) + ec.Emit (OpCodes.Dup); + instance.AddressOf (ec, AddressOp.Store); + ec.Emit (OpCodes.Call, builder_start.MakeGenericMethod (Module, instance.Type)); + + // + // Emits return stateMachine.$builder.Task; + // + if (Task != null) { + var task_get = Task.Get; + + if (MemberName.Arity > 0) { + task_get = MemberCache.GetMember (builder_field.MemberType, task_get); + } + + var pe_task = new PropertyExpr (Task, Location) { + InstanceExpression = EmptyExpression.Null, // Comes from the dup above + Getter = task_get + }; + + pe_task.Emit (ec); + } + } + public void EmitSetException (EmitContext ec, LocalVariableReference exceptionVariable) { // // $builder.SetException (Exception) // var mg = MethodGroupExpr.CreatePredefined (set_exception, set_exception.DeclaringType, Location); - mg.InstanceExpression = new FieldExpr (Builder, Location) { + mg.InstanceExpression = new FieldExpr (builder, Location) { InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location) }; @@ -754,7 +827,7 @@ namespace Mono.CSharp // $builder.SetResult (value); // var mg = MethodGroupExpr.CreatePredefined (set_result, set_result.DeclaringType, Location); - mg.InstanceExpression = new FieldExpr (Builder, Location) { + mg.InstanceExpression = new FieldExpr (builder, Location) { InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, Location) }; @@ -768,5 +841,57 @@ namespace Mono.CSharp mg.EmitCall (ec, args); } + + protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) + { + base_type = Compiler.BuiltinTypes.ValueType; + base_class = null; + + var istate_machine = Module.PredefinedTypes.IAsyncStateMachine; + if (istate_machine.Define ()) { + return new[] { istate_machine.TypeSpec }; + } + + return null; + } + } + + class StackFieldExpr : FieldExpr, IExpressionCleanup + { + public StackFieldExpr (Field field) + : base (field, Location.Null) + { + } + + public override void AddressOf (EmitContext ec, AddressOp mode) + { + base.AddressOf (ec, mode); + + if (mode == AddressOp.Load) { + var field = (Field) spec.MemberDefinition; + field.IsAvailableForReuse = true; + } + } + + public override void Emit (EmitContext ec) + { + base.Emit (ec); + + var field = (Field) spec.MemberDefinition; + field.IsAvailableForReuse = true; + + // + // Release any captured reference type stack variables + // to imitate real stack behavour and help GC stuff early + // + if (TypeSpec.IsReferenceType (type)) { + ec.AddStatementEpilog (this); + } + } + + void IExpressionCleanup.EmitCleanup (EmitContext ec) + { + EmitAssign (ec, new NullConstant (type, loc), false, false); + } } }