public override Expression CloneExpressionOnly()
        {
            DelegateInvokeExpression result = new DelegateInvokeExpression(Target.CloneExpressionOnly(), Arguments.CloneExpressionsOnly(),
                                                                           InvokeMethodReference, null);

            return(result);
        }
        public override bool Equals(Expression other)
        {
            if (!(other is DelegateInvokeExpression))
            {
                return(false);
            }
            DelegateInvokeExpression delegateInvoke = other as DelegateInvokeExpression;

            if (this.Target == null)
            {
                if (delegateInvoke.Target != null)
                {
                    return(false);
                }
            }
            else if (!this.Target.Equals(delegateInvoke.Target))
            {
                return(false);
            }

            return(this.Arguments.Equals(delegateInvoke.Arguments));
        }
		public override void VisitDelegateInvokeExpression(DelegateInvokeExpression node)
		{
			bool isComplexTarget = IsComplexTarget(node.Target);
			bool needsCast = false;

			if (isComplexTarget)
			{
				WriteToken("(");

				if (node.Target.CodeNodeType == CodeNodeType.LambdaExpression && (node.Target as LambdaExpression).HasType)
				{
					needsCast = true;
					WriteToken("(");
					WriteReferenceAndNamespaceIfInCollision((node.Target as LambdaExpression).ExpressionType);
					WriteToken(")");
					WriteToken("(");
				}
			}

			Visit(node.Target);

			if (isComplexTarget)
			{
				if (needsCast)
				{
					WriteToken(")");
				}

				WriteToken(")");
			}

			WriteToken("(");
			EnterMethodInvocation(node.InvokeMethodReference);
			VisitMethodParameters(node.Arguments);
			LeaveMethodInvocation();
			WriteToken(")");
		}
        private void ProcessDelegateInvokeExpression(DelegateInvokeExpression delegateInvokeExpression)
        {
            if (delegateInvokeExpression.Target == null ||
                delegateInvokeExpression.Target.CodeNodeType != CodeNodeType.VariableReferenceExpression)
            {
                return;
            }

            ProcessVariableReferenceExpression(delegateInvokeExpression.Target as VariableReferenceExpression);
        }
 public override Expression CloneExpressionOnly()
 {
     DelegateInvokeExpression result = new DelegateInvokeExpression(Target.CloneExpressionOnly(), Arguments.CloneExpressionsOnly(),
         InvokeMethodReference, null);
     return result;
 }
        public override Expression Clone()
        {
            DelegateInvokeExpression result = new DelegateInvokeExpression(Target.Clone(), Arguments.Clone(), InvokeMethodReference, instructions);
			return result;
        }
 public virtual void VisitDelegateInvokeExpression(DelegateInvokeExpression node)
 {
     Visit(node.Target);
     Visit(node.Arguments);
 }
 public override void VisitDelegateInvokeExpression(DelegateInvokeExpression node)
 {
     if (state == SearchState.Propagation)
     {
         canBePropagated = false;
         return;
     }
     base.VisitDelegateInvokeExpression(node);
 }
		public override void VisitDelegateInvokeExpression(DelegateInvokeExpression node)
		{
			/// Add cast when an argument needs to be of integer type, but the pushed value is of enum type
			base.VisitDelegateInvokeExpression(node);

			CheckArguments(node.InvokeMethodReference.Parameters, node.Arguments);
		}
        public override Expression Clone()
        {
            DelegateInvokeExpression result = new DelegateInvokeExpression(Target.Clone(), Arguments.Clone(), InvokeMethodReference, instructions);

            return(result);
        }