Change the way how using declarators statements are generated to handle await in...

[mono.git] / mcs / mcs / assign.cs

diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs
index c64120f7e653cc18f9635189ebceefd9beceaf68..95ca88d4a8ca62c2c5ac129a73ce5f91bc7be7d0 100644 (file)
--- a/mcs/mcs/assign.cs
+++ b/mcs/mcs/assign.cs
@@ -51,7 +51,7 @@ namespace Mono.CSharp {
                // be data on the stack that it can use to compuatate its value. This is
                // for expressions like a [f ()] ++, where you can't call `f ()' twice.
                //
-               void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load);
+               void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool isCompound);
 
                /*
                For simple assignments, this interface is very simple, EmitAssign is called with source
@@ -201,6 +201,11 @@ namespace Mono.CSharp {
                        builder = null;
                }
 
+               public override bool ContainsEmitWithAwait ()
+               {
+                       return false;
+               }
+
                public override Expression CreateExpressionTree (ResolveContext ec)
                {
                        Arguments args = new Arguments (1);
@@ -223,7 +228,7 @@ namespace Mono.CSharp {
                        if (builder == null)
                                throw new InternalErrorException ("Emit without Store, or after Release");
 
-                       ec.Emit (OpCodes.Ldloc, builder, type);
+                       ec.Emit (OpCodes.Ldloc, builder);
                }
 
                #region IAssignMethod Members
@@ -236,9 +241,9 @@ namespace Mono.CSharp {
                                Emit (ec);
                }
 
-               public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
+               public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool isCompound)
                {
-                       if (prepare_for_load)
+                       if (isCompound)
                                throw new NotImplementedException ();
 
                        source.Emit (ec);
@@ -260,7 +265,7 @@ namespace Mono.CSharp {
                        if (builder == null)
                                builder = ec.GetTemporaryLocal (type);
 
-                       ec.Emit (OpCodes.Stloc, builder, type);
+                       ec.Emit (OpCodes.Stloc, builder);
                }
 
                public void AddressOf (EmitContext ec, AddressOp mode)
@@ -273,9 +278,9 @@ namespace Mono.CSharp {
                                // if is_address, than this is just the address anyways,
                                // so we just return this.
                                //
-                               ec.Emit (OpCodes.Ldloc, builder, type);
+                               ec.Emit (OpCodes.Ldloc, builder);
                        } else {
-                               ec.Emit (OpCodes.Ldloca, builder, type);
+                               ec.Emit (OpCodes.Ldloca, builder);
                        }
                }
        }
@@ -294,12 +299,6 @@ namespace Mono.CSharp {
                        this.loc = loc;
                }
                
-               public override Expression CreateExpressionTree (ResolveContext ec)
-               {
-                       ec.Report.Error (832, loc, "An expression tree cannot contain an assignment operator");
-                       return null;
-               }
-
                public Expression Target {
                        get { return target; }
                }
@@ -310,6 +309,17 @@ namespace Mono.CSharp {
                        }
                }
 
+               public override bool ContainsEmitWithAwait ()
+               {
+                       return target.ContainsEmitWithAwait () || source.ContainsEmitWithAwait ();
+               }
+
+               public override Expression CreateExpressionTree (ResolveContext ec)
+               {
+                       ec.Report.Error (832, loc, "An expression tree cannot contain an assignment operator");
+                       return null;
+               }
+
                protected override Expression DoResolve (ResolveContext ec)
                {
                        bool ok = true;
@@ -567,13 +577,19 @@ namespace Mono.CSharp {
                // This is just a hack implemented for arrays only
                public sealed class TargetExpression : Expression
                {
-                       Expression child;
+                       readonly Expression child;
+
                        public TargetExpression (Expression child)
                        {
                                this.child = child;
                                this.loc = child.Location;
                        }
 
+                       public override bool ContainsEmitWithAwait ()
+                       {
+                               return child.ContainsEmitWithAwait ();
+                       }
+
                        public override Expression CreateExpressionTree (ResolveContext ec)
                        {
                                throw new NotSupportedException ("ET");
@@ -590,6 +606,11 @@ namespace Mono.CSharp {
                        {
                                child.Emit (ec);
                        }
+
+                       public override Expression EmitToField (EmitContext ec)
+                       {
+                               return child.EmitToField (ec);
+                       }
                }
 
                // Used for underlying binary operator