2009-11-26 Sebastien Pouliot <sebastien@ximian.com>

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

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index b8e009343a27b71adaca7b9b30829d05e4c969bb..363b4bc8cac3a83826ed7d0826b3aecf17c59641 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -27,20 +27,24 @@ namespace Mono.CSharp {
                {
                }
 
-               protected override Expression CreateExpressionTree (EmitContext ec, Type delegate_type)
+               protected override Expression CreateExpressionTree (ResolveContext ec, Type delegate_type)
                {
                        if (ec.IsInProbingMode)
                                return this;
-                       
-                       Expression args = Parameters.CreateExpressionTree (ec, loc);
+
+                       BlockContext bc = new BlockContext (ec.MemberContext, ec.CurrentBlock.Explicit, TypeManager.void_type) {
+                               CurrentAnonymousMethod = ec.CurrentAnonymousMethod
+                       };
+
+                       Expression args = Parameters.CreateExpressionTree (bc, loc);
                        Expression expr = Block.CreateExpressionTree (ec);
                        if (expr == null)
                                return null;
 
-                       ArrayList arguments = new ArrayList (2);
+                       Arguments arguments = new Arguments (2);
                        arguments.Add (new Argument (expr));
                        arguments.Add (new Argument (args));
-                       return CreateExpressionFactoryCall ("Lambda",
+                       return CreateExpressionFactoryCall (ec, "Lambda",
                                new TypeArguments (new TypeExpression (delegate_type, loc)),
                                arguments);
                }
@@ -51,15 +55,15 @@ namespace Mono.CSharp {
                        }
                }
 
-               protected override Parameters ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegateType)
+               protected override ParametersCompiled ResolveParameters (ResolveContext ec, TypeInferenceContext tic, Type delegateType)
                {
                        if (!TypeManager.IsDelegateType (delegateType))
                                return null;
 
-                       AParametersCollection d_params = TypeManager.GetDelegateParameters (delegateType);
+                       AParametersCollection d_params = TypeManager.GetDelegateParameters (ec, delegateType);
 
                        if (HasExplicitParameters) {
-                               if (!VerifyExplicitParameters (delegateType, d_params, ec.IsInProbingMode))
+                               if (!VerifyExplicitParameters (ec, delegateType, d_params))
                                        return null;
 
                                return Parameters;
@@ -69,7 +73,7 @@ namespace Mono.CSharp {
                        // If L has an implicitly typed parameter list we make implicit parameters explicit
                        // Set each parameter of L is given the type of the corresponding parameter in D
                        //
-                       if (!VerifyParameterCompatibility (delegateType, d_params, ec.IsInProbingMode))
+                       if (!VerifyParameterCompatibility (ec, delegateType, d_params, ec.IsInProbingMode))
                                return null;
 
                        Type [] ptypes = new Type [Parameters.Count];
@@ -100,7 +104,7 @@ namespace Mono.CSharp {
                        return Parameters;
                }
 
-               public override Expression DoResolve (EmitContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // Only explicit parameters can be resolved at this point
@@ -111,11 +115,11 @@ namespace Mono.CSharp {
                        }
 
                        eclass = ExprClass.Value;
-                       type = TypeManager.anonymous_method_type;                                               
+                       type = InternalType.AnonymousMethod;
                        return this;
                }
 
-               protected override AnonymousMethodBody CompatibleMethodFactory (Type returnType, Type delegateType, Parameters p, ToplevelBlock b)
+               protected override AnonymousMethodBody CompatibleMethodFactory (Type returnType, Type delegateType, ParametersCompiled p, ToplevelBlock b)
                {
                        return new LambdaMethod (p, b, returnType, delegateType, loc);
                }
@@ -128,30 +132,36 @@ namespace Mono.CSharp {
 
        public class LambdaMethod : AnonymousMethodBody
        {
-               public LambdaMethod (Parameters parameters,
+               public LambdaMethod (ParametersCompiled parameters,
                                        ToplevelBlock block, Type return_type, Type delegate_type,
                                        Location loc)
                        : base (parameters, block, return_type, delegate_type, loc)
                {
                }
 
+               protected override void CloneTo (CloneContext clonectx, Expression target)
+               {
+                       // TODO: nothing ??
+               }
+
                public override string ContainerType {
                        get {
                                return "lambda expression";
                        }
                }
 
-               public override Expression CreateExpressionTree (EmitContext ec)
+               public override Expression CreateExpressionTree (ResolveContext ec)
                {
-                       Expression args = parameters.CreateExpressionTree (ec, loc);
+                       BlockContext bc = new BlockContext (ec.MemberContext, Block, ReturnType);
+                       Expression args = parameters.CreateExpressionTree (bc, loc);
                        Expression expr = Block.CreateExpressionTree (ec);
                        if (expr == null)
                                return null;
 
-                       ArrayList arguments = new ArrayList (2);
+                       Arguments arguments = new Arguments (2);
                        arguments.Add (new Argument (expr));
                        arguments.Add (new Argument (args));
-                       return CreateExpressionFactoryCall ("Lambda",
+                       return CreateExpressionFactoryCall (ec, "Lambda",
                                new TypeArguments (new TypeExpression (type, loc)),
                                arguments);
                }
@@ -164,20 +174,22 @@ namespace Mono.CSharp {
        //
        public class ContextualReturn : Return
        {
+               ExpressionStatement statement;
+
                public ContextualReturn (Expression expr)
                        : base (expr, expr.Location)
                {
                }
 
-               public override Expression CreateExpressionTree (EmitContext ec)
+               public override Expression CreateExpressionTree (ResolveContext ec)
                {
                        return Expr.CreateExpressionTree (ec);
                }
 
                public override void Emit (EmitContext ec)
                {
-                       if (ec.ReturnType == TypeManager.void_type) {
-                               ((ExpressionStatement) Expr).EmitStatement (ec);
+                       if (statement != null) {
+                               statement.EmitStatement (ec);
                                ec.ig.Emit (OpCodes.Ret);
                                return;
                        }
@@ -185,8 +197,8 @@ namespace Mono.CSharp {
                        base.Emit (ec);
                }
 
-               protected override bool DoResolve (EmitContext ec)
-               {       
+               protected override bool DoResolve (BlockContext ec)
+               {
                        //
                        // When delegate returns void, only expression statements can be used
                        //
@@ -194,12 +206,12 @@ namespace Mono.CSharp {
                                Expr = Expr.Resolve (ec);
                                if (Expr == null)
                                        return false;
-                               
-                               if (Expr is ExpressionStatement)
-                                       return true;
-                               
-                               Expr.Error_InvalidExpressionStatement ();
-                               return false;
+
+                               statement = Expr as ExpressionStatement;
+                               if (statement == null)
+                                       Expr.Error_InvalidExpressionStatement (ec);
+
+                               return true;
                        }
 
                        return base.DoResolve (ec);