Merge pull request #498 from Unroll-Me/master

[mono.git] / mcs / class / System.Core / System.Linq.Expressions / LambdaExpression.cs

diff --git a/mcs/class/System.Core/System.Linq.Expressions/LambdaExpression.cs b/mcs/class/System.Core/System.Linq.Expressions/LambdaExpression.cs
index 5b32e5a14f4dca59e4cbab917720ebb8610b40c6..92a40c6d4b7f220bf1591ba48ff3b976b833fd00 100644 (file)
--- a/mcs/class/System.Core/System.Linq.Expressions/LambdaExpression.cs
+++ b/mcs/class/System.Core/System.Linq.Expressions/LambdaExpression.cs
@@ -48,41 +48,14 @@ namespace System.Linq.Expressions {
                        get { return parameters; }
                }
 
-               static bool CanAssign (Type target, Type source)
-               {
-                       // This catches object and value type mixage, type compatibility is handled later
-                       if (target.IsValueType ^ source.IsValueType)
-                               return false;
-
-                       return source.IsAssignableTo (target);
-               }
-
                internal LambdaExpression (Type delegateType, Expression body, ReadOnlyCollection<ParameterExpression> parameters)
                        : base (ExpressionType.Lambda, delegateType)
                {
-                       if (!delegateType.IsSubclassOf (typeof (System.Delegate)))
-                               throw new ArgumentException ("delegateType");
-
-                       var invoke = delegateType.GetMethod ("Invoke", BindingFlags.Instance | BindingFlags.Public);
-                       if (invoke == null)
-                               throw new ArgumentException ("delegate must contain an Invoke method", "delegateType");
-
-                       var invoke_parameters = invoke.GetParameters ();
-                       if (invoke_parameters.Length != parameters.Count)
-                               throw new ArgumentException (string.Format ("Different number of arguments in delegate {0}", delegateType), "delegateType");
-
-                       for (int i = 0; i < invoke_parameters.Length; i++){
-                               if (!CanAssign (parameters [i].Type, invoke_parameters [i].ParameterType))
-                                       throw new ArgumentException (String.Format ("Can not assign a {0} to a {1}", invoke_parameters [i].ParameterType, parameters [i].Type));
-                       }
-
-                       if (invoke.ReturnType != typeof (void) && !CanAssign (invoke.ReturnType, body.Type))
-                               throw new ArgumentException (String.Format ("body type {0} can not be assigned to {1}", body.Type, invoke.ReturnType));
-
                        this.body = body;
                        this.parameters = parameters;
                }
 
+#if !FULL_AOT_RUNTIME
                void EmitPopIfNeeded (EmitContext ec)
                {
                        if (GetReturnType () == typeof (void) && body.Type != typeof (void))
@@ -90,28 +63,39 @@ namespace System.Linq.Expressions {
                }
 
                internal override void Emit (EmitContext ec)
+               {
+                       ec.EmitCreateDelegate (this);
+               }
+
+               internal void EmitBody (EmitContext ec)
                {
                        body.Emit (ec);
                        EmitPopIfNeeded (ec);
                        ec.ig.Emit (OpCodes.Ret);
                }
+#endif
 
                internal Type GetReturnType ()
                {
-                       return this.Type.GetMethod ("Invoke").ReturnType;
+                       return this.Type.GetInvokeMethod ().ReturnType;
                }
 
                public Delegate Compile ()
                {
-#if TARGET_JVM
-                       System.Linq.jvm.Interpreter inter = 
-                               new System.Linq.jvm.Interpreter (this);
-                       inter.Validate ();
-                       return inter.CreateDelegate ();        
+#if TARGET_JVM || MONOTOUCH
+                       return new System.Linq.jvm.Runner (this).CreateDelegate ();
 #else
-                       var context = EmitContext.Create (this);
+                       var context = new CompilationContext ();
+                       context.AddCompilationUnit (this);
                        return context.CreateDelegate ();
 #endif
                }
+
+#if TARGET_JVM || MONOTOUCH
+               internal Delegate Compile (System.Linq.jvm.ExpressionInterpreter interpreter)
+               {
+                       return new System.Linq.jvm.Runner (this, interpreter).CreateDelegate ();
+               }
+#endif
        }
 }