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