// lambda.cs: support for lambda expressions
//
// Authors: Miguel de Icaza (miguel@gnu.org)
+// Marek Safar (marek.safar@gmail.com)
//
// Licensed under the terms of the GNU GPL
//
using System.Reflection.Emit;
namespace Mono.CSharp {
- public class LambdaExpression : AnonymousMethodExpression {
- bool explicit_parameters;
+ public class LambdaExpression : AnonymousMethodExpression
+ {
+ readonly bool explicit_parameters;
//
- // If set, this was a lambda expression with an expression
- // argument. And if so, we have a pointer to it, so we can
- // change it if needed.
- //
- Expression lambda_expr;
-
- //
- // The parameter list can either be:
- // null: no parameters
- // arraylist of Parameter (explicitly typed parameters)
- // arraylist of strings (implicitly typed parameters)
+ // The parameters can either be:
+ // A list of Parameters (explicitly typed parameters)
+ // An ImplicitLambdaParameter
//
public LambdaExpression (AnonymousMethodExpression parent,
GenericMethod generic, TypeContainer host,
Location loc)
: base (parent, generic, host, parameters, container, loc)
{
- explicit_parameters = (parameters != null && parameters.Count > 0 && parameters [0].TypeName != null);
- if (parameters == null)
- Parameters = new Parameters (new Parameter [0]);
+ if (parameters.Count > 0)
+ explicit_parameters = !(parameters.FixedParameters [0] is ImplicitLambdaParameter);
}
- public void SetExpression (Expression expr)
+ public static Expression System_Linq_Expressions;
+ public static Expression System_Linq_Expressions_Expression;
+
+ protected override Expression CreateExpressionTree (EmitContext ec, Type delegate_type)
{
- lambda_expr = expr;
+ System_Linq_Expressions = new MemberAccess (
+ new MemberAccess (new SimpleName ("System", loc), "Linq", loc), "Expressions", loc);
+
+ System_Linq_Expressions_Expression = new MemberAccess (
+ System_Linq_Expressions, "Expression", loc);
+
+ MemberAccess lambda = new MemberAccess (System_Linq_Expressions_Expression, "Lambda",
+ new TypeArguments (loc, new TypeExpression (delegate_type, loc)), loc);
+
+ 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));
+ Expression invocation = new Invocation (lambda, arguments);
+
+ return invocation;
}
-
- public override Expression DoResolve (EmitContext ec)
- {
- eclass = ExprClass.Value;
- type = TypeManager.anonymous_method_type;
- if (explicit_parameters){
- if (!Parameters.Resolve (ec))
- return null;
+ public override bool HasExplicitParameters {
+ get {
+ return explicit_parameters;
}
-
- // We will resolve parameters later, we do not
- // have information at this point.
-
- return this;
}
- public override void Emit (EmitContext ec)
+ protected override Parameters ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegateType)
{
- base.Emit (ec);
- }
+ if (!TypeManager.IsDelegateType (delegateType))
+ return null;
- //
- // Returns true if this anonymous method can be implicitly
- // converted to the delegate type `delegate_type'
- //
- public override Expression Compatible (EmitContext ec, Type delegate_type)
- {
- if (anonymous != null)
- return anonymous.AnonymousDelegate;
+ ParameterData d_params = TypeManager.GetDelegateParameters (delegateType);
- if (CompatibleChecks (ec, delegate_type) == null)
- return null;
+ if (explicit_parameters) {
+ if (!VerifyExplicitParameters (delegateType, d_params, ec.IsInProbingMode))
+ return null;
- MethodGroupExpr invoke_mg = Delegate.GetInvokeMethod (
- ec.ContainerType, delegate_type, loc);
- MethodInfo invoke_mb = (MethodInfo) invoke_mg.Methods [0];
- ParameterData invoke_pd = TypeManager.GetParameterData (invoke_mb);
+ return Parameters;
+ }
//
- // The lambda expression is compatible with the delegate type,
- // provided that:
+ // 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
//
-
- //
- // D and L have the same number of arguments.
- if (Parameters.Count != invoke_pd.Count)
+ if (!VerifyParameterCompatibility (delegateType, d_params, ec.IsInProbingMode))
return null;
- Parameters parameters_copy = Parameters.Clone ();
- if (explicit_parameters){
- //
- // If L has an explicitly typed parameter list, each parameter
- // in D has the same type and modifiers as the corresponding
- // parameter in L.
- //
- if (!VerifyExplicitParameterCompatibility (delegate_type, invoke_pd))
+ if (Parameters.Types == null)
+ Parameters.Types = new Type [Parameters.Count];
+
+ for (int i = 0; i < d_params.Count; i++) {
+ // D has no ref or out parameters
+ if ((d_params.ParameterModifier (i) & Parameter.Modifier.ISBYREF) != 0)
return null;
- parameters_copy = Parameters.Clone ();
- } else {
- //
- // If L has an implicitly typed parameter list, D has no ref or
- // out parameters
- //
- // Note: We currently do nothing, because the preview does not
- // follow the above rule.
-
- //
- // each parameter of L is given the type of the corresponding parameter in D
- //
-
- for (int i = 0; i < invoke_pd.Count; i++)
- parameters_copy [i].TypeName = new TypeExpression (
- invoke_pd.ParameterType (i),
- parameters_copy [i].Location);
+ Type d_param = d_params.Types [i];
+
+#if MS_COMPATIBLE
+ // Blablabla, because reflection does not work with dynamic types
+ if (d_param.IsGenericParameter)
+ d_param = delegateType.GetGenericArguments () [d_param.GenericParameterPosition];
+#endif
+ // When inferred context exists all generics parameters have type replacements
+ if (tic != null) {
+ d_param = tic.InflateGenericArgument (d_param);
+ }
+
+ Parameters.Types [i] = Parameters.FixedParameters[i].ParameterType = d_param;
}
+ return Parameters;
+ }
+ public override Expression DoResolve (EmitContext ec)
+ {
//
- // The return type of the delegate must be compatible with
- // the anonymous type. Instead of doing a pass to examine the block
- // we satisfy the rule by setting the return type on the EmitContext
- // to be the delegate type return type.
+ // Only explicit parameters can be resolved at this point
//
+ if (explicit_parameters) {
+ if (!Parameters.Resolve (ec))
+ return null;
+ }
- anonymous = new AnonymousMethod (
- Parent != null ? Parent.AnonymousMethod : null, RootScope, Host,
- GenericMethod, parameters_copy, Container, Block, invoke_mb.ReturnType,
- delegate_type, loc);
+ eclass = ExprClass.Value;
+ type = TypeManager.anonymous_method_type;
+ return this;
+ }
- if (!anonymous.Resolve (ec))
- return null;
+ protected override AnonymousMethod CompatibleMethodFactory (Type returnType, Type delegateType, Parameters p, ToplevelBlock b)
+ {
+ return new LambdaMethod (RootScope, Host,
+ GenericMethod, p, Container, b, returnType,
+ delegateType, loc);
+ }
+
+ public override string GetSignatureForError ()
+ {
+ return "lambda expression";
+ }
+ }
+
+ public class LambdaMethod : AnonymousMethod
+ {
+ public LambdaMethod (RootScopeInfo root_scope,
+ DeclSpace host, GenericMethod generic,
+ Parameters parameters, Block container,
+ ToplevelBlock block, Type return_type, Type delegate_type,
+ Location loc)
+ : base (root_scope, host, generic, parameters, container, block,
+ return_type, delegate_type, loc)
+ {
+ }
- return anonymous.AnonymousDelegate;
+ public override string ContainerType {
+ get {
+ return "lambda expression";
+ }
}
}
// to be expressions. Depending on the return type of the delegate this will behave
// as either { expr (); return (); } or { return expr (); }
//
- public class ContextualReturn : Statement {
- public Expression Expr;
-
- public ContextualReturn (Expression e)
+ public class ContextualReturn : Return
+ {
+ bool statement_return;
+
+ public ContextualReturn (Expression expr)
+ : base (expr, expr.Location)
{
- Expr = e;
- loc = Expr.Location;
}
- bool unwind_protect;
-
- public override bool Resolve (EmitContext ec)
+ public override Expression CreateExpressionTree (EmitContext ec)
{
- AnonymousContainer am = ec.CurrentAnonymousMethod;
- if ((am != null) && am.IsIterator && ec.InIterator) {
- Report.Error (1622, loc, "Cannot return a value from iterators. Use the yield return " +
- "statement to return a value, or yield break to end the iteration");
- return false;
- }
-
- Expr = Expr.Resolve (ec);
- if (Expr == null)
- return false;
+ return Expr.CreateExpressionTree (ec);
+ }
- if (ec.ReturnType == null){
- if (!(Expr is ExpressionStatement)){
- Expression.Error_InvalidExpressionStatement (Expr.Location);
- return false;
- }
- } else {
- if (Expr.Type != ec.ReturnType) {
- Expr = Convert.ImplicitConversionRequired (
- ec, Expr, ec.ReturnType, loc);
- if (Expr == null)
- return false;
+ public override void Emit (EmitContext ec)
+ {
+ if (statement_return) {
+ ExpressionStatement es = Expr as ExpressionStatement;
+ if (es == null) {
+ Expr.Error_InvalidExpressionStatement ();
+ return;
}
+
+ es.EmitStatement (ec);
+ return;
}
-
- int errors = Report.Errors;
- unwind_protect = ec.CurrentBranching.AddReturnOrigin (ec.CurrentBranching.CurrentUsageVector, loc);
- if (unwind_protect)
- ec.NeedReturnLabel ();
- ec.CurrentBranching.CurrentUsageVector.Return ();
- return errors == Report.Errors;
+
+ base.Emit (ec);
}
-
- protected override void DoEmit (EmitContext ec)
- {
- Expr.Emit (ec);
- if (unwind_protect){
- ec.ig.Emit (OpCodes.Stloc, ec.TemporaryReturn ());
- ec.ig.Emit (OpCodes.Leave, ec.ReturnLabel);
- }
- ec.ig.Emit (OpCodes.Ret);
+ public override bool Resolve (EmitContext ec)
+ {
+ if (ec.ReturnType == TypeManager.void_type) {
+ statement_return = true;
+ return Expr.Resolve (ec) != null;
+ }
+
+ return base.Resolve (ec);
}
-
}
}