private Expression HandleInvocationExpression(InvocationExpression invocation)
{
if (invocation.Type != typeof(void))
{
return(invocation.Update(invocation.Expression,
ReplaceValuesOf <TextWriter>(invocation.Arguments, ExpressionShortcuts.Null <TextWriter>()).Select(Visit)
));
}
var context = ExpressionShortcuts.Var <BindingContext>();
var writer = ExpressionShortcuts.Var <TextWriter>();
invocation = invocation.Update(ExpressionUtils.ReplaceParameters(invocation.Expression, context),
ExpressionUtils.ReplaceParameters(
ReplaceValuesOf <TextWriter>(invocation.Arguments, writer), new Expression[] { context }
).Select(Visit)
);
var formatProvider = ExpressionShortcuts.Arg(CompilationContext.Configuration.FormatProvider);
var block = ExpressionShortcuts.Block()
.Parameter(writer, ExpressionShortcuts.New(() => new PolledStringWriter((IFormatProvider)formatProvider)))
.Line(writer.Using((o, body) =>
body.Line(invocation)
.Line(o.Call(x => (object)x.ToString()))
));
var continuation = _expressionCompiler.Compile(Expression.Lambda <Func <BindingContext, object> >(block, (ParameterExpression)context));
return(ExpressionShortcuts.Arg <object>(Expression.Invoke(Expression.Constant(continuation), CompilationContext.BindingContext)));
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var args = VisitMemberAndExpressionList(node.Arguments);
var expr = Visit(node.Expression);
return(node.Update(expr, args));
}
/// <summary>
/// 访问 <see cref="InvocationExpression"/>。
/// </summary>
/// <param name="invocationExp">要访问的表达式。</param>
/// <returns></returns>
protected virtual Expression VisitInvocation(InvocationExpression invocationExp)
{
var args = VisitMemberAndExpressionList(invocationExp.Arguments);
var expr = Visit(invocationExp.Expression);
return(invocationExp.Update(expr, args));
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var arguments = node.Arguments.Select(arg => Visit(arg)).ToList();
var expression = Visit(node.Expression);
node = node.Update(expression, arguments);
if (arguments.Any(arg => !IsEvaluatedAsConstant(arg)))
{
goto bypass;
}
if (!IsEvaluatedAsConstant(expression))
{
goto bypass;
}
/* If all the arguments, and the lambda expression itself, are evaluated,
* Then the invocation can also be evaluated.
*/
return(EvaluateToConstant(node));
bypass:
return(node);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var o = Visit(node.Expression);
var e = Visit(node.Arguments);
var args = (IList <Expression>)e;
var n = node.Arguments.Count;
var all = Pop(n, out var ess);
var os = _tilingState.Pop();
all &= os;
if (all)
{
_tilingState.Push(true);
}
else
{
_tilingState.Push(false);
EvaluateIf(os, ref o);
EvaluateIf(ess, ref args);
}
return(node.Update(o, args));
}
private static InvocationExpression Update(InvocationExpression node)
{
// Tests the call of Update to Expression.Invoke factories.
InvocationExpression res = node.Update(node.Expression, node.Arguments.ToArray());
Assert.Same(node, res);
return(res);
}
private static InvocationExpression UpdateInvocation(InvocationExpression i, LambdaExpression lambda)
{
var lambdaArgs = lambda.Parameters.ToList();
lambdaArgs.Add(typeBuilderParameter);
lambda = Expression.Lambda(lambda.Body, lambdaArgs);
var invocationArgs = i.Arguments.ToList();
invocationArgs.Add(typeBuilderParameter);
i = i.Update(lambda, invocationArgs);
return(i);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var parameters = node.Type.GetMethod("Invoke").GetParameters();
Expression expression;
if (node.Expression.NodeType == ExpressionType.Lambda)
{
expression = _lambdaVisitor.Visit(node.Expression);
}
else
{
expression = Visit(node.Expression);
}
var args = VisitArguments(parameters, node.Arguments);
return(node.Update(expression, 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);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var changed = false;
var arguments = new Expression[node.Arguments.Count];
var i = 0;
foreach (var arg in node.Arguments)
{
var argument = Visit(arg);
arguments[i] = argument;
changed |= argument != arg;
i++;
}
var obj = Visit(node.Expression);
changed |= obj != node.Expression;
if (changed)
{
return(node.Update(obj, arguments));
}
return(node);
}
/// <summary>
/// Visits the children of the <see cref="System.Linq.Expressions.InvocationExpression" />.
/// </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 VisitInvocation(InvocationExpression node)
{
var expr = Visit(node.Expression);
var args = Visit(node.Arguments);
if (expr.NodeType == ExpressionType.Parameter)
{
var parameter = (ParameterExpression)expr;
// Turns f(x, y, z) into f((x, y, z)) when f is an unbound parameter, i.e. representing a known resource.
if (IsUnboundParameter(parameter))
{
if (args.Count > 0)
{
var tuple = ExpressionTupletizer.Pack(args);
var funcType = Expression.GetDelegateType(tuple.Type, node.Type);
var function = Expression.Parameter(funcType, parameter.Name);
return(Expression.Invoke(function, tuple));
}
}
}
return(node.Update(expr, args));
}
private static InvocationExpression Update(InvocationExpression node)
{
// Tests the call of Update to Expression.Invoke factories.
var res = node.Update(node.Expression, node.Arguments.ToArray());
Assert.NotSame(node, res);
return res;
}
protected virtual Expression VisitInvocation(InvocationExpression expr)
{
return(expr.Update(Visit(expr.Expression), expr.Arguments.Select(a => Visit(a))));
}
public void GivenTwoInvocationsWhenSameThenAreEquivalentShouldReturnTrue(InvocationExpression invocation)
{
Assert.True(eq.AreEquivalent(
invocation,
invocation.Update(invocation.Expression, invocation.Arguments)));
}
/// <summary>Updates the supplied expression using the appropriate parameter.</summary>
/// <param name="expression">The expression to update.</param>
/// <param name="oldParameter">The original parameter of the expression.</param>
/// <param name="newParameter">The target parameter of the expression.</param>
/// <returns>The updated expression.</returns>
private static Expression RebindParameter(Expression expression, ParameterExpression oldParameter, ParameterExpression newParameter)
{
if (expression == null)
{
return(null);
}
switch (expression.NodeType)
{
case ExpressionType.Parameter:
{
ParameterExpression parameterExpression = (ParameterExpression)expression;
return(parameterExpression.Name == oldParameter.Name ? newParameter : parameterExpression);
}
case ExpressionType.MemberAccess:
{
MemberExpression memberExpression = (MemberExpression)expression;
return(memberExpression.Update(RebindParameter(memberExpression.Expression, oldParameter, newParameter)));
}
case ExpressionType.Negate:
case ExpressionType.Not:
case ExpressionType.Convert:
case ExpressionType.Quote:
{
UnaryExpression unaryExpression = (UnaryExpression)expression;
return(unaryExpression.Update(RebindParameter(unaryExpression.Operand, oldParameter, newParameter)));
}
case ExpressionType.Coalesce:
case ExpressionType.ExclusiveOr:
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Or:
case ExpressionType.OrElse:
case ExpressionType.Equal:
case ExpressionType.NotEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
{
BinaryExpression binaryExpression = (BinaryExpression)expression;
return(binaryExpression.Update(RebindParameter(binaryExpression.Left, oldParameter, newParameter), binaryExpression.Conversion, RebindParameter(binaryExpression.Right, oldParameter, newParameter)));
}
case ExpressionType.Call:
{
MethodCallExpression methodCallExpression = (MethodCallExpression)expression;
return(methodCallExpression.Update(RebindParameter(methodCallExpression.Object, oldParameter, newParameter), methodCallExpression.Arguments.Select(arg => RebindParameter(arg, oldParameter, newParameter))));
}
case ExpressionType.Invoke:
{
InvocationExpression invocationExpression = (InvocationExpression)expression;
return(invocationExpression.Update(RebindParameter(invocationExpression.Expression, oldParameter, newParameter), invocationExpression.Arguments.Select(arg => RebindParameter(arg, oldParameter, newParameter))));
}
case ExpressionType.Lambda:
{
LambdaExpression lambdaExpression = (LambdaExpression)expression;
return(Expression.Lambda(RebindParameter(lambdaExpression.Body, oldParameter, newParameter), lambdaExpression.Parameters));
}
default:
{
return(expression);
}
}
}
InvocationExpression Convert(InvocationExpression expr)
{
return(expr.Update(Process(expr.Expression), Process(expr.Arguments)));
}
