/// <summary> /// Visits the children of the <see cref="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 internal virtual Expression VisitListInit(ListInitExpression node) { return(node.Update( VisitAndConvert(node.NewExpression, "VisitListInit"), Visit(node.Initializers, VisitElementInit) )); }
protected override Expression VisitListInit(ListInitExpression node) { var n = (NewExpression)VisitNew(node.NewExpression); var initializers = VisitElementInitializerList(node.Initializers); return(node.Update(n, initializers)); }
/// <summary> /// 访问 <see cref="ListInitExpression"/>。 /// </summary> /// <param name="listInitExp">要访问的表达式。</param> /// <returns></returns> protected virtual Expression VisitListInit(ListInitExpression listInitExp) { var n = (NewExpression)VisitNew(listInitExp.NewExpression); var initializers = VisitElementInitializerList(listInitExp.Initializers); return(listInitExp.Update(n, initializers)); }
protected override Expression VisitListInit(ListInitExpression node) { var c = VisitAndConvert(node.NewExpression, nameof(VisitListInit)); var a = Visit(node.Initializers, VisitElementInit); var inits = (IList <ElementInit>)a; var n = node.Initializers.Count; var all = Pop(n, out var ess); var cs = _tilingState.Pop(); all &= cs; if (all && _parent.CanEvaluate(node.Type)) { _tilingState.Push(true); } else { _tilingState.Push(false); inits = Reduce(inits, ess); } return(node.Update(c, inits)); }
public void UpdateDifferentNewReturnsDifferent() { ListInitExpression init = Expression.ListInit( Expression.New(typeof(List <int>)), Expression.Constant(1), Expression.Constant(2), Expression.Constant(3)); Assert.NotSame(init, init.Update(Expression.New(typeof(List <int>)), init.Initializers)); }
public void UpdateSameReturnsSame() { ListInitExpression init = Expression.ListInit( Expression.New(typeof(List <int>)), Expression.Constant(1), Expression.Constant(2), Expression.Constant(3)); Assert.Same(init, init.Update(init.NewExpression, init.Initializers.ToArray())); }
protected override Expression VisitListInit(ListInitExpression node) { // If we here, than eval the whole block failed, don't touch constructor! _allowEval = false; var newExpr = VisitAndConvert(node.NewExpression, "VisitListInit"); _allowEval = true; // ReSharper disable once AssignNullToNotNullAttribute return(node.Update(newExpr, Visit(node.Initializers, VisitElementInit))); }
public void UpdateDifferentInitializersReturnsDifferent() { MethodInfo meth = typeof(List <int>).GetMethod("Add"); ElementInit[] inits = new[] { Expression.ElementInit(meth, Expression.Constant(1)), Expression.ElementInit(meth, Expression.Constant(2)), Expression.ElementInit(meth, Expression.Constant(3)) }; ListInitExpression init = Expression.ListInit(Expression.New(typeof(List <int>)), inits); Assert.NotSame(init, init.Update(Expression.New(typeof(List <int>)), inits)); }
protected override Expression VisitListInit(ListInitExpression node) { var visitedNewExpression = VisitNew(node.NewExpression); var visitedInitializers = node.Initializers.Select(VisitElementInit).ToArray(); if (visitedNewExpression is ConstantExpression objectConstant && visitedInitializers.All(i => i.Arguments.All(a => a is ConstantExpression))) { ApplyListInitializers(objectConstant.Value, visitedInitializers); return(objectConstant); } return(node.Update((NewExpression)visitedNewExpression, visitedInitializers)); }
protected override Expression VisitListInit(ListInitExpression node) { var newExpression = Visit(node.NewExpression) as NewExpression; var changed = newExpression != node.NewExpression; var initializers = new ElementInit[node.Initializers.Count]; for (int i = 0; i < node.Initializers.Count; i++) { initializers[i] = VisitElementInit(node.Initializers[i]); changed |= initializers[i] != node.Initializers[i]; } if (changed) { return(node.Update(newExpression, initializers)); } return(node); }
public void UpdateDoesntRepeatEnumeration() { MethodInfo meth = typeof(List <int>).GetMethod("Add"); ElementInit[] inits = new[] { Expression.ElementInit(meth, Expression.Constant(1)), Expression.ElementInit(meth, Expression.Constant(2)), Expression.ElementInit(meth, Expression.Constant(3)) }; ListInitExpression init = Expression.ListInit(Expression.New(typeof(List <int>)), inits); IEnumerable <ElementInit> newInits = new RunOnceEnumerable <ElementInit>( new[] { Expression.ElementInit(meth, Expression.Constant(1)), Expression.ElementInit(meth, Expression.Constant(2)), Expression.ElementInit(meth, Expression.Constant(3)) }); Assert.NotSame(init, init.Update(init.NewExpression, newInits)); }
public T?Simplify <T>(T?expression) where T : Expression { if (expression is null) { return(null); } Expression expr = expression.Reduce() switch { UnaryExpression unaryExpr => unaryExpr.Update(Simplify(unaryExpr.Operand)), BinaryExpression binaryExpr => binaryExpr.Update(Simplify(binaryExpr.Left), binaryExpr.Conversion, Simplify(binaryExpr.Right)), LambdaExpression lambdaExpr => Expression.Lambda(Simplify(lambdaExpr.Body), lambdaExpr.Name, lambdaExpr.TailCall, Simplify(lambdaExpr.Parameters)), TryExpression tryExpr => tryExpr.Update(Simplify(tryExpr.Body), Simplify(tryExpr.Handlers), Simplify(tryExpr.Finally), Simplify(tryExpr.Fault)), NewExpression newExpr => newExpr.Update(Simplify(newExpr.Arguments)), GotoExpression gotoExpr => gotoExpr.Update(gotoExpr.Target, Simplify(gotoExpr.Value)), LoopExpression loopExpr => loopExpr.Update(loopExpr.BreakLabel, loopExpr.ContinueLabel, Simplify(loopExpr.Body)), BlockExpression blockExpr => blockExpr.Update(Simplify(blockExpr.Variables), Simplify(blockExpr.Expressions)), IndexExpression indexExpr => indexExpr.Update(Simplify(indexExpr.Object) !, Simplify(indexExpr.Arguments)), LabelExpression labelExpr => labelExpr.Update(labelExpr.Target, Simplify(labelExpr.DefaultValue)), MemberExpression memberExpr => memberExpr.Update(Simplify(memberExpr.Expression)), SwitchExpression switchExpr => switchExpr.Update(Simplify(switchExpr.SwitchValue), Simplify(switchExpr.Cases), Simplify(switchExpr.DefaultBody)), DynamicExpression dynamicExpr => dynamicExpr.Update(Simplify(dynamicExpr.Arguments)), ListInitExpression listInitExpr => listInitExpr.Update(Simplify(listInitExpr.NewExpression), Simplify(listInitExpr.Initializers)), NewArrayExpression newArrayExpr => newArrayExpr.Update(Simplify(newArrayExpr.Expressions)), InvocationExpression invokeExpr => invokeExpr.Update(Simplify(invokeExpr.Expression), Simplify(invokeExpr.Arguments)), MemberInitExpression memberInitExpr => memberInitExpr.Update(Simplify(memberInitExpr.NewExpression), memberInitExpr.Bindings), MethodCallExpression methodCallExpr => methodCallExpr.Update(Simplify(methodCallExpr.Object), Simplify(methodCallExpr.Arguments)), TypeBinaryExpression typeBinaryExpr => typeBinaryExpr.Update(Simplify(typeBinaryExpr.Expression)), ConditionalExpression condExpr => condExpr.Update(Simplify(condExpr.Test), Simplify(condExpr.IfTrue), Simplify(condExpr.IfFalse)), RuntimeVariablesExpression runtimeVarExpr => runtimeVarExpr.Update(Simplify(runtimeVarExpr.Variables)), _ => expression }; foreach (var transform in transformers) { expr = transform.Transform(expr, this); } return((T)expr); }
protected virtual Expression VisitListInit(ListInitExpression expr) { return(expr.Update((NewExpression)Visit(expr.NewExpression), expr.Initializers.Select(i => VisitElementInit(i)))); }
ListInitExpression Convert(ListInitExpression expr) { return(expr.Update(Process(expr.NewExpression), expr.Initializers.Select(i => i.Update(Process(i.Arguments))))); }