public virtual ExpressionList VisitExpressionList(ExpressionList list)
 {
     if (list == null) return null;
     for (int i = 0, n = list.Count; i < n; i++)
         list[i] = (Expression)this.Visit(list[i]);
     return list;
 }

        /// <summary>
        /// Visits the call.
        /// </summary>
        /// <param name="destination">The destination.</param>
        /// <param name="receiver">The receiver.</param>
        /// <param name="callee">The callee.</param>
        /// <param name="arguments">The arguments.</param>
        /// <param name="isVirtualCall">if set to <c>true</c> [is virtual call].</param>
        /// <param name="programContext">The program context.</param>
        /// <param name="stateBeforeInstruction">The state before instruction.</param>
        /// <param name="stateAfterInstruction">The state after instruction.</param>
        public override void VisitCall(
            Variable destination, 
            Variable receiver, 
            Method callee, 
            ExpressionList arguments, 
            bool isVirtualCall, 
            Microsoft.Fugue.IProgramContext programContext, 
            Microsoft.Fugue.IExecutionState stateBeforeInstruction, 
            Microsoft.Fugue.IExecutionState stateAfterInstruction)
        {
            if ((callee.DeclaringType.GetRuntimeType() == typeof(X509ServiceCertificateAuthentication) ||
                 callee.DeclaringType.GetRuntimeType() == typeof(X509ClientCertificateAuthentication)) &&
                 (callee.Name.Name.Equals("set_CertificateValidationMode", StringComparison.InvariantCultureIgnoreCase)))
            {
                IAbstractValue value = stateBeforeInstruction.Lookup((Variable)arguments[0]);
                IIntValue intValue = value.IntValue(stateBeforeInstruction);

                if (intValue != null)
                {
                    X509CertificateValidationMode mode = (X509CertificateValidationMode)intValue.Value;
                    if (mode != X509CertificateValidationMode.ChainTrust)
                    {
                        Resolution resolution = base.GetResolution(mode.ToString(), 
                            X509CertificateValidationMode.ChainTrust.ToString());
                        Problem problem = new Problem(resolution, programContext);
                        base.Problems.Add(problem);
                    }
                }
            }

            base.VisitCall(destination, receiver, callee, arguments, isVirtualCall, programContext, stateBeforeInstruction, stateAfterInstruction);
        }

 public LiteralElement()
   : base((NodeType)SpecSharpNodeType.None){
   this.AttributeNames = new IdentifierList();
   this.AttributeValues = new ExpressionList();
   this.Contents = new ExpressionList();
   this.ContentsType = new Int32List();
 }

 InterProcMapping(PTGraph caller, PTGraph callee, Variable thisRef, ExpressionList arguments)
 {
   this.calleePTG = callee;
   this.callerPTG = caller;
   this.callerThisRef = thisRef;
   this.arguments = arguments;
 }

 public void AddTest()
 {
     var list = new ExpressionList<ConstantTypes.Integer>();
     var one = new ConstantTypes.Integer(1);
     list.Add(one);
     Assert.IsTrue(list.Contains(one));
 }

 private static ExpressionList Clone(ExpressionList expression)
 {
     var parameters = new Expression[expression.Count];
     for (int i = 0; i < expression.Count; ++i)
         parameters[i] = Clone(expression[i]);
     return new ExpressionList(parameters);
 }

 public GroupByClause(ExpressionList exprList)
 {
     foreach (Expression e in exprList) {
         e.Parent = this;
         _exprs.Add(e);
     }
     this.ExpressionType = ExpressionType.QL_SELECT_GROUP_BY;
 }

 public SearchedCase(params KeyValuePair<Predicate, Expression>[] cases)
 {
     SearchCases = new ExpressionList<SearchedCaseExpression>();
     foreach (var kvp in cases)
     {
         SearchCases.Add(new SearchedCaseExpression(kvp.Key, kvp.Value));
     }
 }

 public WhereClause(ExpressionList exprList)
 {
     foreach (Expression e in exprList) {
         e.Parent = this;
         _exprs.Add(e);
     }
     this.ExpressionType = ExpressionType.QL_SELECT_WHERE_CLAUSE;
 }

 public void ClearTest()
 {
     var list = new ExpressionList<ConstantTypes.Integer>();
     var one = new ConstantTypes.Integer(1);
     list.Add(one);
     Assert.IsTrue(list.Count == 1);
     list.Clear();
     Assert.IsTrue(list.Count == 0);
 }

 public override Expression VisitRefTypeExpression(RefTypeExpression reftypexp) {
   if (reftypexp == null) return null;
   Expression result = base.VisitRefTypeExpression (reftypexp);
   if (result != reftypexp) return result;
   UnaryExpression refanytype = new UnaryExpression(reftypexp.Operand, NodeType.Refanytype, SystemTypes.RuntimeTypeHandle, reftypexp.SourceContext);
   ExpressionList arguments = new ExpressionList(1);
   arguments.Add(refanytype);
   MemberBinding mb = new MemberBinding(null, Runtime.GetTypeFromHandle);
   return new MethodCall(mb, arguments, NodeType.Call, SystemTypes.Type);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ParenthesizedExpression"/> class.
 /// </summary>
 /// <param name="content">The content.</param>
 public ParenthesizedExpression(params Expression[] content)
 {
     if (content != null)
     {
         if (content.Length == 1)
             Content = content[0];
         else
             Content = new ExpressionList(content);
     }
 }

    public override ExpressionList VisitExpressionList(ExpressionList expressions)
    {
      if (expressions == null) return null;

      for(int i = expressions.Count-1; i >= 0; i--) 
      {
        Expression elem = this.VisitExpression(expressions[i]);
        System.Diagnostics.Debug.Assert(elem != null, "VisitExpression must return non null if passed non null");
        expressions[i] = elem;
      }
      return expressions;
    }

        public AbbreviationDuplicator(Method sourceMethod, Method targetMethod, ContractNodes contractNodes,
            Method abbreviation, Expression targetObject, ExpressionList actuals)
            : base(targetMethod.DeclaringType.DeclaringModule, sourceMethod, targetMethod, contractNodes, false)
        {
            this.targetObject = targetObject;
            this.abbreviation = abbreviation;
            this.actuals = actuals;

            this.localsInActuals = new TrivialHashtable();

            PopulateLocalsInActuals();
        }

 public void CopyToTest()
 {
     ExpressionList<ConstantTypes.Integer> list = new ExpressionList<ConstantTypes.Integer>();
     var zero = new ConstantTypes.Integer(0);
     var one = new ConstantTypes.Integer(1);
     list.Add(zero);
     list.Add(one);
     ConstantTypes.Integer[] array = new ConstantTypes.Integer[2];
     list.CopyTo(array, 0);
     Assert.IsTrue(array.Length == 2);
     Assert.IsTrue(array[0] == zero);
     Assert.IsTrue(array[1] == one);
 }

		ExpressionList Parse (int start, int end)
		{
			if (string.IsNullOrWhiteSpace (source))
				return new ExpressionList ();

			var ret = new ExpressionList ();
			while (start < end) {
				int bak = start;
				ret.Add (ParseSingle (ref start, end));
				if (bak == start)
					throw new Exception ("Parser failed to progress token position: " + source);
			}
			return ret;
		}

        public void ShouldGetOneProblemWithClientCertificateValidationModePeerOrChainTrustRuleViolation()
        {
            CertificateValidationMode rule = new CertificateValidationMode();
            Method callee = Method.GetMethod(typeof(X509ClientCertificateAuthentication).GetMethod("set_CertificateValidationMode"));
            ExpressionList arguments = new ExpressionList(new Variable(NodeType.VariableDeclaration));
            rule.VisitCall(
                null, null,
                callee,
                arguments,
                false, new MockProgramContext(),
                new MockStateBeforeInstruction((int)X509CertificateValidationMode.PeerOrChainTrust), null);

            Assert.IsNotNull(rule.Problems);
            Assert.AreEqual(1, rule.Problems.Count);
        }

 public Alternatives()
 {
     this.Expressions = new ExpressionList();
     //this.Image = ImageType.Alternative;
     this.Literal = "";
 }

        private static void AddInterfaceImplementationWrapper(Class Class, Method intfMethod, Method baseMethod)
        {
            var d = new Duplicator(Class.DeclaringModule, Class);
            
            d.SkipBodies = true;

            var copy = d.VisitMethod(baseMethod);
            
            copy.Flags = MethodFlags.Private | MethodFlags.HideBySig | MethodFlags.Virtual | MethodFlags.NewSlot |
                         MethodFlags.Final;
            
            copy.ImplementedInterfaceMethods = new MethodList(intfMethod);
            copy.Name = Identifier.For("InheritedInterfaceImplementationContractWrapper$" + intfMethod.Name.Name);
            copy.ClearBody();
            copy.ThisParameter.Type = Class;
            
            var bodyBlock = new Block(new StatementList());
            copy.Body = new Block(new StatementList(bodyBlock));

            // add call to baseMethod
            var calledMethod = (baseMethod.TemplateParameters != null && baseMethod.TemplateParameters.Count > 0)
                ? baseMethod.GetTemplateInstance(Class, copy.TemplateParameters)
                : baseMethod;

            var argList = new ExpressionList();
            for (int i = 0; i < copy.Parameters.Count; i++)
            {
                argList.Add(copy.Parameters[i]);
            }

            var callExpression = new MethodCall(new MemberBinding(copy.ThisParameter, calledMethod), argList);
            if (HelperMethods.IsVoidType(intfMethod.ReturnType))
            {
                bodyBlock.Statements.Add(new ExpressionStatement(callExpression));
            }
            else
            {
                bodyBlock.Statements.Add(new Return(callExpression));
            }
            
            Class.Members.Add(copy);
        }

		string Evaluate (string source, ExpressionList exprList)
		{
			if (exprList == null)
				throw new ArgumentNullException ("exprList");
			return string.Concat (exprList.Select (e => e.EvaluateAsString (CreateContext (source))));
		}