private bool CompareListInit(ListInitExpression a, ListInitExpression b) => Compare(a.NewExpression, b.NewExpression) && CompareElementInitList(a.Initializers, b.Initializers);
protected override Expression VisitListInit(ListInitExpression init)
{
throw InvalidSqlExpression(init);
}
protected override Expression MakeListInit(ListInitExpression node, NewExpression newExpression, ReadOnlyCollection <ElementInit> initializers) => throw new NotImplementedException();
protected override Expression VisitListInit(ListInitExpression node)
{
this.expressions.Add(node);
return(base.VisitListInit(node));
}
protected override Expression VisitListInit(ListInitExpression expression)
{
this.hashCode ^= expression.Initializers.Count;
return(base.VisitListInit(expression));
}
protected virtual Expression VisitListInit(ListInitExpression init)
{
NewExpression n = (NewExpression)this.Visit(init.NewExpression);
IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);
return this.UpdateListInit(init, n, initializers);
}
internal override Expression VisitListInit(ListInitExpression init)
{
throw new NotSupportedException(Strings.ALinq_ListInitNotSupported);
}
private Expression Rewrite(Expression expression, ReadOnlyCollection <ParameterExpression> lambdaParameters)
{
Func <Expression, Expression> selector = null;
Func <ElementInit, ElementInit> func2 = null;
Func <MemberBinding, MemberBinding> func3 = null;
Func <Expression, Expression> func4 = null;
Func <Expression, Expression> func5 = null;
Func <Expression, Expression> func6 = null;
Func <Expression, Expression> func7 = null;
Func <Expression, Expression> func8 = null;
if (expression == null)
{
return(null);
}
switch (expression.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.And:
case ExpressionType.AndAlso:
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:
{
BinaryExpression expression2 = (BinaryExpression)expression;
return(Expression.MakeBinary(expression2.NodeType, this.Rewrite(expression2.Left, lambdaParameters), this.Rewrite(expression2.Right, lambdaParameters), expression2.IsLiftedToNull, expression2.Method, (LambdaExpression)this.Rewrite(expression2.Conversion, lambdaParameters)));
}
case ExpressionType.ArrayLength:
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Not:
case ExpressionType.Quote:
case ExpressionType.TypeAs:
{
UnaryExpression expression17 = (UnaryExpression)expression;
return(Expression.MakeUnary(expression17.NodeType, this.Rewrite(expression17.Operand, lambdaParameters), expression17.Type, expression17.Method));
}
case ExpressionType.ArrayIndex:
{
MethodCallExpression expression10 = expression as MethodCallExpression;
if (expression10 == null)
{
BinaryExpression expression11 = (BinaryExpression)expression;
return(Expression.ArrayIndex(this.Rewrite(expression11.Left, lambdaParameters), this.Rewrite(expression11.Right, lambdaParameters)));
}
if (func4 == null)
{
func4 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.ArrayIndex(this.Rewrite(expression10.Object, lambdaParameters), expression10.Arguments.Select <Expression, Expression>(func4)));
}
case ExpressionType.Call:
{
MethodCallExpression expression12 = (MethodCallExpression)expression;
if (func5 == null)
{
func5 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.Call(this.Rewrite(expression12.Object, lambdaParameters), expression12.Method, expression12.Arguments.Select <Expression, Expression>(func5)));
}
case ExpressionType.Conditional:
{
ConditionalExpression expression3 = (ConditionalExpression)expression;
return(Expression.Condition(this.Rewrite(expression3.Test, lambdaParameters), this.Rewrite(expression3.IfTrue, lambdaParameters), this.Rewrite(expression3.IfFalse, lambdaParameters)));
}
case ExpressionType.Constant:
return(expression);
case ExpressionType.Invoke:
{
InvocationExpression expression4 = (InvocationExpression)expression;
if (selector == null)
{
selector = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.Invoke(this.Rewrite(expression4.Expression, lambdaParameters), expression4.Arguments.Select <Expression, Expression>(selector)));
}
case ExpressionType.Lambda:
{
LambdaExpression expression5 = (LambdaExpression)expression;
return(Expression.Lambda(expression5.Type, this.Rewrite(expression5.Body, expression5.Parameters), expression5.Parameters));
}
case ExpressionType.ListInit:
{
ListInitExpression expression6 = (ListInitExpression)expression;
if (func2 == null)
{
func2 = ei => Expression.ElementInit(ei.AddMethod, (IEnumerable <Expression>)(from arg in ei.Arguments select this.Rewrite(arg, lambdaParameters)));
}
return(Expression.ListInit((NewExpression)this.Rewrite(expression6.NewExpression, lambdaParameters), expression6.Initializers.Select <ElementInit, ElementInit>(func2)));
}
case ExpressionType.MemberAccess:
{
MemberExpression expression8 = (MemberExpression)expression;
return(Expression.MakeMemberAccess(this.Rewrite(expression8.Expression, lambdaParameters), expression8.Member));
}
case ExpressionType.MemberInit:
{
MemberInitExpression expression9 = (MemberInitExpression)expression;
if (func3 == null)
{
func3 = b => this.Rewrite(b, lambdaParameters);
}
return(Expression.MemberInit((NewExpression)this.Rewrite(expression9.NewExpression, lambdaParameters), expression9.Bindings.Select <MemberBinding, MemberBinding>(func3)));
}
case ExpressionType.UnaryPlus:
{
UnaryExpression expression18 = (UnaryExpression)expression;
return(Expression.UnaryPlus(this.Rewrite(expression18.Operand, lambdaParameters), expression18.Method));
}
case ExpressionType.New:
{
NewExpression expression15 = (NewExpression)expression;
if (expression15.Constructor != null)
{
if (func8 == null)
{
func8 = a => this.Rewrite(a, lambdaParameters);
}
return(Expression.New(expression15.Constructor, expression15.Arguments.Select <Expression, Expression>(func8)));
}
return(expression);
}
case ExpressionType.NewArrayInit:
{
NewArrayExpression expression13 = (NewArrayExpression)expression;
if (func6 == null)
{
func6 = e => this.Rewrite(e, lambdaParameters);
}
return(Expression.NewArrayInit(expression13.Type.GetElementType(), expression13.Expressions.Select <Expression, Expression>(func6)));
}
case ExpressionType.NewArrayBounds:
{
NewArrayExpression expression14 = (NewArrayExpression)expression;
if (func7 == null)
{
func7 = e => this.Rewrite(e, lambdaParameters);
}
return(Expression.NewArrayBounds(expression14.Type.GetElementType(), expression14.Expressions.Select <Expression, Expression>(func7)));
}
case ExpressionType.Parameter:
{
ParameterExpression expression7 = (ParameterExpression)expression;
if ((lambdaParameters == null) || !lambdaParameters.Contains(expression7))
{
string name = expression7.Name;
for (LocationReferenceEnvironment environment = this.environment; environment != null; environment = environment.Parent)
{
foreach (LocationReference reference in environment.GetLocationReferences())
{
if (string.Equals(reference.Name, name, StringComparison.OrdinalIgnoreCase))
{
LocationReference reference3;
LocationReference locationReference = reference;
if (this.metadata.HasValue && this.metadata.Value.TryGetInlinedLocationReference(reference, out reference3))
{
locationReference = reference3;
}
return(ExpressionUtilities.CreateIdentifierExpression(locationReference));
}
}
}
return(expression7);
}
return(expression7);
}
case ExpressionType.TypeIs:
{
TypeBinaryExpression expression16 = (TypeBinaryExpression)expression;
return(Expression.TypeIs(this.Rewrite(expression16.Expression, lambdaParameters), expression16.TypeOperand));
}
case ExpressionType.Assign:
{
BinaryExpression expression22 = (BinaryExpression)expression;
return(Expression.Assign(this.Rewrite(expression22.Left, lambdaParameters), this.Rewrite(expression22.Right, lambdaParameters)));
}
case ExpressionType.Block:
{
BlockExpression expression19 = (BlockExpression)expression;
List <ParameterExpression> list = new List <ParameterExpression>();
foreach (ParameterExpression expression20 in expression19.Variables)
{
list.Add((ParameterExpression)this.Rewrite(expression20, lambdaParameters));
}
List <Expression> list2 = new List <Expression>();
foreach (Expression expression21 in expression19.Expressions)
{
list2.Add(this.Rewrite(expression21, lambdaParameters));
}
return(Expression.Block((IEnumerable <ParameterExpression>)list, (IEnumerable <Expression>)list2));
}
}
return(expression);
}
/// <summary> /// Visit a <see cref="ListInitExpression"/>. /// </summary> /// <param name="expression"><see cref="ListInitExpression"/> to visit.</param> /// <returns>Returns the result of the visit.</returns> protected abstract object VisitListInitExpression(ListInitExpression expression);
private static bool GetDecompositionInfoList(ParameterExpression keyParam,
ParameterExpression groupParam,
Expression expr,
List <DecompositionInfo> infoList,
HpcLinqCodeGen codeGen)
{
IEnumerable <Expression> argList = null;
if (HpcLinqExpression.IsConstant(expr))
{
return(true);
}
else if (expr is BinaryExpression)
{
BinaryExpression be = (BinaryExpression)expr;
argList = new Expression[] { be.Left, be.Right };
}
else if (expr is UnaryExpression)
{
UnaryExpression ue = (UnaryExpression)expr;
return(GetDecompositionInfoList(keyParam, groupParam, ue.Operand, infoList, codeGen));
}
else if (expr is ConditionalExpression)
{
ConditionalExpression ce = (ConditionalExpression)expr;
argList = new Expression[] { ce.Test, ce.IfTrue, ce.IfFalse };
}
else if (expr is MethodCallExpression)
{
MethodCallExpression mcExpr = (MethodCallExpression)expr;
DecompositionInfo dinfo = GetDecompositionInfo(groupParam, mcExpr, codeGen);
if (dinfo != null)
{
infoList.Add(dinfo);
return(true);
}
if (mcExpr.Object != null)
{
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
mcExpr.Object,
infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
argList = mcExpr.Arguments;
}
else if (expr is NewExpression)
{
argList = ((NewExpression)expr).Arguments;
}
else if (expr is NewArrayExpression)
{
argList = ((NewArrayExpression)expr).Expressions;
}
else if (expr is ListInitExpression)
{
ListInitExpression li = (ListInitExpression)expr;
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
li.NewExpression,
infoList, codeGen);
for (int i = 0, n = li.Initializers.Count; i < n; i++)
{
ElementInit ei = li.Initializers[i];
foreach (Expression arg in ei.Arguments)
{
isDecomposed = GetDecompositionInfoList(keyParam, groupParam, arg, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
}
return(true);
}
else if (expr is MemberInitExpression)
{
MemberInitExpression mi = (MemberInitExpression)expr;
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
mi.NewExpression,
infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
foreach (MemberBinding mb in mi.Bindings)
{
isDecomposed = GetDecompositionInfoList(keyParam, groupParam, mb, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
return(true);
}
else if (keyParam == null)
{
while (expr is MemberExpression)
{
MemberExpression me = (MemberExpression)expr;
if (me.Expression == groupParam &&
me.Member.Name == "Key")
{
return(true);
}
expr = me.Expression;
}
return(false);
}
else
{
while (expr is MemberExpression)
{
expr = ((MemberExpression)expr).Expression;
}
return(expr == keyParam);
}
foreach (var argExpr in argList)
{
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam, argExpr, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
return(true);
}
private static ParameterExpression FindParameter(Expression expression)
{
if (expression != null)
{
switch (expression.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.And:
case ExpressionType.AndAlso:
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:
{
BinaryExpression expression2 = (BinaryExpression)expression;
return(FindParameter(expression2.Left) ?? FindParameter(expression2.Right));
}
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:
{
UnaryExpression expression16 = (UnaryExpression)expression;
return(FindParameter(expression16.Operand));
}
case ExpressionType.ArrayIndex:
{
MethodCallExpression expression9 = expression as MethodCallExpression;
if (expression9 == null)
{
BinaryExpression expression10 = (BinaryExpression)expression;
return(FindParameter(expression10.Left) ?? FindParameter(expression10.Right));
}
return(FindParameter(expression9.Object) ?? FindParameter(expression9.Arguments));
}
case ExpressionType.Call:
{
MethodCallExpression expression11 = (MethodCallExpression)expression;
return(FindParameter(expression11.Object) ?? FindParameter(expression11.Arguments));
}
case ExpressionType.Conditional:
{
ConditionalExpression expression3 = (ConditionalExpression)expression;
return(FindParameter(expression3.Test) ?? (FindParameter(expression3.IfTrue) ?? FindParameter(expression3.IfFalse)));
}
case ExpressionType.Constant:
return(null);
case ExpressionType.Invoke:
{
InvocationExpression expression4 = (InvocationExpression)expression;
return(FindParameter(expression4.Expression) ?? FindParameter(expression4.Arguments));
}
case ExpressionType.Lambda:
{
LambdaExpression expression5 = (LambdaExpression)expression;
return(FindParameter(expression5.Body));
}
case ExpressionType.ListInit:
{
ListInitExpression expression6 = (ListInitExpression)expression;
return(FindParameter(expression6.NewExpression) ?? FindParameter(expression6.Initializers));
}
case ExpressionType.MemberAccess:
{
MemberExpression expression7 = (MemberExpression)expression;
return(FindParameter(expression7.Expression));
}
case ExpressionType.MemberInit:
{
MemberInitExpression expression8 = (MemberInitExpression)expression;
return(FindParameter(expression8.NewExpression) ?? FindParameter(expression8.Bindings));
}
case ExpressionType.New:
{
NewExpression expression13 = (NewExpression)expression;
return(FindParameter(expression13.Arguments));
}
case ExpressionType.NewArrayInit:
case ExpressionType.NewArrayBounds:
{
NewArrayExpression expression12 = (NewArrayExpression)expression;
return(FindParameter(expression12.Expressions));
}
case ExpressionType.Parameter:
{
ParameterExpression expression14 = (ParameterExpression)expression;
if (!(expression14.Type == typeof(ActivityContext)) || !(expression14.Name == "context"))
{
return(null);
}
return(expression14);
}
case ExpressionType.TypeIs:
{
TypeBinaryExpression expression15 = (TypeBinaryExpression)expression;
return(FindParameter(expression15.Expression));
}
case ExpressionType.Assign:
{
BinaryExpression expression20 = (BinaryExpression)expression;
return(FindParameter(expression20.Left) ?? FindParameter(expression20.Right));
}
case ExpressionType.Block:
{
BlockExpression expression17 = (BlockExpression)expression;
ParameterExpression expression18 = FindParameter(expression17.Expressions);
if (expression18 == null)
{
List <Expression> collection = new List <Expression>();
foreach (ParameterExpression expression19 in expression17.Variables)
{
collection.Add(expression19);
}
return(FindParameter(collection));
}
return(expression18);
}
}
}
return(null);
}
protected override Expression VisitListInit(ListInitExpression node) => throw new ApplicationException();
protected virtual bool CompareListInit(ListInitExpression a, ListInitExpression b)
{
return this.Compare(a.NewExpression, b.NewExpression)
&& this.CompareElementInitList(a.Initializers, b.Initializers);
}
protected ListInitExpression UpdateListInit(ListInitExpression init, NewExpression nex, IEnumerable<ElementInit> initializers)
{
if (nex != init.NewExpression || initializers != init.Initializers)
{
return Expression.ListInit(nex, initializers);
}
return init;
}
protected virtual bool CompareListInit(ListInitExpression a, ListInitExpression b)
{
return(this.Compare(a.NewExpression, b.NewExpression) && this.CompareElementInitList(a.Initializers, b.Initializers));
}
static void FindTypeReferences(Expression expression, HashSet <Type> typeReferences)
{
if (expression == null)
{
return;
}
switch (expression.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.And:
case ExpressionType.AndAlso:
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:
BinaryExpression binaryExpression = (BinaryExpression)expression;
FindTypeReferences(binaryExpression.Left, typeReferences);
FindTypeReferences(binaryExpression.Right, typeReferences);
return;
case ExpressionType.Conditional:
ConditionalExpression conditional = (ConditionalExpression)expression;
FindTypeReferences(conditional.Test, typeReferences);
FindTypeReferences(conditional.IfTrue, typeReferences);
FindTypeReferences(conditional.IfFalse, typeReferences);
return;
case ExpressionType.Constant:
ConstantExpression constantExpr = (ConstantExpression)expression;
if (constantExpr.Value is Type)
{
EnsureTypeReferenced((Type)constantExpr.Value, true, typeReferences);
}
else if (constantExpr.Value != null)
{
EnsureTypeReferenced(constantExpr.Value.GetType(), true, typeReferences);
}
return;
case ExpressionType.Invoke:
InvocationExpression invocation = (InvocationExpression)expression;
FindTypeReferences(invocation.Expression, typeReferences);
for (int i = 0; i < invocation.Arguments.Count; i++)
{
FindTypeReferences(invocation.Arguments[i], typeReferences);
}
return;
case ExpressionType.Lambda:
LambdaExpression lambda = (LambdaExpression)expression;
FindTypeReferences(lambda.Body, typeReferences);
for (int i = 0; i < lambda.Parameters.Count; i++)
{
FindTypeReferences(lambda.Parameters[i], typeReferences);
}
return;
case ExpressionType.ListInit:
ListInitExpression listInit = (ListInitExpression)expression;
FindTypeReferences(listInit.NewExpression, typeReferences);
for (int i = 0; i < listInit.Initializers.Count; i++)
{
ReadOnlyCollection <Expression> arguments = listInit.Initializers[i].Arguments;
for (int argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++)
{
FindTypeReferences(arguments[argumentIndex], typeReferences);
}
}
return;
case ExpressionType.Parameter:
ParameterExpression paramExpr = (ParameterExpression)expression;
EnsureTypeReferenced(paramExpr.Type, false, typeReferences);
return;
case ExpressionType.MemberAccess:
MemberExpression memberExpression = (MemberExpression)expression;
if (memberExpression.Expression == null)
{
EnsureTypeReferenced(memberExpression.Member.DeclaringType, true, typeReferences);
}
else
{
FindTypeReferences(memberExpression.Expression, typeReferences);
}
EnsureTypeReferenced(memberExpression.Type, false, typeReferences);
return;
case ExpressionType.MemberInit:
MemberInitExpression memberInit = (MemberInitExpression)expression;
FindTypeReferences(memberInit.NewExpression, typeReferences);
ReadOnlyCollection <MemberBinding> bindings = memberInit.Bindings;
for (int i = 0; i < bindings.Count; i++)
{
FindTypeReferences(bindings[i], typeReferences);
}
return;
case ExpressionType.ArrayIndex:
// ArrayIndex can be a MethodCallExpression or a BinaryExpression
MethodCallExpression arrayIndex = expression as MethodCallExpression;
if (arrayIndex != null)
{
FindTypeReferences(arrayIndex.Object, typeReferences);
ReadOnlyCollection <Expression> arguments = arrayIndex.Arguments;
for (int i = 0; i < arguments.Count; i++)
{
FindTypeReferences(arguments[i], typeReferences);
}
return;
}
BinaryExpression alternateIndex = (BinaryExpression)expression;
FindTypeReferences(alternateIndex.Left, typeReferences);
FindTypeReferences(alternateIndex.Right, typeReferences);
return;
case ExpressionType.Call:
MethodCallExpression methodCall = (MethodCallExpression)expression;
MethodInfo method = methodCall.Method;
EnsureTypeReferenced(methodCall.Type, false, typeReferences);
if (methodCall.Object != null)
{
FindTypeReferences(methodCall.Object, typeReferences);
}
else
{
EnsureTypeReferenced(method.DeclaringType, true, typeReferences);
}
if (method.IsGenericMethod && !method.IsGenericMethodDefinition && !method.ContainsGenericParameters)
{
// closed generic method
Type[] typeArgs = method.GetGenericArguments();
for (int i = 1; i < typeArgs.Length; ++i)
{
EnsureTypeReferenced(typeArgs[i], true, typeReferences);
}
}
ParameterInfo[] parameters = method.GetParameters();
if (parameters != null)
{
foreach (ParameterInfo parameter in parameters)
{
EnsureTypeReferenced(parameter.ParameterType, false, typeReferences);
}
}
ReadOnlyCollection <Expression> callArguments = methodCall.Arguments;
for (int i = 0; i < callArguments.Count; i++)
{
FindTypeReferences(callArguments[i], typeReferences);
}
return;
case ExpressionType.NewArrayInit:
NewArrayExpression newArray = (NewArrayExpression)expression;
EnsureTypeReferenced(newArray.Type.GetElementType(), true, typeReferences);
ReadOnlyCollection <Expression> expressions = newArray.Expressions;
for (int i = 0; i < expressions.Count; i++)
{
FindTypeReferences(expressions[i], typeReferences);
}
return;
case ExpressionType.NewArrayBounds:
NewArrayExpression newArrayBounds = (NewArrayExpression)expression;
EnsureTypeReferenced(newArrayBounds.Type.GetElementType(), true, typeReferences);
ReadOnlyCollection <Expression> boundExpressions = newArrayBounds.Expressions;
for (int i = 0; i < boundExpressions.Count; i++)
{
FindTypeReferences(boundExpressions[i], typeReferences);
}
return;
case ExpressionType.New:
NewExpression newExpression = (NewExpression)expression;
if (newExpression.Constructor != null)
{
EnsureTypeReferenced(newExpression.Constructor.DeclaringType, true, typeReferences);
}
else
{
// if no constructors defined (e.g. structs), the simply use the type
EnsureTypeReferenced(newExpression.Type, true, typeReferences);
}
ReadOnlyCollection <Expression> ctorArguments = newExpression.Arguments;
for (int i = 0; i < ctorArguments.Count; i++)
{
FindTypeReferences(ctorArguments[i], typeReferences);
}
return;
case ExpressionType.TypeIs:
TypeBinaryExpression typeBinary = (TypeBinaryExpression)expression;
FindTypeReferences(typeBinary.Expression, typeReferences);
EnsureTypeReferenced(typeBinary.TypeOperand, true, typeReferences);
return;
case ExpressionType.TypeAs:
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
UnaryExpression unary = (UnaryExpression)expression;
FindTypeReferences(unary.Operand, typeReferences);
EnsureTypeReferenced(unary.Type, true, typeReferences);
return;
case ExpressionType.ArrayLength:
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Not:
case ExpressionType.Quote:
case ExpressionType.UnaryPlus:
UnaryExpression unaryExpression = (UnaryExpression)expression;
FindTypeReferences(unaryExpression.Operand, typeReferences);
return;
// Expression Tree V2.0 types. This is due to the hosted VB compiler generating ET V2.0 nodes
case ExpressionType.Block:
BlockExpression block = (BlockExpression)expression;
ReadOnlyCollection <ParameterExpression> variables = block.Variables;
for (int i = 0; i < variables.Count; i++)
{
FindTypeReferences(variables[i], typeReferences);
}
ReadOnlyCollection <Expression> blockExpressions = block.Expressions;
for (int i = 0; i < blockExpressions.Count; i++)
{
FindTypeReferences(blockExpressions[i], typeReferences);
}
return;
case ExpressionType.Assign:
BinaryExpression assign = (BinaryExpression)expression;
FindTypeReferences(assign.Left, typeReferences);
FindTypeReferences(assign.Right, typeReferences);
return;
}
Fx.Assert("Don't understand expression type " + expression.NodeType);
return;
}
public ListInitExpressionProxy(ListInitExpression node) {
_node = node;
}
private bool EqualsListInit(ListInitExpression x, ListInitExpression y)
{
return(this.EqualsNew(x.NewExpression, y.NewExpression) &&
Equals(x.Initializers, y.Initializers, this.EqualsElementInit));
}
protected override Expression VisitListInit(ListInitExpression node) => null;
internal override Expression VisitListInit(ListInitExpression init)
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjectionToEntity, this.type, init.ToString()));
}
protected override DbExpression VisitListInit(ListInitExpression exp)
{
object list = ExpressionEvaluator.Evaluate(exp);
return(this.Visit(ExpressionExtension.MakeWrapperAccess(list, exp.Type)));
}
public virtual EditableListInitExpression Edit(ListInitExpression expression)
{
}
protected virtual void VisitListInit(ListInitExpression init)
{
VisitNew(init.NewExpression);
VisitElementInitializerList(init.Initializers);
}
protected override Expression VisitListInit(ListInitExpression expression)
{
return(base.VisitListInit(expression));
}
protected override Expression VisitListInit(ListInitExpression node)
{
return(base.VisitListInit(node));
}
private void TraverseListInitExpression(ListInitExpression listInitExpression)
{
TraverseExpressions((from i in listInitExpression.Initializers
select i.Arguments.Cast <Expression>()).UnionAll());
TraverseExpression(listInitExpression.NewExpression);
}
protected override Expression VisitListInit(ListInitExpression node)
{
throw CreateExpressionNotSupportedException(node);
}
bool IEvaluatableExpressionFilter.IsEvaluatableListInit(ListInitExpression node) => true;
protected override string VisitListInit(ListInitExpression node) => throw new NotImplementedException();
// RewriteListInitExpression
private Result RewriteListInitExpression(Expression expr, Stack stack)
{
ListInitExpression node = (ListInitExpression)expr;
//ctor runs on initial stack
Result newResult = RewriteExpression(node.NewExpression, stack);
Expression rewrittenNew = newResult.Node;
RewriteAction action = newResult.Action;
ReadOnlyCollection <ElementInit> inits = node.Initializers;
ChildRewriter[] cloneCrs = new ChildRewriter[inits.Count];
for (int i = 0; i < inits.Count; i++)
{
ElementInit init = inits[i];
//initializers all run on nonempty stack
ChildRewriter cr = new ChildRewriter(this, Stack.NonEmpty, init.Arguments.Count);
cr.Add(init.Arguments);
action |= cr.Action;
cloneCrs[i] = cr;
}
switch (action)
{
case RewriteAction.None:
break;
case RewriteAction.Copy:
ElementInit[] newInits = new ElementInit[inits.Count];
for (int i = 0; i < inits.Count; i++)
{
ChildRewriter cr = cloneCrs[i];
if (cr.Action == RewriteAction.None)
{
newInits[i] = inits[i];
}
else
{
newInits[i] = Expression.ElementInit(inits[i].AddMethod, cr[0, -1]);
}
}
expr = Expression.ListInit((NewExpression)rewrittenNew, new TrueReadOnlyCollection <ElementInit>(newInits));
break;
case RewriteAction.SpillStack:
RequireNotRefInstance(node.NewExpression);
ParameterExpression tempNew = MakeTemp(rewrittenNew.Type);
Expression[] comma = new Expression[inits.Count + 2];
comma[0] = Expression.Assign(tempNew, rewrittenNew);
for (int i = 0; i < inits.Count; i++)
{
ChildRewriter cr = cloneCrs[i];
Result add = cr.Finish(Expression.Call(tempNew, inits[i].AddMethod, cr[0, -1]));
comma[i + 1] = add.Node;
}
comma[inits.Count + 1] = tempNew;
expr = MakeBlock(comma);
break;
default:
throw ContractUtils.Unreachable;
}
return(new Result(action, expr));
}
/// <summary>
/// Visits the children of the <see cref="System.Linq.Expressions.ListInitExpression"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
protected override Expression VisitListInit(ListInitExpression node)
{
// new Dictionary() { Add(5, a), Add(6, c) }
InvalidExpression(node);
return(null);
}
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
protected override Expression VisitListInit(ListInitExpression node)
{
throw new NotSupportedException(string.Format(Resources.EX_PROCESS_NODE_NOT_SUPPORT, node.GetType().Name));
}
protected override Expression VisitListInit(ListInitExpression node)
{
Visit(node.NewExpression);
VisitExpressions('{', ',', node.Initializers, e => VisitElementInit(e));
return(node);
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/>.
/// </summary>
/// <param name="expression"><see cref="ListInitExpression"/> to visit.</param>
/// <returns>Returns a <see cref="ListInitExpression"/>.</returns>
/// <seealso cref="ExpressionVisitor.VisitListInitExpression"/>
protected override object VisitListInitExpression(ListInitExpression expression)
{
return(Expression.ListInit(Visit <NewExpression>(expression.NewExpression), VisitObjectCollection <ElementInit>(expression.Initializers)));
}
private void EmitListInit(ListInitExpression init)
{
EmitExpression(init.NewExpression);
LocalBuilder loc = null;
if (init.NewExpression.Type.GetTypeInfo().IsValueType)
{
loc = _ilg.DeclareLocal(init.NewExpression.Type);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.Emit(OpCodes.Ldloca, loc);
}
EmitListInit(init.Initializers, loc == null, init.NewExpression.Type);
if (loc != null)
{
_ilg.Emit(OpCodes.Ldloc, loc);
}
}
protected override Expression VisitListInit(ListInitExpression init)
{
return base.VisitListInit(init);
}
