// Dual licensed under the terms of the MIT X11 or GNU GPL
//
// Copyright 2007-2008 Novell, Inc
+// Copyright 2011 Xamarin Inc
//
-using System;
-using System.Collections;
-using System.Reflection;
+#if STATIC
+using IKVM.Reflection.Emit;
+#else
using System.Reflection.Emit;
+#endif
namespace Mono.CSharp {
public class LambdaExpression : AnonymousMethodExpression
{
}
- protected override Expression CreateExpressionTree (ResolveContext ec, Type delegate_type)
+ protected override Expression CreateExpressionTree (ResolveContext ec, TypeSpec delegate_type)
{
if (ec.IsInProbingMode)
return this;
- BlockContext bc = new BlockContext (ec.MemberContext, ec.CurrentBlock.Explicit, TypeManager.void_type);
+ BlockContext bc = new BlockContext (ec.MemberContext, ec.ConstructorBlock, ec.BuiltinTypes.Void) {
+ CurrentAnonymousMethod = ec.CurrentAnonymousMethod
+ };
+
Expression args = Parameters.CreateExpressionTree (bc, loc);
Expression expr = Block.CreateExpressionTree (ec);
if (expr == null)
}
}
- protected override ParametersCompiled ResolveParameters (ResolveContext ec, TypeInferenceContext tic, Type delegateType)
+ protected override ParametersCompiled ResolveParameters (ResolveContext ec, TypeInferenceContext tic, TypeSpec delegateType)
{
- if (!TypeManager.IsDelegateType (delegateType))
+ if (!delegateType.IsDelegate)
return null;
- AParametersCollection d_params = TypeManager.GetDelegateParameters (ec, delegateType);
+ AParametersCollection d_params = Delegate.GetParameters (delegateType);
if (HasExplicitParameters) {
- if (!VerifyExplicitParameters (ec, delegateType, d_params))
+ if (!VerifyExplicitParameters (ec, tic, 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 (ec, delegateType, d_params, ec.IsInProbingMode))
+ if (!VerifyParameterCompatibility (ec, tic, delegateType, d_params, ec.IsInProbingMode))
return null;
- Type [] ptypes = new Type [Parameters.Count];
+ TypeSpec [] ptypes = new TypeSpec [Parameters.Count];
for (int i = 0; i < d_params.Count; i++) {
// D has no ref or out parameters
- if ((d_params.FixedParameters [i].ModFlags & Parameter.Modifier.ISBYREF) != 0)
+ if ((d_params.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != 0)
return null;
- Type d_param = d_params.Types [i];
+ TypeSpec 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 type inference context exists try to apply inferred type arguments
//
if (tic != null) {
- d_param = tic.InflateGenericArgument (d_param);
+ d_param = tic.InflateGenericArgument (ec, d_param);
}
ptypes [i] = d_param;
- ((ImplicitLambdaParameter) Parameters.FixedParameters [i]).Type = d_param;
+ ImplicitLambdaParameter ilp = (ImplicitLambdaParameter) Parameters.FixedParameters [i];
+ ilp.SetParameterType (d_param);
+ ilp.Resolve (null, i);
}
Parameters.Types = ptypes;
return Parameters;
}
- public override Expression DoResolve (ResolveContext ec)
+ protected override AnonymousMethodBody CompatibleMethodFactory (TypeSpec returnType, TypeSpec delegateType, ParametersCompiled p, ParametersBlock b)
+ {
+ return new LambdaMethod (p, b, returnType, delegateType, loc);
+ }
+
+ protected override bool DoResolveParameters (ResolveContext rc)
{
//
// Only explicit parameters can be resolved at this point
//
if (HasExplicitParameters) {
- if (!Parameters.Resolve (ec))
- return null;
+ return Parameters.Resolve (rc);
}
- eclass = ExprClass.Value;
- type = InternalType.AnonymousMethod;
- return this;
- }
-
- protected override AnonymousMethodBody CompatibleMethodFactory (Type returnType, Type delegateType, ParametersCompiled p, ToplevelBlock b)
- {
- return new LambdaMethod (p, b, returnType, delegateType, loc);
+ return true;
}
public override string GetSignatureForError ()
{
return "lambda expression";
}
+
+ public override object Accept (StructuralVisitor visitor)
+ {
+ return visitor.Visit (this);
+ }
}
- public class LambdaMethod : AnonymousMethodBody
+ class LambdaMethod : AnonymousMethodBody
{
public LambdaMethod (ParametersCompiled parameters,
- ToplevelBlock block, Type return_type, Type delegate_type,
+ ParametersBlock block, TypeSpec return_type, TypeSpec delegate_type,
Location loc)
: base (parameters, block, return_type, delegate_type, loc)
{
}
- protected override void CloneTo (CloneContext clonectx, Expression target)
- {
- // TODO: nothing ??
- }
+ #region Properties
public override string ContainerType {
get {
}
}
+ #endregion
+
+ protected override void CloneTo (CloneContext clonectx, Expression target)
+ {
+ // TODO: nothing ??
+ }
+
public override Expression CreateExpressionTree (ResolveContext ec)
{
BlockContext bc = new BlockContext (ec.MemberContext, Block, ReturnType);
ExpressionStatement statement;
public ContextualReturn (Expression expr)
- : base (expr, expr.Location)
+ : base (expr, expr.StartLocation)
{
}
return Expr.CreateExpressionTree (ec);
}
- public override void Emit (EmitContext ec)
+ protected override void DoEmit (EmitContext ec)
{
if (statement != null) {
statement.EmitStatement (ec);
- ec.ig.Emit (OpCodes.Ret);
+ if (unwind_protect)
+ ec.Emit (OpCodes.Leave, ec.CreateReturnLabel ());
+ else {
+ ec.Emit (OpCodes.Ret);
+ }
return;
}
- base.Emit (ec);
+ base.DoEmit (ec);
}
protected override bool DoResolve (BlockContext ec)
//
// When delegate returns void, only expression statements can be used
//
- if (ec.ReturnType == TypeManager.void_type) {
+ if (ec.ReturnType.Kind == MemberKind.Void) {
Expr = Expr.Resolve (ec);
if (Expr == null)
return false;
projects / mono.git / blobdiff