mono/mcs/class/System.Core/System.Linq.Expressions/LambdaExpression.cs

//
// LambdaExpression.cs
//
// Author:
//   Jb Evain ([email protected])
//   Miguel de Icaza ([email protected])
//
// (C) 2008 Novell, Inc. (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

namespace System.Linq.Expressions {

	internal class EmitContext {
		internal LambdaExpression Owner;
		internal Type [] ParamTypes;
		internal DynamicMethod Method;
		internal ILGenerator ig;

		// When debugging:
		internal AssemblyBuilder ab;
		internal TypeBuilder tb;
		internal MethodBuilder mb;
		
		static object mlock = new object ();
		static int method_count;
		static string GenName ()
		{
			lock (mlock){
				return "<LINQ-" + method_count++ + ">";
			}
		}
		
		public EmitContext (LambdaExpression owner)
		{
			Owner = owner;

			ParamTypes = new Type [Owner.parameters.Count];
			for (int i = 0; i < Owner.parameters.Count; i++)
				ParamTypes [i] = Owner.parameters [i].Type;

			//
			// We probably want to use the 3.5 new API calls to associate
			// the method with the "sandboxed" Assembly, instead am currently
			// dumping these types in this class
			//
			Type owner_of_code = typeof (EmitContext);


			//
			// FIXME: Need to force this to be verifiable, see:
			// https://bugzilla.novell.com/show_bug.cgi?id=355005
			//
			string name = GenName ();
			if (Environment.GetEnvironmentVariable ("LINQ_DBG") != null){
				string fname = "linq" + (method_count-1) + ".dll";
				ab = Thread.GetDomain ().DefineDynamicAssembly (new AssemblyName (fname),
										AssemblyBuilderAccess.RunAndSave, "/tmp");
				ModuleBuilder b = ab.DefineDynamicModule (fname, fname);
				tb = b.DefineType ("LINQ", TypeAttributes.Public);
				mb = tb.DefineMethod ("A", MethodAttributes.Static, Owner.Type, ParamTypes);
				ig = mb.GetILGenerator ();
			} else {
				Method = new DynamicMethod (name, Owner.Type, ParamTypes, owner_of_code);
			
				ig = Method.GetILGenerator ();
			}
		}

		internal Delegate CreateDelegate ()
		{
			if (ab != null){
				tb.CreateType ();
				ab.Save ("linq" + (method_count-1) + ".dll");

				// This does not work, need to figure out why, for now
				// makes debugging harder (only one linq file will work unless
				// you do not compile them
				Delegate d = Delegate.CreateDelegate (Owner.delegate_type, tb, mb, true);

				ab = null;
				tb = null;

				//Console.WriteLine ("got: {0}", d);
				return null;
			}
			return Method.CreateDelegate (Owner.delegate_type);			
		}

		internal int GetParameterPosition (ParameterExpression p)
		{
			ReadOnlyCollection<ParameterExpression> pars = Owner.Parameters;
			
			for (int i = 0; i < pars.Count; i++){
				if (pars [i] == p)
					return i;
			}
			throw new InvalidOperationException ("Parameter not in scope");
		}
	}
	
	public class LambdaExpression : Expression {

		//
		// LambdaExpression parameters
		//
		Expression body;
		internal ReadOnlyCollection<ParameterExpression> parameters;
		internal Type delegate_type;

		// This is set during compilation
		Delegate lambda_delegate;

		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 target.IsAssignableFrom (source);
		}
				
		internal LambdaExpression (Type delegateType, Expression body, ReadOnlyCollection<ParameterExpression> parameters)
			: base (ExpressionType.Lambda, body.Type)
		{
			if (!delegateType.IsSubclassOf (typeof (System.Delegate))){
				throw new ArgumentException ("delegateType");
			}
			
			MethodInfo [] invokes = delegateType.GetMethods (BindingFlags.Instance | BindingFlags.Public);
			MethodInfo invoke = null;
			foreach (MethodInfo m in invokes)
				if (m.Name == "Invoke"){
					invoke = m;
					break;
				}
			if (invoke == null)
				throw new ArgumentException ("delegate must contain an Invoke method", "delegateType");

			ParameterInfo [] invoke_parameters = invoke.GetParameters ();
			if (invoke_parameters.Length != parameters.Count)
				throw new ArgumentException ("Different number of arguments in delegate {0}", "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 (!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;
			delegate_type = delegateType;
		}
		
		public Expression Body {
			get { return body; }
		}

		public ReadOnlyCollection<ParameterExpression> Parameters {
			get { return parameters; }
		}

		internal override void Emit (EmitContext ec)
		{
			throw new NotImplementedException ();
		}
		
		public Delegate Compile ()
		{
			if (lambda_delegate == null){
				EmitContext ec = new EmitContext (this);
				
				body.Emit (ec);

				ec.ig.Emit (OpCodes.Ret);

				lambda_delegate = ec.CreateDelegate ();
			}
			return lambda_delegate;
		}
	}
}