2008-04-30 Marek Safar <marek.safar@gmail.com>

	* assign.cs, anonymous.cs, lambda.cs, nullable.cs, ecore.cs, linq.cs,
	class.cs, iterators.cs, expression.cs, attribute.cs: Filled a few more
	expression tree conversions.

svn path=/trunk/mcs/; revision=102219

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 0031da775ffffa2cbc81ceb8acd2b9a0998f502c..01d89009e0ac54150c70c0f5fedfae686fa0764b 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,9 @@
+2008-04-30  Marek Safar  <marek.safar@gmail.com>
+
+       * assign.cs, anonymous.cs, lambda.cs, nullable.cs, ecore.cs, linq.cs,
+       class.cs, iterators.cs, expression.cs, attribute.cs: Filled a few more
+       expression tree conversions.
+       
 2008-04-30  Marek Safar  <marek.safar@gmail.com>
 
        * typemanager.cs, ecore.cs, class.cs, expression.cs, doc.cs: Merged all

diff --git a/mcs/mcs/anonymous.cs b/mcs/mcs/anonymous.cs
index 55e5bd0e8da230d37fb07aaf59143398e3aa71f3..794956f53e7501e4c51d5a24e5c6e0b144646fbc 100644 (file)
--- a/mcs/mcs/anonymous.cs
+++ b/mcs/mcs/anonymous.cs
@@ -646,6 +646,11 @@ namespace Mono.CSharp {
                                get { return scope; }
                        }
 
