1 /* ****************************************************************************
3 * Copyright (c) Microsoft Corporation.
5 * This source code is subject to terms and conditions of the Apache License, Version 2.0. A
6 * copy of the license can be found in the License.html file at the root of this distribution. If
7 * you cannot locate the Apache License, Version 2.0, please send an email to
8 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
9 * by the terms of the Apache License, Version 2.0.
11 * You must not remove this notice, or any other, from this software.
14 * ***************************************************************************/
17 using System.Collections.Generic;
18 using System.Collections.ObjectModel;
19 using System.Diagnostics;
20 using System.Dynamic.Utils;
21 using System.Reflection;
22 using System.Reflection.Emit;
23 using System.Threading;
24 using System.Runtime.CompilerServices;
31 namespace Microsoft.Scripting.Ast {
33 namespace System.Linq.Expressions {
38 /// Creates a <see cref="LambdaExpression"/> node.
39 /// This captures a block of code that is similar to a .NET method body.
42 /// Lambda expressions take input through parameters and are expected to be fully bound.
45 [DebuggerTypeProxy(typeof(Expression.LambdaExpressionProxy))]
47 public abstract class LambdaExpression : Expression {
48 private readonly string _name;
49 private readonly Expression _body;
50 private readonly ReadOnlyCollection<ParameterExpression> _parameters;
51 private readonly Type _delegateType;
52 private readonly bool _tailCall;
54 internal LambdaExpression(
59 ReadOnlyCollection<ParameterExpression> parameters
62 Debug.Assert(delegateType != null);
66 _parameters = parameters;
67 _delegateType = delegateType;
72 /// Gets the static type of the expression that this <see cref="Expression" /> represents. (Inherited from <see cref="Expression"/>.)
74 /// <returns>The <see cref="Type"/> that represents the static type of the expression.</returns>
75 public sealed override Type Type {
76 get { return _delegateType; }
80 /// Returns the node type of this <see cref="Expression" />. (Inherited from <see cref="Expression" />.)
82 /// <returns>The <see cref="ExpressionType"/> that represents this expression.</returns>
83 public sealed override ExpressionType NodeType {
84 get { return ExpressionType.Lambda; }
88 /// Gets the parameters of the lambda expression.
90 public ReadOnlyCollection<ParameterExpression> Parameters {
91 get { return _parameters; }
95 /// Gets the name of the lambda expression.
97 /// <remarks>Used for debugging purposes.</remarks>
103 /// Gets the body of the lambda expression.
105 public Expression Body {
106 get { return _body; }
110 /// Gets the return type of the lambda expression.
112 public Type ReturnType {
113 get { return Type.GetMethod("Invoke").ReturnType; }
117 /// Gets the value that indicates if the lambda expression will be compiled with
118 /// tail call optimization.
120 public bool TailCall {
121 get { return _tailCall; }
125 /// Produces a delegate that represents the lambda expression.
127 /// <returns>A delegate containing the compiled version of the lambda.</returns>
128 public Delegate Compile() {
129 return LambdaCompiler.Compile(this, null);
133 /// Produces a delegate that represents the lambda expression.
135 /// <param name="debugInfoGenerator">Debugging information generator used by the compiler to mark sequence points and annotate local variables.</param>
136 /// <returns>A delegate containing the compiled version of the lambda.</returns>
137 public Delegate Compile(DebugInfoGenerator debugInfoGenerator) {
138 ContractUtils.RequiresNotNull(debugInfoGenerator, "debugInfoGenerator");
139 return LambdaCompiler.Compile(this, debugInfoGenerator);
143 /// Compiles the lambda into a method definition.
145 /// <param name="method">A <see cref="MethodBuilder"/> which will be used to hold the lambda's IL.</param>
146 public void CompileToMethod(MethodBuilder method) {
147 CompileToMethodInternal(method, null);
151 /// Compiles the lambda into a method definition and custom debug information.
153 /// <param name="method">A <see cref="MethodBuilder"/> which will be used to hold the lambda's IL.</param>
154 /// <param name="debugInfoGenerator">Debugging information generator used by the compiler to mark sequence points and annotate local variables.</param>
155 public void CompileToMethod(MethodBuilder method, DebugInfoGenerator debugInfoGenerator) {
156 ContractUtils.RequiresNotNull(debugInfoGenerator, "debugInfoGenerator");
157 CompileToMethodInternal(method, debugInfoGenerator);
160 private void CompileToMethodInternal(MethodBuilder method, DebugInfoGenerator debugInfoGenerator) {
161 ContractUtils.RequiresNotNull(method, "method");
162 ContractUtils.Requires(method.IsStatic, "method");
163 var type = method.DeclaringType as TypeBuilder;
164 if (type == null) throw Error.MethodBuilderDoesNotHaveTypeBuilder();
166 LambdaCompiler.Compile(this, method, debugInfoGenerator);
169 internal abstract LambdaExpression Accept(StackSpiller spiller);
173 /// Defines a <see cref="Expression{TDelegate}"/> node.
174 /// This captures a block of code that is similar to a .NET method body.
176 /// <typeparam name="TDelegate">The type of the delegate.</typeparam>
178 /// Lambda expressions take input through parameters and are expected to be fully bound.
180 public sealed class Expression<TDelegate> : LambdaExpression {
181 internal Expression(Expression body, string name, bool tailCall, ReadOnlyCollection<ParameterExpression> parameters)
182 : base(typeof(TDelegate), name, body, tailCall, parameters) {
186 /// Produces a delegate that represents the lambda expression.
188 /// <returns>A delegate containing the compiled version of the lambda.</returns>
189 public new TDelegate Compile() {
190 return (TDelegate)(object)LambdaCompiler.Compile(this, null);
194 /// Produces a delegate that represents the lambda expression.
196 /// <param name="debugInfoGenerator">Debugging information generator used by the compiler to mark sequence points and annotate local variables.</param>
197 /// <returns>A delegate containing the compiled version of the lambda.</returns>
198 public new TDelegate Compile(DebugInfoGenerator debugInfoGenerator) {
199 ContractUtils.RequiresNotNull(debugInfoGenerator, "debugInfoGenerator");
200 return (TDelegate)(object)LambdaCompiler.Compile(this, debugInfoGenerator);
204 /// Creates a new expression that is like this one, but using the
205 /// supplied children. If all of the children are the same, it will
206 /// return this expression.
208 /// <param name="body">The <see cref="LambdaExpression.Body">Body</see> property of the result.</param>
209 /// <param name="parameters">The <see cref="LambdaExpression.Parameters">Parameters</see> property of the result.</param>
210 /// <returns>This expression if no children changed, or an expression with the updated children.</returns>
211 public Expression<TDelegate> Update(Expression body, IEnumerable<ParameterExpression> parameters) {
212 if (body == Body && parameters == Parameters) {
215 return Expression.Lambda<TDelegate>(body, Name, TailCall, parameters);
219 /// Dispatches to the specific visit method for this node type.
221 protected internal override Expression Accept(ExpressionVisitor visitor) {
222 return visitor.VisitLambda(this);
225 internal override LambdaExpression Accept(StackSpiller spiller) {
226 return spiller.Rewrite(this);
229 internal static LambdaExpression Create(Expression body, string name, bool tailCall, ReadOnlyCollection<ParameterExpression> parameters) {
230 return new Expression<TDelegate>(body, name, tailCall, parameters);
235 public partial class Expression {
238 /// Creates an Expression{T} given the delegate type. Caches the
239 /// factory method to speed up repeated creations for the same T.
241 internal static LambdaExpression CreateLambda(Type delegateType, Expression body, string name, bool tailCall, ReadOnlyCollection<ParameterExpression> parameters) {
242 // Get or create a delegate to the public Expression.Lambda<T>
243 // method and call that will be used for creating instances of this
245 LambdaFactory fastPath;
246 var factories = _LambdaFactories;
247 if (factories == null) {
248 _LambdaFactories = factories = new CacheDict<Type, LambdaFactory>(50);
251 MethodInfo create = null;
252 if (!factories.TryGetValue(delegateType, out fastPath)) {
253 create = typeof(Expression<>).MakeGenericType(delegateType).GetMethod("Create", BindingFlags.Static | BindingFlags.NonPublic);
254 if (TypeUtils.CanCache(delegateType)) {
255 factories[delegateType] = fastPath = (LambdaFactory)Delegate.CreateDelegate(typeof(LambdaFactory), create);
259 if (fastPath != null) {
260 return fastPath(body, name, tailCall, parameters);
263 Debug.Assert(create != null);
264 return (LambdaExpression)create.Invoke(null, new object[] { body, name, tailCall, parameters });
268 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
270 /// <typeparam name="TDelegate">The delegate type. </typeparam>
271 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
272 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
273 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
274 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters) {
275 return Lambda<TDelegate>(body, false, (IEnumerable<ParameterExpression>)parameters);
279 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
281 /// <typeparam name="TDelegate">The delegate type. </typeparam>
282 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
283 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
284 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
285 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
286 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, params ParameterExpression[] parameters) {
287 return Lambda<TDelegate>(body, tailCall, (IEnumerable<ParameterExpression>)parameters);
291 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
293 /// <typeparam name="TDelegate">The delegate type. </typeparam>
294 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
295 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
296 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
297 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, IEnumerable<ParameterExpression> parameters) {
298 return Lambda<TDelegate>(body, null, false, parameters);
302 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
304 /// <typeparam name="TDelegate">The delegate type. </typeparam>
305 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
306 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
307 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
308 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
309 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters) {
310 return Lambda<TDelegate>(body, null, tailCall, parameters);
314 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
316 /// <typeparam name="TDelegate">The delegate type. </typeparam>
317 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
318 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
319 /// <param name="name">The name of the lambda. Used for generating debugging info.</param>
320 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
321 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, String name, IEnumerable<ParameterExpression> parameters) {
322 return Lambda<TDelegate>(body, name, false, parameters);
326 /// Creates an <see cref="Expression{TDelegate}"/> where the delegate type is known at compile time.
328 /// <typeparam name="TDelegate">The delegate type. </typeparam>
329 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
330 /// <param name="name">The name of the lambda. Used for generating debugging info.</param>
331 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
332 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
333 /// <returns>An <see cref="Expression{TDelegate}"/> that has the <see cref="P:NodeType"/> property equal to <see cref="P:Lambda"/> and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
334 public static Expression<TDelegate> Lambda<TDelegate>(Expression body, String name, bool tailCall, IEnumerable<ParameterExpression> parameters) {
335 var parameterList = parameters.ToReadOnly();
336 ValidateLambdaArgs(typeof(TDelegate), ref body, parameterList);
337 return new Expression<TDelegate>(body, name, tailCall, parameterList);
342 /// Creates a LambdaExpression by first constructing a delegate type.
344 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
345 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
346 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
347 public static LambdaExpression Lambda(Expression body, params ParameterExpression[] parameters) {
348 return Lambda(body, false, (IEnumerable<ParameterExpression>)parameters);
352 /// Creates a LambdaExpression by first constructing a delegate type.
354 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
355 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
356 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
357 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
358 public static LambdaExpression Lambda(Expression body, bool tailCall, params ParameterExpression[] parameters) {
359 return Lambda(body, tailCall, (IEnumerable<ParameterExpression>)parameters);
363 /// Creates a LambdaExpression by first constructing a delegate type.
365 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
366 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
367 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
368 public static LambdaExpression Lambda(Expression body, IEnumerable<ParameterExpression> parameters) {
369 return Lambda(body, null, false, parameters);
373 /// Creates a LambdaExpression by first constructing a delegate type.
375 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
376 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
377 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
378 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
379 public static LambdaExpression Lambda(Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters) {
380 return Lambda(body, null, tailCall, parameters);
384 /// Creates a LambdaExpression by first constructing a delegate type.
386 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
387 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
388 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
389 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
390 public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters) {
391 return Lambda(delegateType, body, null, false, parameters);
395 /// Creates a LambdaExpression by first constructing a delegate type.
397 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
398 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
399 /// <param name="parameters">An array that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
400 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
401 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
402 public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, params ParameterExpression[] parameters) {
403 return Lambda(delegateType, body, null, tailCall, parameters);
407 /// Creates a LambdaExpression by first constructing a delegate type.
409 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
410 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
411 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
412 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
413 public static LambdaExpression Lambda(Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters) {
414 return Lambda(delegateType, body, null, false, parameters);
418 /// Creates a LambdaExpression by first constructing a delegate type.
420 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
421 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
422 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
423 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
424 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
425 public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters) {
426 return Lambda(delegateType, body, null, tailCall, parameters);
430 /// Creates a LambdaExpression by first constructing a delegate type.
432 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
433 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
434 /// <param name="name">The name for the lambda. Used for emitting debug information.</param>
435 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
436 public static LambdaExpression Lambda(Expression body, string name, IEnumerable<ParameterExpression> parameters) {
437 return Lambda(body, name, false, parameters);
441 /// Creates a LambdaExpression by first constructing a delegate type.
443 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
444 /// <param name="name">The name for the lambda. Used for emitting debug information.</param>
445 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
446 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
447 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
448 public static LambdaExpression Lambda(Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters) {
449 ContractUtils.RequiresNotNull(body, "body");
451 var parameterList = parameters.ToReadOnly();
453 int paramCount = parameterList.Count;
454 Type[] typeArgs = new Type[paramCount + 1];
455 if (paramCount > 0) {
456 var set = new Set<ParameterExpression>(parameterList.Count);
457 for (int i = 0; i < paramCount; i++) {
458 var param = parameterList[i];
459 ContractUtils.RequiresNotNull(param, "parameter");
460 typeArgs[i] = param.IsByRef ? param.Type.MakeByRefType() : param.Type;
461 if (set.Contains(param)) {
462 throw Error.DuplicateVariable(param);
467 typeArgs[paramCount] = body.Type;
469 Type delegateType = DelegateHelpers.MakeDelegateType(typeArgs);
471 return CreateLambda(delegateType, body, name, tailCall, parameterList);
475 /// Creates a LambdaExpression by first constructing a delegate type.
477 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
478 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
479 /// <param name="name">The name for the lambda. Used for emitting debug information.</param>
480 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
481 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
482 public static LambdaExpression Lambda(Type delegateType, Expression body, string name, IEnumerable<ParameterExpression> parameters) {
483 var paramList = parameters.ToReadOnly();
484 ValidateLambdaArgs(delegateType, ref body, paramList);
486 return CreateLambda(delegateType, body, name, false, paramList);
490 /// Creates a LambdaExpression by first constructing a delegate type.
492 /// <param name="delegateType">A <see cref="Type"/> representing the delegate signature for the lambda.</param>
493 /// <param name="body">An <see cref="Expression"/> to set the <see cref="P:Body"/> property equal to. </param>
494 /// <param name="name">The name for the lambda. Used for emitting debug information.</param>
495 /// <param name="tailCall">A <see cref="Boolean"/> that indicates if tail call optimization will be applied when compiling the created expression. </param>
496 /// <param name="parameters">An <see cref="IEnumerable{T}"/> that contains <see cref="ParameterExpression"/> objects to use to populate the <see cref="P:Parameters"/> collection. </param>
497 /// <returns>A <see cref="LambdaExpression"/> that has the <see cref="P:NodeType"/> property equal to Lambda and the <see cref="P:Body"/> and <see cref="P:Parameters"/> properties set to the specified values.</returns>
498 public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters) {
499 var paramList = parameters.ToReadOnly();
500 ValidateLambdaArgs(delegateType, ref body, paramList);
502 return CreateLambda(delegateType, body, name, tailCall, paramList);
505 private static void ValidateLambdaArgs(Type delegateType, ref Expression body, ReadOnlyCollection<ParameterExpression> parameters) {
506 ContractUtils.RequiresNotNull(delegateType, "delegateType");
507 RequiresCanRead(body, "body");
509 if (!typeof(MulticastDelegate).IsAssignableFrom(delegateType) || delegateType == typeof(MulticastDelegate)) {
510 throw Error.LambdaTypeMustBeDerivedFromSystemDelegate();
514 var ldc = _LambdaDelegateCache;
515 if (!ldc.TryGetValue(delegateType, out mi)) {
516 mi = delegateType.GetMethod("Invoke");
517 if (TypeUtils.CanCache(delegateType)) {
518 ldc[delegateType] = mi;
522 ParameterInfo[] pis = mi.GetParametersCached();
524 if (pis.Length > 0) {
525 if (pis.Length != parameters.Count) {
526 throw Error.IncorrectNumberOfLambdaDeclarationParameters();
528 var set = new Set<ParameterExpression>(pis.Length);
529 for (int i = 0, n = pis.Length; i < n; i++) {
530 ParameterExpression pex = parameters[i];
531 ParameterInfo pi = pis[i];
532 RequiresCanRead(pex, "parameters");
533 Type pType = pi.ParameterType;
535 if (!pType.IsByRef) {
536 //We cannot pass a parameter of T& to a delegate that takes T or any non-ByRef type.
537 throw Error.ParameterExpressionNotValidAsDelegate(pex.Type.MakeByRefType(), pType);
539 pType = pType.GetElementType();
541 if (!TypeUtils.AreReferenceAssignable(pex.Type, pType)) {
542 throw Error.ParameterExpressionNotValidAsDelegate(pex.Type, pType);
544 if (set.Contains(pex)) {
545 throw Error.DuplicateVariable(pex);
549 } else if (parameters.Count > 0) {
550 throw Error.IncorrectNumberOfLambdaDeclarationParameters();
552 if (mi.ReturnType != typeof(void) && !TypeUtils.AreReferenceAssignable(mi.ReturnType, body.Type)) {
553 if (!TryQuote(mi.ReturnType, ref body)) {
554 throw Error.ExpressionTypeDoesNotMatchReturn(body.Type, mi.ReturnType);
559 private static bool ValidateTryGetFuncActionArgs(Type[] typeArgs) {
560 if (typeArgs == null) {
561 throw new ArgumentNullException("typeArgs");
563 for (int i = 0, n = typeArgs.Length; i < n; i++) {
566 throw new ArgumentNullException("typeArgs");
576 /// Creates a <see cref="Type"/> object that represents a generic System.Func delegate type that has specific type arguments.
577 /// The last type argument specifies the return type of the created delegate.
579 /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Func delegate type.</param>
580 /// <returns>The type of a System.Func delegate that has the specified type arguments.</returns>
581 public static Type GetFuncType(params Type[] typeArgs) {
582 if (!ValidateTryGetFuncActionArgs(typeArgs)) throw Error.TypeMustNotBeByRef();
584 Type result = DelegateHelpers.GetFuncType(typeArgs);
585 if (result == null) {
586 throw Error.IncorrectNumberOfTypeArgsForFunc();
592 /// Creates a <see cref="Type"/> object that represents a generic System.Func delegate type that has specific type arguments.
593 /// The last type argument specifies the return type of the created delegate.
595 /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Func delegate type.</param>
596 /// <param name="funcType">When this method returns, contains the generic System.Func delegate type that has specific type arguments. Contains null if there is no generic System.Func delegate that matches the <paramref name="typeArgs"/>.This parameter is passed uninitialized.</param>
597 /// <returns>true if generic System.Func delegate type was created for specific <paramref name="typeArgs"/>; false otherwise.</returns>
598 public static bool TryGetFuncType(Type[] typeArgs, out Type funcType) {
599 if (ValidateTryGetFuncActionArgs(typeArgs)) {
600 return (funcType = DelegateHelpers.GetFuncType(typeArgs)) != null;
607 /// Creates a <see cref="Type"/> object that represents a generic System.Action delegate type that has specific type arguments.
609 /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Action delegate type.</param>
610 /// <returns>The type of a System.Action delegate that has the specified type arguments.</returns>
611 public static Type GetActionType(params Type[] typeArgs) {
612 if (!ValidateTryGetFuncActionArgs(typeArgs)) throw Error.TypeMustNotBeByRef();
614 Type result = DelegateHelpers.GetActionType(typeArgs);
615 if (result == null) {
616 throw Error.IncorrectNumberOfTypeArgsForAction();
622 /// Creates a <see cref="Type"/> object that represents a generic System.Action delegate type that has specific type arguments.
624 /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Action delegate type.</param>
625 /// <param name="actionType">When this method returns, contains the generic System.Action delegate type that has specific type arguments. Contains null if there is no generic System.Action delegate that matches the <paramref name="typeArgs"/>.This parameter is passed uninitialized.</param>
626 /// <returns>true if generic System.Action delegate type was created for specific <paramref name="typeArgs"/>; false otherwise.</returns>
627 public static bool TryGetActionType(Type[] typeArgs, out Type actionType) {
628 if (ValidateTryGetFuncActionArgs(typeArgs)) {
629 return (actionType = DelegateHelpers.GetActionType(typeArgs)) != null;
636 /// Gets a <see cref="Type"/> object that represents a generic System.Func or System.Action delegate type that has specific type arguments.
637 /// The last type argument determines the return type of the delegate. If no Func or Action is large enough, it will generate a custom
640 /// <param name="typeArgs">The type arguments of the delegate.</param>
641 /// <returns>The delegate type.</returns>
643 /// As with Func, the last argument is the return type. It can be set
644 /// to System.Void to produce an Action.</remarks>
645 public static Type GetDelegateType(params Type[] typeArgs) {
646 ContractUtils.RequiresNotEmpty(typeArgs, "typeArgs");
647 ContractUtils.RequiresNotNullItems(typeArgs, "typeArgs");
648 return DelegateHelpers.MakeDelegateType(typeArgs);