protected override Expression VisitInvocation(InvocationExpression iv)
{
if (iv.Expression is LambdaExpression)
return Visit(ExpressionReplacer.Replace(iv));
else
return base.VisitInvocation(iv); //Just calling a delegate in the projector
}
protected InvocationExpression UpdateInvocation(InvocationExpression iv, Expression expression, IEnumerable<Expression> args)
{
if (args != iv.Arguments || expression != iv.Expression) {
return Expression.Invoke(expression, args);
}
return iv;
}
/// <summary>
/// Flatten calls to Invoke so that Entity Framework can understand it. Calls to Invoke are generated
/// by PredicateBuilder.
/// </summary>
protected override Expression VisitInvocation(InvocationExpression iv)
{
Expression target = iv.Expression;
if (target is MemberExpression) target = TransformExpr ((MemberExpression)target);
if (target is ConstantExpression) target = ((ConstantExpression)target).Value as Expression;
LambdaExpression lambda = (LambdaExpression)target;
Dictionary<ParameterExpression, Expression> replaceVars;
if (_replaceVars == null)
replaceVars = new Dictionary<ParameterExpression, Expression> ();
else
replaceVars = new Dictionary<ParameterExpression, Expression> (_replaceVars);
try
{
for (int i = 0; i < lambda.Parameters.Count; i++)
replaceVars.Add (lambda.Parameters[i], iv.Arguments[i]);
}
catch (ArgumentException ex)
{
throw new InvalidOperationException ("Invoke cannot be called recursively - try using a temporary variable.", ex);
}
return new ExpressionExpander (replaceVars).Visit (lambda.Body);
}
private ExpressionNode ParseInvocation(InvocationExpression ie)
{
var args = new List<LiteralNode>();
foreach(var arg in ie.Arguments)
{
if (arg is ParameterExpression)
{
var name = ((ParameterExpression)arg).Name;
args.Add(new VariableNode(name));
}
else if (arg is ConstantExpression)
{
var token = (String)((ConstantExpression)arg).Value;
args.Add(new ConstantNode(token));
}
else
{
return Unsupported(arg);
}
}
if (ie.Expression is MemberExpression)
{
var term = GetTermFromMemberExpression((MemberExpression)ie.Expression);
return new TermNode(term, args.ToArray());
}
return Unsupported(ie);
}
private static void AssertInvokeIsOptimized(InvocationExpression expr, Expression expression, IReadOnlyList<Expression> args)
{
var n = args.Count;
var updated = Update(expr);
var visited = Visit(expr);
foreach (var node in new[] { expr, updated, visited })
{
Assert.Same(expression, node.Expression);
AssertInvocation(n, node);
var argProvider = node as IArgumentProvider;
Assert.NotNull(argProvider);
Assert.Equal(n, argProvider.ArgumentCount);
if (node != visited) // our visitor clones argument nodes
{
for (var i = 0; i < n; i++)
{
Assert.Same(args[i], argProvider.GetArgument(i));
Assert.Same(args[i], node.Arguments[i]);
}
}
}
}
private void DoVisit(InvocationExpression invocation)
{
foreach (var arg in invocation.Arguments)
{
Visit(arg);
}
Visit(invocation.Expression);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
if (typeof(Delegate).IsAssignableFrom(node.Expression.Type) || IsObservableFuncType(node.Expression.Type, node.Arguments.Count))
{
return VisitMethodCall(Expression.Call(node.Expression, node.Expression.Type.GetMethod("Invoke"), node.Arguments));
}
throw new InvalidOperationException("Unclear what to invoke.");
}
protected override Expression VisitInvocation(InvocationExpression node)
{
if (typeof(Delegate).GetTypeInfo().IsAssignableFrom(node.Expression.Type.GetTypeInfo()) || IsObservableFuncType(node.Expression.Type, node.Arguments.Count))
{
var method = node.Expression.Type.GetRuntimeMethods().FirstOrDefault(m => m.Name == "Invoke");
return VisitMethodCall(Expression.Call(node.Expression, method, node.Arguments));
}
throw new InvalidOperationException("Unclear what to invoke.");
}
protected static InvocationExpression UpdateInvocation(InvocationExpression node, Expression expression,
IEnumerable<Expression> args)
{
if (node.Arguments != args || node.Expression != expression)
{
return Expression.Invoke(expression, args);
}
return node;
}
/// <summary>
/// Initializes a new instance of the <see cref="InvocationExpectation"/> class.
/// </summary>
/// <param name="lambdaExpression">The lambda expression.</param>
public InvocationExpectation(LambdaExpression lambdaExpression)
{
var expression = lambdaExpression.Body as InvocationExpression;
if (expression == null)
throw new ArgumentException("Invalid lambda expression", "lambdaExpression");
_expression = expression;
}
public static Expression Replace(InvocationExpression invocation)
{
LambdaExpression lambda = invocation.Expression as LambdaExpression;
var replacer = new ExpressionReplacer()
{
replacements = 0.To(lambda.Parameters.Count).ToDictionaryEx(i => lambda.Parameters[i], i => invocation.Arguments[i])
};
return replacer.Visit(lambda.Body);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var args = Visit(node.Arguments);
foreach(var arg in args)
AddParameter(arg);
var expr = Visit(node.Expression);
AddParameter(expr);
return null;
}
private static ParsedCallExpression ParseInvokationExpression(InvocationExpression expression)
{
var target = Helpers.GetValueProducedByExpression(expression.Expression);
var method = target.GetType().GetMethod("Invoke");
return new ParsedCallExpression(
calledMethod: method,
callTargetExpression: expression.Expression,
argumentsExpressions: from argument in expression.Arguments.Zip(method.GetParameters(), (x, y) => new { Expression = x, ParameterInfo = y })
select new ParsedArgumentExpression(argument.Expression, argument.ParameterInfo));
}
protected override Expression VisitInvocation(InvocationExpression node)
{
ConstantExpression varNameExpr;
ParameterExpression contextExpr;
if ((contextExpr = node.Expression as ParameterExpression) != null &&
contextExpr.Name == _contextVarName &&
node.Arguments.Count == 1 &&
(varNameExpr = node.Arguments[0] as ConstantExpression) != null)
{
Variables.Add((string)varNameExpr.Value);
}
return base.VisitInvocation(node);
}
internal Expression AutoInline(InvocationExpression expression)
{
this.isLocked = true;
if (expression == null) throw new ArgumentNullException("expression");
var lambda = (LambdaExpression) expression.Expression;
var childScope = new ExpressionRewriter(this);
var lambdaParams = lambda.Parameters;
var invokeArgs = expression.Arguments;
if (lambdaParams.Count != invokeArgs.Count) throw new InvalidOperationException("Lambda/invoke mismatch");
for (int i = 0; i < lambdaParams.Count; i++)
{
childScope.Subst(lambdaParams[i], invokeArgs[i]);
}
return childScope.Apply(lambda.Body);
}
protected override Expression VisitInvocation(InvocationExpression node)
{
var baseResult = (InvocationExpression)base.VisitInvocation(node);
if (baseResult.Expression.NodeType == ExpressionType.Call)
{
var methodCallExpression = (MethodCallExpression)baseResult.Expression;
if (IsCompileMethod(methodCallExpression.Method))
{
Expression result;
if (TrySubstituteExpression(methodCallExpression.Object, baseResult.Arguments, out result))
return result;
}
}
return baseResult;
}
protected virtual Expression VisitInvocation(InvocationExpression iv)
{
IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
Expression expr = this.Visit(iv.Expression);
return this.UpdateInvocation(iv, expr, args);
}
/// <summary>
/// InvocationExpression visit method
/// </summary>
/// <param name="iv">The InvocationExpression to visit</param>
/// <returns>The visited InvocationExpression</returns>
internal override Expression VisitInvocation(InvocationExpression iv)
{
this.cantTranslateExpression = true;
return iv;
}
protected virtual Expression VisitInvocation (InvocationExpression invocation)
{
Expression[] args;
bool changed = VisitExpressionList (invocation.Arguments, out args);
Expression e = Visit (invocation.Expression);
changed = (e != invocation.Expression) || changed;
if (changed)
return Expression.Invoke (e, args);
return invocation;
}
/// <summary>
/// Visits an InvocationExpression.
/// </summary>
/// <param name="node">The InvocationExpression.</param>
/// <returns>The InvocationExpression.</returns>
protected override Expression VisitInvocation(InvocationExpression node)
{
throw new NotImplementedException();
}
private static string VisitInvocation(InvocationExpression node)
{
throw new NotImplementedException();
}
/// <summary>
/// Visits an InvocationExpression.
/// </summary>
/// <param name="iv">The InvocationExpression.</param>
/// <returns>The InvocationExpression (possibly modified).</returns>
protected virtual Expression VisitInvocation(InvocationExpression iv)
{
IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
Expression expr = this.Visit(iv.Expression);
if (args != iv.Arguments || expr != iv.Expression)
{
return Expression.Invoke(expr, args);
}
return iv;
}
private Expression Convert(LinqExp.InvocationExpression linqInvoke)
{
return(Expression.Invoke(
ConvertExp(linqInvoke.Expression),
Convert(linqInvoke.Arguments)));
}
protected override Expression VisitInvocation(InvocationExpression iv)
{
this.Write("Invoke(");
this.WriteLine(Indentation.Inner);
this.VisitExpressionList(iv.Arguments);
this.Write(", ");
this.WriteLine(Indentation.Same);
this.Visit(iv.Expression);
this.WriteLine(Indentation.Same);
this.Write(")");
this.Indent(Indentation.Outer);
return iv;
}
protected override MSAst.Expression VisitInvocation(MSAst.InvocationExpression node)
{
return(VisitCall(base.VisitInvocation(node)));
}
private HqlTreeNode VisitInvocationExpression(InvocationExpression expression)
{
return VisitExpression(expression.Expression);
}
/// <summary>
/// Visit a invocation expression.
/// </summary>
/// <param name="invocationExp"></param>
/// <returns></returns>
protected virtual Expression VisitInvocation(InvocationExpression invocationExp)
{
IEnumerable<Expression> args = VisitList(invocationExp.Arguments);
Expression expr = Visit(invocationExp.Expression);
return args != invocationExp.Arguments || expr != invocationExp.Expression
? Expression.Invoke(expr, args)
: invocationExp;
}
/// <summary>
/// InvocationExpression visit method
/// </summary>
/// <param name="iv">The InvocationExpression to visit</param>
/// <returns>The visited InvocationExpression</returns>
internal override Expression VisitInvocation(InvocationExpression iv)
{
throw new NotImplementedException();
}
protected virtual System.Linq.Expressions.Expression VisitInvocation(InvocationExpression iv)
{
IEnumerable<System.Linq.Expressions.Expression> args = VisitExpressionList(iv.Arguments);
System.Linq.Expressions.Expression expr = Visit(iv.Expression);
// ReSharper disable once PossibleUnintendedReferenceComparison
if(args != iv.Arguments || expr != iv.Expression)
{
return System.Linq.Expressions.Expression.Invoke(expr, args);
}
return iv;
}
protected virtual bool CompareInvocation(InvocationExpression a, InvocationExpression b)
{
return this.Compare(a.Expression, b.Expression)
&& this.CompareExpressionList(a.Arguments, b.Arguments);
}
/// <summary>
/// We are doing an inline call to a lambda expression.
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
protected override Expression VisitInvocation(InvocationExpression expression)
{
///
/// Declare all the parameters for lookup.
///
if (!(expression.Expression is LambdaExpression))
throw new NotImplementedException("Do not know how to invoke a non-lambda call like '" + expression.ToString() + "'");
var lambda = expression.Expression as LambdaExpression;
var paramArgs = lambda.Parameters.Zip(expression.Arguments, (p, a) => Tuple.Create(p, a));
var paramDefineToPopers = from pair in paramArgs
select CodeContext.Add(pair.Item1.Name, pair.Item2);
var allParamDefineToPopers = paramDefineToPopers.ToArray();
///
/// Do the work. We parse the body of the lambda expression. The references to the parameters should be automatically
/// dealt with.
///
var result = lambda.Body.Resolve(GeneratedCode, CodeContext, MEFContainer);
///
/// Now, pop everything off!
///
foreach (var param in allParamDefineToPopers)
{
param.Pop();
}
///
/// Done!
///
return result;
}
/// <summary>
/// Visits an InvocationExpression.
/// </summary>
/// <param name="node">The InvocationExpression.</param>
/// <returns>The InvocationExpression.</returns>
protected override Expression VisitInvocation(InvocationExpression node)
{
_sb.Append("<InvocationExpression>");
return node;
}