// 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;
// 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);
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);
}
}
}
- 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)
{
}
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);
+ }
}
//
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
return false;
}
- return base.Resolve (ec);
+ return base.DoResolve (ec);
}
}
}