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); }