public void UpdateToSameReturnsSameTyped1()
{
CallSiteBinder binder = Binder.GetMember(
CSharpBinderFlags.None, "Member", GetType(),
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
Expression arg = Expression.Constant(null);
DynamicExpression exp = Expression.MakeDynamic(typeof(Func <CallSite, object, string>), binder, arg);
Assert.Same(exp, exp.Update(new[] { arg }));
Assert.Same(exp, exp.Update(Enumerable.Repeat(arg, 1)));
Assert.Same(exp, exp.Update(exp.Arguments));
}
public void UpdateToSameReturnsSameTyped0()
{
CallSiteBinder binder = Binder.GetMember(
CSharpBinderFlags.None, "Member", GetType(),
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
DynamicExpression exp = Expression.MakeDynamic(typeof(Func <CallSite, string>), binder);
Assert.Same(exp, exp.Update(null));
Assert.Same(exp, exp.Update(Array.Empty <Expression>()));
Assert.Same(exp, exp.Update(Enumerable.Repeat <Expression>(null, 0)));
Assert.Same(exp, exp.Update(exp.Arguments));
}
public void UpdateToDifferentReturnsDifferent1()
{
CallSiteBinder binder = Binder.GetMember(
CSharpBinderFlags.None, "Member", GetType(),
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
Expression arg = Expression.Constant(null);
DynamicExpression exp = Expression.MakeDynamic(typeof(Func <CallSite, object, object>), binder, arg);
Assert.NotSame(exp, exp.Update(new[] { Expression.Constant(null) }));
// Wrong number of arguments continues to attempt to create new expression, which fails.
AssertExtensions.Throws <ArgumentException>("method", () => exp.Update(null));
AssertExtensions.Throws <ArgumentException>("method", () => exp.Update(new[] { arg, arg }));
}
public void UpdateToSameReturnsSame2()
{
CallSiteBinder binder = Binder.GetMember(
CSharpBinderFlags.None, "Member", GetType(),
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
Expression arg0 = Expression.Constant(null);
Expression arg1 = Expression.Constant(null);
DynamicExpression exp = Expression.MakeDynamic(
typeof(Func <CallSite, object, object, object>), binder, arg0, arg1);
Assert.Same(exp, exp.Update(new[] { arg0, arg1 }));
Assert.Same(exp, exp.Update(exp.Arguments));
}
protected override Expression VisitDynamic(DynamicExpression node)
{
// NB: We have to be conservative here; any argument could be passed in a ref position.
var args = node.Arguments.Select(VisitLVal);
return(node.Update(args));
}
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);
}
private static Expression SetChildren(ReadOnlySpan <Expression> newChildren, DynamicExpression d) => d.Update(newChildren.ToArray());
