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