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