+                       public override Expression CreateExpressionTree (EmitContext ec)
+                       {
+                               throw new NotSupportedException ("ET");
+                       }
+
                        public override Expression DoResolve (EmitContext ec)
                        {
                                if (scope_ctor != null)
@@ -1423,6 +1428,11 @@ namespace Mono.CSharp {
                }
 
                protected virtual Expression CreateExpressionTree (EmitContext ec, Type delegate_type)
+               {
+                       return CreateExpressionTree (ec);
+               }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
                {
                        Report.Error (1946, loc, "An anonymous method cannot be converted to an expression tree");
                        return null;
@@ -1794,6 +1804,12 @@ namespace Mono.CSharp {
                        return TypeManager.CSharpName (DelegateType);
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       Report.Error (1945, loc, "An expression tree cannot contain an anonymous method expression");
+                       return null;
+               }
+
                //
                // Creates the host for the anonymous method
                //
@@ -1941,6 +1957,11 @@ namespace Mono.CSharp {
                        this.am = am;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       return am.CreateExpressionTree (ec);
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        eclass = ExprClass.Value;

diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs
index 03350c7021aae2ff1145d393ee57c7b6f39ea499..8ae6cd57bbbb9b6b0dfbabe6b26ac8e3a39590de 100644 (file)
--- a/mcs/mcs/assign.cs
+++ b/mcs/mcs/assign.cs
@@ -206,6 +206,11 @@ namespace Mono.CSharp {
                        builder = null;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        return this;
@@ -476,6 +481,11 @@ namespace Mono.CSharp {
                        this.loc = loc;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       return new SimpleAssign (target, source).CreateExpressionTree (ec);
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        eclass = ExprClass.Value;
@@ -524,6 +534,7 @@ namespace Mono.CSharp {
                        this.op = op;
                }
 
+               // !!! What a stupid name
                public class Helper : Expression {
                        Expression child;
                        public Helper (Expression child)
@@ -532,6 +543,11 @@ namespace Mono.CSharp {
                                this.loc = child.Location;
                        }
 
+                       public override Expression CreateExpressionTree (EmitContext ec)
+                       {
+                               throw new NotSupportedException ("ET");
+                       }
+
                        public override Expression DoResolve (EmitContext ec)
                        {
                                child = child.Resolve (ec);

diff --git a/mcs/mcs/attribute.cs b/mcs/mcs/attribute.cs
index 099055b733cf2d9182b0e6b06b950edd402d3c5a..098134db35fbeac592de457063cba626c871eabc 100644 (file)
--- a/mcs/mcs/attribute.cs
+++ b/mcs/mcs/attribute.cs
@@ -1272,6 +1272,11 @@ namespace Mono.CSharp {
                        return e.TypeArgument;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        throw new NotImplementedException ();

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index 31912e078d2287ed6e191613b638164ca38f118b..6b0e5fe92fe775b9b64a49473f3befbfbc09dde3 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -4554,6 +4554,11 @@ namespace Mono.CSharp {
                        }
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public bool Resolve (ConstructorBuilder caller_builder, EmitContext ec)
                {
                        if (argument_list != null){

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index f78a76b22983096d0c2e1a556ebb84081c3b88b4..1e12fd37f9024c5d42a756de1d2060979cd6723e 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -5652,6 +5652,11 @@ namespace Mono.CSharp {
                        this.loc = loc;
                        eclass = ExprClass.Value;
                }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
                
                public override Expression DoResolve (EmitContext ec)
                {

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 55d75ca981aae8a568f9cedd445e34a7b57e150c..9a58c991bd2320832c47f94221dff8cc24dc9593 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -101,6 +101,12 @@ namespace Mono.CSharp {
                public ParenthesizedExpression (Expression expr)
                {
                        this.Expr = expr;
+                       this.loc = expr.Location;
+               }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
                }
 
                public override Expression DoResolve (EmitContext ec)
@@ -114,13 +120,6 @@ namespace Mono.CSharp {
                        throw new Exception ("Should not happen");
                }
 
-               public override Location Location
-               {
-                       get {
-                               return Expr.Location;
-                       }
-               }
-
                protected override void CloneTo (CloneContext clonectx, Expression t)
                {
                        ParenthesizedExpression target = (ParenthesizedExpression) t;
@@ -1209,6 +1208,8 @@ namespace Mono.CSharp {
        ///   Implementation of the `is' operator.
        /// </summary>
        public class Is : Probe {
+               Nullable.Unwrap expr_unwrap;
+
                public Is (Expression expr, Expression probe_type, Location l)
                        : base (expr, probe_type, l)
                {
@@ -1225,6 +1226,10 @@ namespace Mono.CSharp {
                public override void Emit (EmitContext ec)
                {
                        ILGenerator ig = ec.ig;
+                       if (expr_unwrap != null) {
+                               expr_unwrap.EmitCheck (ec);
+                               return;
+                       }
 
                        expr.Emit (ec);
                        ig.Emit (OpCodes.Isinst, probe_type_expr.Type);
@@ -1235,9 +1240,12 @@ namespace Mono.CSharp {
                public override void EmitBranchable (EmitContext ec, Label target, bool on_true)
                {
                        ILGenerator ig = ec.ig;
-
-                       expr.Emit (ec);
-                       ig.Emit (OpCodes.Isinst, probe_type_expr.Type);
+                       if (expr_unwrap != null) {
+                               expr_unwrap.EmitCheck (ec);
+                       } else {
+                               expr.Emit (ec);
+                               ig.Emit (OpCodes.Isinst, probe_type_expr.Type);
+                       }                       
                        ig.Emit (on_true ? OpCodes.Brtrue : OpCodes.Brfalse, target);
                }
                
@@ -1287,8 +1295,10 @@ namespace Mono.CSharp {
                                        //
                                        // D and T are the same value types but D can be null
                                        //
-                                       if (d_is_nullable && !t_is_nullable)
-                                               return Nullable.HasValue.Create (expr, ec);
+                                       if (d_is_nullable && !t_is_nullable) {
+                                               expr_unwrap = Nullable.Unwrap.Create (expr, ec);
+                                               return this;
+                                       }
                                        
                                        //
                                        // The result is true if D and T are the same value types
@@ -1513,6 +1523,11 @@ namespace Mono.CSharp {
                        get { return expr; }
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        expr = expr.Resolve (ec);
@@ -2476,8 +2491,6 @@ namespace Mono.CSharp {
 
                        MethodInfo method;
                        ArrayList args = new ArrayList (2);
-
-                       args = new ArrayList (2);
                        args.Add (new Argument (left, Argument.AType.Expression));
                        args.Add (new Argument (right, Argument.AType.Expression));
 
@@ -2497,7 +2510,10 @@ namespace Mono.CSharp {
                                method = TypeManager.delegate_remove_delegate_delegate;
                        }
 
-                       return new BinaryDelegate (l, method, args);
+                       MethodGroupExpr mg = new MethodGroupExpr (new MemberInfo [] { method }, TypeManager.delegate_type, loc);
+                       mg = mg.OverloadResolve (ec, ref args, false, loc);
+
+                       return new ClassCast (new UserOperatorCall (mg, args, CreateExpressionTree, loc), l);
                }
 
                //
@@ -3456,40 +3472,6 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (method_name, args);
                }
        }
-
-       //
-       // Object created by Binary when the binary operator uses an method instead of being
-       // a binary operation that maps to a CIL binary operation.
-       //
-       public class BinaryMethod : Expression {
-               public MethodBase method;
-               public ArrayList  Arguments;
-               
-               public BinaryMethod (Type t, MethodBase m, ArrayList args)
-               {
-                       method = m;
-                       Arguments = args;
-                       type = t;
-                       eclass = ExprClass.Value;
-               }
-
-               public override Expression DoResolve (EmitContext ec)
-               {
-                       return this;
-               }
-
-               public override void Emit (EmitContext ec)
-               {
-                       ILGenerator ig = ec.ig;
-                       
-                       Invocation.EmitArguments (ec, Arguments, false, null);
-                       
-                       if (method is MethodInfo)
-                               ig.Emit (OpCodes.Call, (MethodInfo) method);
-                       else
-                               ig.Emit (OpCodes.Call, (ConstructorInfo) method);
-               }
-       }
        
        //
        // Represents the operation a + b [+ c [+ d [+ ...]]], where a is a string
@@ -3596,50 +3578,6 @@ namespace Mono.CSharp {
                }
        }
 
-       //
-       // Object created with +/= on delegates
-       //
-       public class BinaryDelegate : Expression {
-               MethodInfo method;
-               ArrayList  args;
-
-               public BinaryDelegate (Type t, MethodInfo mi, ArrayList args)
-               {
-                       method = mi;
-                       this.args = args;
-                       type = t;
-                       eclass = ExprClass.Value;
-               }
-
-               public override Expression DoResolve (EmitContext ec)
-               {
-                       return this;
-               }
-
-               public override void Emit (EmitContext ec)
-               {
-                       ILGenerator ig = ec.ig;
-                       
-                       Invocation.EmitArguments (ec, args, false, null);
-                       
-                       ig.Emit (OpCodes.Call, (MethodInfo) method);
-                       ig.Emit (OpCodes.Castclass, type);
-               }
-
-               public Expression Right {
-                       get {
-                               Argument arg = (Argument) args [1];
-                               return arg.Expr;
-                       }
-               }
-
-               public bool IsAddition {
-                       get {
-                               return method == TypeManager.delegate_combine_delegate_delegate;
-                       }
-               }
-       }
-       
        //
        // User-defined conditional logical operator
        //
@@ -5045,6 +4983,11 @@ namespace Mono.CSharp {
                        this.loc = expr.Location;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        //
@@ -6974,6 +6917,11 @@ namespace Mono.CSharp {
                        this.loc = loc;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        if (TypeManager.fieldinfo_get_field_from_handle == null) {
@@ -8235,6 +8183,17 @@ namespace Mono.CSharp {
                        throw new NotImplementedException (at.ToString ());
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       ArrayList args = new ArrayList (arguments.Count + 2);
+                       args.Add (new Argument (instance_expr.CreateExpressionTree (ec)));
+                       args.Add (new Argument (new TypeOfMethodInfo (get, loc)));
+                       foreach (Argument a in arguments)
+                               args.Add (new Argument (a.Expr.CreateExpressionTree (ec)));
+
+                       return CreateExpressionFactoryCall ("Call", args);
+               }
+
                protected virtual bool CommonResolve (EmitContext ec)
                {
                        indexer_type = instance_expr.Type;
@@ -8610,6 +8569,11 @@ namespace Mono.CSharp {
                        eclass = ExprClass.Value;
                        loc = Location.Null;
                }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
                
                public override Expression DoResolve (EmitContext ec)
                {
@@ -8650,6 +8614,11 @@ namespace Mono.CSharp {
                        loc = Location.Null;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       return null;
+               }
+
                public override void EmitStatement (EmitContext ec)
                {
                        // Do nothing
@@ -9455,6 +9424,11 @@ namespace Mono.CSharp {
                        return type;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        AnonymousTypeClass anonymous_type;

diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs
index 8d0a9a79655b4e2b74d51cd1f16e888df618ec2c..4ec6bfad3ecb6e6f1a5406b97343feee9de0a4a5 100644 (file)
--- a/mcs/mcs/iterators.cs
+++ b/mcs/mcs/iterators.cs
@@ -993,6 +993,11 @@ namespace Mono.CSharp {
                        }
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       throw new NotSupportedException ("ET");
+               }
+
                public static Iterator CreateIterator (IMethodData method, DeclSpace parent,
                                                       GenericMethod generic, int modifiers)
                {

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index 80bf5d3cbde28f117bb23f309da8cf1534c51732..b561487a33783739f9d9e3814bbaa76bfcb208a0 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -149,6 +149,11 @@ namespace Mono.CSharp {
                                return "lambda expression";
                        }
                }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       return Block.CreateExpressionTree (ec);
+               }
        }
 
        //

diff --git a/mcs/mcs/linq.cs b/mcs/mcs/linq.cs
index ff1d2857db7f73681f361b9fbed983677a58f4ab..a338dca44fed4b236eb846bd4bd498ced48dd67d 100644 (file)
--- a/mcs/mcs/linq.cs
+++ b/mcs/mcs/linq.cs
@@ -194,7 +194,7 @@ namespace Mono.CSharp.Linq
                        LambdaExpression selector = new LambdaExpression (
                                null, null, (TypeContainer)ec.TypeContainer, p, ec.CurrentBlock, loc);
                        selector.Block = new SelectorBlock (ec.CurrentBlock, p, ti, loc);
-                       selector.Block.AddStatement (new Return (expr, loc));
+                       selector.Block.AddStatement (new ContextualReturn (expr));
 
                        if (!ec.IsInProbingMode) {
                                selector.CreateAnonymousHelpers ();

diff --git a/mcs/mcs/nullable.cs b/mcs/mcs/nullable.cs
index 5e92d7e41855d4ecf65271920054e26865397da1..1b2115c7ee55a92de620777f80d7dcd5d0f5070f 100644 (file)
--- a/mcs/mcs/nullable.cs
+++ b/mcs/mcs/nullable.cs
@@ -80,44 +80,6 @@ namespace Mono.CSharp.Nullable
                        Constructor = type.GetConstructor (new Type[] { UnderlyingType });
                }
        }
-       
-       public class HasValue : Expression
-       {
-               Expression expr;
-               NullableInfo info;
-
-               private HasValue (Expression expr)
-               {
-                       this.expr = expr;
-               }
-               
-               public static Expression Create (Expression expr, EmitContext ec)
-               {
-                       return new HasValue (expr).Resolve (ec);
-               }
-
-               public override void Emit (EmitContext ec)
-               {
-                       IMemoryLocation memory_loc = expr as IMemoryLocation;
-                       if (memory_loc == null) {
-                               LocalTemporary temp = new LocalTemporary (expr.Type);
-                               expr.Emit (ec);
-                               temp.Store (ec);
-                               memory_loc = temp;
-                       }
-                       memory_loc.AddressOf (ec, AddressOp.LoadStore);
-                       ec.ig.EmitCall (OpCodes.Call, info.HasValue, null);
-               }
-
-               public override Expression DoResolve (EmitContext ec)
-               {
-                       this.info = new NullableInfo (expr.Type);
-
-                       type = TypeManager.bool_type;
-                       eclass = expr.eclass;
-                       return this;
-               }
-       }               
 
        public class Unwrap : Expression, IMemoryLocation, IAssignMethod
        {
@@ -265,6 +227,11 @@ namespace Mono.CSharp.Nullable
                                eclass = ExprClass.Value;
                        }
 
+                       public override Expression CreateExpressionTree (EmitContext ec)
+                       {
+                               throw new NotSupportedException ("ET");
+                       }
+
                        public override Expression DoResolve (EmitContext ec)
                        {
                                return this;
@@ -1108,6 +1075,11 @@ namespace Mono.CSharp.Nullable
                        eclass = ExprClass.Value;
                }
 
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       return new SimpleAssign (this, this).CreateExpressionTree (ec);
+               }
+
                public override Expression DoResolve (EmitContext ec)
                {
                        expr = expr.Resolve (ec);