/// <summary>
        /// Need to make sure that references to ForAll/Exists that could be to another assembly go to the target contract nodes
        /// implementation.
        /// </summary>
        public override Expression VisitMemberBinding(MemberBinding memberBinding)
        {
            if (memberBinding == null)
            {
                return(null);
            }

            var result = base.VisitMemberBinding(memberBinding);

            memberBinding = result as MemberBinding;
            if (this.targetContractNodes != null && memberBinding != null && memberBinding.TargetObject == null)
            {
                // all methods are static
                Method method = memberBinding.BoundMember as Method;
                if (method == null)
                {
                    return(memberBinding);
                }

                Contract.Assume(this.contractNodes != null);

                if (method.Template == null)
                {
                    if (contractNodes.IsExistsMethod(method))
                    {
                        return(new MemberBinding(null, targetContractNodes.GetExistsTemplate));
                    }

                    if (contractNodes.IsForallMethod(method))
                    {
                        return(new MemberBinding(null, targetContractNodes.GetForAllTemplate));
                    }
                }
                else
                {
                    // template != null
                    Method template     = method.Template;
                    var    templateArgs = method.TemplateArguments;

                    if (contractNodes.IsGenericForallMethod(template))
                    {
                        Contract.Assume(templateArgs != null);
                        Contract.Assume(targetContractNodes.GetForAllGenericTemplate != null);

                        return(new MemberBinding(null,
                                                 targetContractNodes.GetForAllGenericTemplate.GetTemplateInstance(
                                                     targetContractNodes.GetForAllGenericTemplate.DeclaringType, templateArgs[0])));
                    }

                    if (contractNodes.IsGenericExistsMethod(template))
                    {
                        Contract.Assume(templateArgs != null);
                        Contract.Assume(targetContractNodes.GetExistsGenericTemplate != null);

                        return(new MemberBinding(null,
                                                 targetContractNodes.GetExistsGenericTemplate.GetTemplateInstance(
                                                     targetContractNodes.GetExistsGenericTemplate.DeclaringType, templateArgs[0])));
                    }
                }
            }

            return(result);
        }