2008-07-22 Marek Safar <marek.safar@gmail.com>

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

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index c500d323bdff91cb8e5900cccbc1f9e3254f0470..b11dc6000e254d2c8c6beec1f9ce9445c9891e56 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -4,9 +4,9 @@
 // Authors: Miguel de Icaza (miguel@gnu.org)
 //          Marek Safar (marek.safar@gmail.com)
 //
-// Licensed under the terms of the GNU GPL
+// Dual licensed under the terms of the MIT X11 or GNU GPL
 //
-// (C) 2007 Novell, Inc
+// Copyright 2007-2008 Novell, Inc
 //
 
 using System;
@@ -24,11 +24,8 @@ namespace Mono.CSharp {
                //    A list of Parameters (explicitly typed parameters)
                //    An ImplicitLambdaParameter
                //
-               public LambdaExpression (AnonymousMethodExpression parent,
-                                        GenericMethod generic, TypeContainer host,
-                                        Parameters parameters, Block container,
-                                        Location loc)
-                       : base (parent, generic, host, parameters, container, loc)
+               public LambdaExpression (TypeContainer host, Parameters parameters, Location loc)
+                       : base (host, parameters, loc)
                {
                        if (parameters.Count > 0)
                                explicit_parameters = !(parameters.FixedParameters [0] is ImplicitLambdaParameter);
@@ -119,10 +116,10 @@ namespace Mono.CSharp {
                        return this;
                }
 
-               protected override AnonymousMethod CompatibleMethodFactory (Type returnType, Type delegateType, Parameters p, ToplevelBlock b)
+               protected override AnonymousMethodBody CompatibleMethodFactory (Type returnType, Type delegateType, Parameters p, ToplevelBlock b)
                {
-                       return new LambdaMethod (RootScope, Host,
-                               GenericMethod, p, Container, b, returnType,
+                       return new LambdaMethod (Host,
+                               p, b, returnType,
                                delegateType, loc);
                }
 
@@ -132,15 +129,12 @@ namespace Mono.CSharp {
                }
        }
 
-       public class LambdaMethod : AnonymousMethod
+       public class LambdaMethod : AnonymousMethodBody
        {
-               public LambdaMethod (RootScopeInfo root_scope,
-                                       DeclSpace host, GenericMethod generic,
-                                       Parameters parameters, Block container,
+               public LambdaMethod (TypeContainer host, Parameters parameters,
                                        ToplevelBlock block, Type return_type, Type delegate_type,
                                        Location loc)
-                       : base (root_scope, host, generic, parameters, container, block,
-                               return_type, delegate_type, loc)
+                       : base (host, parameters, block, return_type, delegate_type, loc)
                {
                }
 
@@ -149,6 +143,26 @@ namespace Mono.CSharp {
                                return "lambda expression";
                        }
                }
+
+               public override Expression CreateExpressionTree (EmitContext ec)
+               {
+                       //
+                       // Remove IL method implementation when expression tree is requested
+                       //
+                       method.Parent.PartialContainer.RemoveMethod (method);
+
+                       Expression args = parameters.CreateExpressionTree (ec, loc);
+                       Expression expr = Block.CreateExpressionTree (ec);
+                       if (expr == null)
+                               return null;
+
+                       ArrayList arguments = new ArrayList (2);
+                       arguments.Add (new Argument (expr));
+                       arguments.Add (new Argument (args));
+                       return CreateExpressionFactoryCall ("Lambda",
+                               new TypeArguments (loc, new TypeExpression (type, loc)),
+                               arguments);
+               }
        }
 
        //
@@ -170,13 +184,16 @@ namespace Mono.CSharp {
 
                public override void Emit (EmitContext ec)
                {
-                       if (ec.ReturnType == TypeManager.void_type)
+                       if (ec.ReturnType == TypeManager.void_type) {
                                ((ExpressionStatement) Expr).EmitStatement (ec);
-                       else
-                               base.Emit (ec);
+                               ec.ig.Emit (OpCodes.Ret);
+                               return;
+                       }
+
+                       base.Emit (ec);
                }
 
-               public override bool Resolve (EmitContext ec)
+               protected override bool DoResolve (EmitContext ec)
                {       
                        //
                        // When delegate returns void, only expression statements can be used
@@ -193,7 +210,7 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       return base.Resolve (ec);
+                       return base.DoResolve (ec);
                }
        }
 }