namespace Mono.CSharp {
public class LambdaExpression : AnonymousMethodExpression
{
- readonly bool explicit_parameters;
-
//
// The parameters can either be:
// A list of Parameters (explicitly typed parameters)
// An ImplicitLambdaParameter
//
- public LambdaExpression (TypeContainer host, Parameters parameters, Location loc)
- : base (host, parameters, loc)
+ public LambdaExpression (Location loc)
+ : base (loc)
{
- if (parameters.Count > 0)
- explicit_parameters = !(parameters.FixedParameters [0] is ImplicitLambdaParameter);
}
- 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",
- new TypeArguments (loc, new TypeExpression (delegate_type, loc)),
+ return CreateExpressionFactoryCall (ec, "Lambda",
+ new TypeArguments (new TypeExpression (delegate_type, loc)),
arguments);
}
public override bool HasExplicitParameters {
get {
- return explicit_parameters;
+ return Parameters.Count > 0 && !(Parameters.FixedParameters [0] is ImplicitLambdaParameter);
}
}
- 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;
- ParameterData d_params = TypeManager.GetDelegateParameters (delegateType);
+ AParametersCollection d_params = TypeManager.GetDelegateParameters (ec, delegateType);
- if (explicit_parameters) {
- if (!VerifyExplicitParameters (delegateType, d_params, ec.IsInProbingMode))
+ if (HasExplicitParameters) {
+ if (!VerifyExplicitParameters (ec, delegateType, d_params))
return null;
return Parameters;
// 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;
- if (Parameters.Types == null)
- Parameters.Types = new Type [Parameters.Count];
-
+ Type [] ptypes = 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)
+ if ((d_params.FixedParameters [i].ModFlags & Parameter.Modifier.ISBYREF) != 0)
return null;
Type d_param = d_params.Types [i];
if (d_param.IsGenericParameter)
d_param = delegateType.GetGenericArguments () [d_param.GenericParameterPosition];
#endif
- // When inferred context exists all generics parameters have type replacements
+ //
+ // When type inference context exists try to apply inferred type arguments
+ //
if (tic != null) {
d_param = tic.InflateGenericArgument (d_param);
}
- Parameters.Types [i] = Parameters.FixedParameters[i].ParameterType = d_param;
+ ptypes [i] = d_param;
+ ((ImplicitLambdaParameter) Parameters.FixedParameters [i]).Type = d_param;
}
+
+ Parameters.Types = ptypes;
return Parameters;
}
- public override Expression DoResolve (EmitContext ec)
+ protected override Expression DoResolve (ResolveContext ec)
{
//
// Only explicit parameters can be resolved at this point
//
- if (explicit_parameters) {
+ if (HasExplicitParameters) {
if (!Parameters.Resolve (ec))
return null;
}
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 (Host,
- p, b, returnType,
- delegateType, loc);
+ return new LambdaMethod (p, b, returnType, delegateType, loc);
}
public override string GetSignatureForError ()
public class LambdaMethod : AnonymousMethodBody
{
- public LambdaMethod (TypeContainer host, Parameters parameters,
+ public LambdaMethod (ParametersCompiled parameters,
ToplevelBlock block, Type return_type, Type delegate_type,
Location loc)
- : base (host, parameters, block, return_type, delegate_type, 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)
{
- //
- // Remove IL method implementation when expression tree is requested
- //
- method.Parent.PartialContainer.RemoveMethod (method);
-
- 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",
- new TypeArguments (loc, new TypeExpression (type, loc)),
+ return CreateExpressionFactoryCall (ec, "Lambda",
+ new TypeArguments (new TypeExpression (type, loc)),
arguments);
}
}
//
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);
- else
- base.Emit (ec);
+ if (statement != null) {
+ statement.EmitStatement (ec);
+ ec.ig.Emit (OpCodes.Ret);
+ return;
+ }
+
+ 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
//
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);
projects / mono.git / blobdiff