niko
369 lines
12 KiB
C#
369 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
|
|
namespace System.Linq.Expressions
|
|
{
|
|
// Token: 0x0200001E RID: 30
|
|
internal abstract class ExpressionTransformer
|
|
{
|
|
// Token: 0x060001CC RID: 460 RVA: 0x0000A8F8 File Offset: 0x00008AF8
|
|
public Expression Transform(Expression expression)
|
|
{
|
|
return this.Visit(expression);
|
|
}
|
|
|
|
// Token: 0x060001CD RID: 461 RVA: 0x0000A904 File Offset: 0x00008B04
|
|
protected virtual Expression Visit(Expression exp)
|
|
{
|
|
if (exp == null)
|
|
{
|
|
return exp;
|
|
}
|
|
switch (exp.NodeType)
|
|
{
|
|
case ExpressionType.Add:
|
|
case ExpressionType.AddChecked:
|
|
case ExpressionType.And:
|
|
case ExpressionType.AndAlso:
|
|
case ExpressionType.ArrayIndex:
|
|
case ExpressionType.Coalesce:
|
|
case ExpressionType.Divide:
|
|
case ExpressionType.Equal:
|
|
case ExpressionType.ExclusiveOr:
|
|
case ExpressionType.GreaterThan:
|
|
case ExpressionType.GreaterThanOrEqual:
|
|
case ExpressionType.LeftShift:
|
|
case ExpressionType.LessThan:
|
|
case ExpressionType.LessThanOrEqual:
|
|
case ExpressionType.Modulo:
|
|
case ExpressionType.Multiply:
|
|
case ExpressionType.MultiplyChecked:
|
|
case ExpressionType.NotEqual:
|
|
case ExpressionType.Or:
|
|
case ExpressionType.OrElse:
|
|
case ExpressionType.Power:
|
|
case ExpressionType.RightShift:
|
|
case ExpressionType.Subtract:
|
|
case ExpressionType.SubtractChecked:
|
|
return this.VisitBinary((BinaryExpression)exp);
|
|
case ExpressionType.ArrayLength:
|
|
case ExpressionType.Convert:
|
|
case ExpressionType.ConvertChecked:
|
|
case ExpressionType.Negate:
|
|
case ExpressionType.UnaryPlus:
|
|
case ExpressionType.NegateChecked:
|
|
case ExpressionType.Not:
|
|
case ExpressionType.Quote:
|
|
case ExpressionType.TypeAs:
|
|
return this.VisitUnary((UnaryExpression)exp);
|
|
case ExpressionType.Call:
|
|
return this.VisitMethodCall((MethodCallExpression)exp);
|
|
case ExpressionType.Conditional:
|
|
return this.VisitConditional((ConditionalExpression)exp);
|
|
case ExpressionType.Constant:
|
|
return this.VisitConstant((ConstantExpression)exp);
|
|
case ExpressionType.Invoke:
|
|
return this.VisitInvocation((InvocationExpression)exp);
|
|
case ExpressionType.Lambda:
|
|
return this.VisitLambda((LambdaExpression)exp);
|
|
case ExpressionType.ListInit:
|
|
return this.VisitListInit((ListInitExpression)exp);
|
|
case ExpressionType.MemberAccess:
|
|
return this.VisitMemberAccess((MemberExpression)exp);
|
|
case ExpressionType.MemberInit:
|
|
return this.VisitMemberInit((MemberInitExpression)exp);
|
|
case ExpressionType.New:
|
|
return this.VisitNew((NewExpression)exp);
|
|
case ExpressionType.NewArrayInit:
|
|
case ExpressionType.NewArrayBounds:
|
|
return this.VisitNewArray((NewArrayExpression)exp);
|
|
case ExpressionType.Parameter:
|
|
return this.VisitParameter((ParameterExpression)exp);
|
|
case ExpressionType.TypeIs:
|
|
return this.VisitTypeIs((TypeBinaryExpression)exp);
|
|
default:
|
|
throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001CE RID: 462 RVA: 0x0000AAB4 File Offset: 0x00008CB4
|
|
protected virtual MemberBinding VisitBinding(MemberBinding binding)
|
|
{
|
|
switch (binding.BindingType)
|
|
{
|
|
case MemberBindingType.Assignment:
|
|
return this.VisitMemberAssignment((MemberAssignment)binding);
|
|
case MemberBindingType.MemberBinding:
|
|
return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
|
|
case MemberBindingType.ListBinding:
|
|
return this.VisitMemberListBinding((MemberListBinding)binding);
|
|
default:
|
|
throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001CF RID: 463 RVA: 0x0000AB20 File Offset: 0x00008D20
|
|
protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
|
|
{
|
|
ReadOnlyCollection<Expression> readOnlyCollection = this.VisitExpressionList(initializer.Arguments);
|
|
if (readOnlyCollection != initializer.Arguments)
|
|
{
|
|
return Expression.ElementInit(initializer.AddMethod, readOnlyCollection);
|
|
}
|
|
return initializer;
|
|
}
|
|
|
|
// Token: 0x060001D0 RID: 464 RVA: 0x0000AB54 File Offset: 0x00008D54
|
|
protected virtual Expression VisitUnary(UnaryExpression u)
|
|
{
|
|
Expression expression = this.Visit(u.Operand);
|
|
if (expression != u.Operand)
|
|
{
|
|
return Expression.MakeUnary(u.NodeType, expression, u.Type, u.Method);
|
|
}
|
|
return u;
|
|
}
|
|
|
|
// Token: 0x060001D1 RID: 465 RVA: 0x0000AB94 File Offset: 0x00008D94
|
|
protected virtual Expression VisitBinary(BinaryExpression b)
|
|
{
|
|
Expression expression = this.Visit(b.Left);
|
|
Expression expression2 = this.Visit(b.Right);
|
|
Expression expression3 = this.Visit(b.Conversion);
|
|
if (expression == b.Left && expression2 == b.Right && expression3 == b.Conversion)
|
|
{
|
|
return b;
|
|
}
|
|
if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
|
|
{
|
|
return Expression.Coalesce(expression, expression2, expression3 as LambdaExpression);
|
|
}
|
|
return Expression.MakeBinary(b.NodeType, expression, expression2, b.IsLiftedToNull, b.Method);
|
|
}
|
|
|
|
// Token: 0x060001D2 RID: 466 RVA: 0x0000AC2C File Offset: 0x00008E2C
|
|
protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
|
|
{
|
|
Expression expression = this.Visit(b.Expression);
|
|
if (expression != b.Expression)
|
|
{
|
|
return Expression.TypeIs(expression, b.TypeOperand);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
// Token: 0x060001D3 RID: 467 RVA: 0x0000AC60 File Offset: 0x00008E60
|
|
protected virtual Expression VisitConstant(ConstantExpression c)
|
|
{
|
|
return c;
|
|
}
|
|
|
|
// Token: 0x060001D4 RID: 468 RVA: 0x0000AC64 File Offset: 0x00008E64
|
|
protected virtual Expression VisitConditional(ConditionalExpression c)
|
|
{
|
|
Expression expression = this.Visit(c.Test);
|
|
Expression expression2 = this.Visit(c.IfTrue);
|
|
Expression expression3 = this.Visit(c.IfFalse);
|
|
if (expression != c.Test || expression2 != c.IfTrue || expression3 != c.IfFalse)
|
|
{
|
|
return Expression.Condition(expression, expression2, expression3);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// Token: 0x060001D5 RID: 469 RVA: 0x0000ACC8 File Offset: 0x00008EC8
|
|
protected virtual Expression VisitParameter(ParameterExpression p)
|
|
{
|
|
return p;
|
|
}
|
|
|
|
// Token: 0x060001D6 RID: 470 RVA: 0x0000ACCC File Offset: 0x00008ECC
|
|
protected virtual Expression VisitMemberAccess(MemberExpression m)
|
|
{
|
|
Expression expression = this.Visit(m.Expression);
|
|
if (expression != m.Expression)
|
|
{
|
|
return Expression.MakeMemberAccess(expression, m.Member);
|
|
}
|
|
return m;
|
|
}
|
|
|
|
// Token: 0x060001D7 RID: 471 RVA: 0x0000AD00 File Offset: 0x00008F00
|
|
protected virtual Expression VisitMethodCall(MethodCallExpression m)
|
|
{
|
|
Expression expression = this.Visit(m.Object);
|
|
IEnumerable<Expression> enumerable = this.VisitExpressionList(m.Arguments);
|
|
if (expression != m.Object || enumerable != m.Arguments)
|
|
{
|
|
return Expression.Call(expression, m.Method, enumerable);
|
|
}
|
|
return m;
|
|
}
|
|
|
|
// Token: 0x060001D8 RID: 472 RVA: 0x0000AD50 File Offset: 0x00008F50
|
|
protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)
|
|
{
|
|
IList<Expression> list = this.VisitList<Expression>(original, new Func<Expression, Expression>(this.Visit));
|
|
if (list == null)
|
|
{
|
|
return original;
|
|
}
|
|
return new ReadOnlyCollection<Expression>(list);
|
|
}
|
|
|
|
// Token: 0x060001D9 RID: 473 RVA: 0x0000AD80 File Offset: 0x00008F80
|
|
protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
|
|
{
|
|
Expression expression = this.Visit(assignment.Expression);
|
|
if (expression != assignment.Expression)
|
|
{
|
|
return Expression.Bind(assignment.Member, expression);
|
|
}
|
|
return assignment;
|
|
}
|
|
|
|
// Token: 0x060001DA RID: 474 RVA: 0x0000ADB4 File Offset: 0x00008FB4
|
|
protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
|
|
{
|
|
IEnumerable<MemberBinding> enumerable = this.VisitBindingList(binding.Bindings);
|
|
if (enumerable != binding.Bindings)
|
|
{
|
|
return Expression.MemberBind(binding.Member, enumerable);
|
|
}
|
|
return binding;
|
|
}
|
|
|
|
// Token: 0x060001DB RID: 475 RVA: 0x0000ADE8 File Offset: 0x00008FE8
|
|
protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)
|
|
{
|
|
IEnumerable<ElementInit> enumerable = this.VisitElementInitializerList(binding.Initializers);
|
|
if (enumerable != binding.Initializers)
|
|
{
|
|
return Expression.ListBind(binding.Member, enumerable);
|
|
}
|
|
return binding;
|
|
}
|
|
|
|
// Token: 0x060001DC RID: 476 RVA: 0x0000AE1C File Offset: 0x0000901C
|
|
protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)
|
|
{
|
|
return this.VisitList<MemberBinding>(original, new Func<MemberBinding, MemberBinding>(this.VisitBinding));
|
|
}
|
|
|
|
// Token: 0x060001DD RID: 477 RVA: 0x0000AE34 File Offset: 0x00009034
|
|
protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)
|
|
{
|
|
return this.VisitList<ElementInit>(original, new Func<ElementInit, ElementInit>(this.VisitElementInitializer));
|
|
}
|
|
|
|
// Token: 0x060001DE RID: 478 RVA: 0x0000AE4C File Offset: 0x0000904C
|
|
private IList<TElement> VisitList<TElement>(ReadOnlyCollection<TElement> original, Func<TElement, TElement> visit)
|
|
{
|
|
List<TElement> list = null;
|
|
int i = 0;
|
|
int count = original.Count;
|
|
while (i < count)
|
|
{
|
|
TElement telement = visit(original[i]);
|
|
if (list != null)
|
|
{
|
|
list.Add(telement);
|
|
}
|
|
else if (!EqualityComparer<TElement>.Default.Equals(telement, original[i]))
|
|
{
|
|
list = new List<TElement>(count);
|
|
for (int j = 0; j < i; j++)
|
|
{
|
|
list.Add(original[j]);
|
|
}
|
|
list.Add(telement);
|
|
}
|
|
i++;
|
|
}
|
|
if (list != null)
|
|
{
|
|
return list;
|
|
}
|
|
return original;
|
|
}
|
|
|
|
// Token: 0x060001DF RID: 479 RVA: 0x0000AEE8 File Offset: 0x000090E8
|
|
protected virtual Expression VisitLambda(LambdaExpression lambda)
|
|
{
|
|
Expression expression = this.Visit(lambda.Body);
|
|
if (expression != lambda.Body)
|
|
{
|
|
return Expression.Lambda(lambda.Type, expression, lambda.Parameters);
|
|
}
|
|
return lambda;
|
|
}
|
|
|
|
// Token: 0x060001E0 RID: 480 RVA: 0x0000AF24 File Offset: 0x00009124
|
|
protected virtual NewExpression VisitNew(NewExpression nex)
|
|
{
|
|
IEnumerable<Expression> enumerable = this.VisitExpressionList(nex.Arguments);
|
|
if (enumerable == nex.Arguments)
|
|
{
|
|
return nex;
|
|
}
|
|
if (nex.Members != null)
|
|
{
|
|
return Expression.New(nex.Constructor, enumerable, nex.Members);
|
|
}
|
|
return Expression.New(nex.Constructor, enumerable);
|
|
}
|
|
|
|
// Token: 0x060001E1 RID: 481 RVA: 0x0000AF78 File Offset: 0x00009178
|
|
protected virtual Expression VisitMemberInit(MemberInitExpression init)
|
|
{
|
|
NewExpression newExpression = this.VisitNew(init.NewExpression);
|
|
IEnumerable<MemberBinding> enumerable = this.VisitBindingList(init.Bindings);
|
|
if (newExpression != init.NewExpression || enumerable != init.Bindings)
|
|
{
|
|
return Expression.MemberInit(newExpression, enumerable);
|
|
}
|
|
return init;
|
|
}
|
|
|
|
// Token: 0x060001E2 RID: 482 RVA: 0x0000AFC0 File Offset: 0x000091C0
|
|
protected virtual Expression VisitListInit(ListInitExpression init)
|
|
{
|
|
NewExpression newExpression = this.VisitNew(init.NewExpression);
|
|
IEnumerable<ElementInit> enumerable = this.VisitElementInitializerList(init.Initializers);
|
|
if (newExpression != init.NewExpression || enumerable != init.Initializers)
|
|
{
|
|
return Expression.ListInit(newExpression, enumerable);
|
|
}
|
|
return init;
|
|
}
|
|
|
|
// Token: 0x060001E3 RID: 483 RVA: 0x0000B008 File Offset: 0x00009208
|
|
protected virtual Expression VisitNewArray(NewArrayExpression na)
|
|
{
|
|
IEnumerable<Expression> enumerable = this.VisitExpressionList(na.Expressions);
|
|
if (enumerable == na.Expressions)
|
|
{
|
|
return na;
|
|
}
|
|
if (na.NodeType == ExpressionType.NewArrayInit)
|
|
{
|
|
return Expression.NewArrayInit(na.Type.GetElementType(), enumerable);
|
|
}
|
|
return Expression.NewArrayBounds(na.Type.GetElementType(), enumerable);
|
|
}
|
|
|
|
// Token: 0x060001E4 RID: 484 RVA: 0x0000B060 File Offset: 0x00009260
|
|
protected virtual Expression VisitInvocation(InvocationExpression iv)
|
|
{
|
|
IEnumerable<Expression> enumerable = this.VisitExpressionList(iv.Arguments);
|
|
Expression expression = this.Visit(iv.Expression);
|
|
if (enumerable != iv.Arguments || expression != iv.Expression)
|
|
{
|
|
return Expression.Invoke(expression, enumerable);
|
|
}
|
|
return iv;
|
|
}
|
|
}
|
|
}
|