internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions)
 {
     Stack<MemberInfo> methodStack = new Stack<MemberInfo>();
     methodStack.Push(member);
     this.AnalyzeInvokeAttribute(analysis, member.DeclaringType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);
     methodStack.Pop();
 }

 private void AnalyzeInvokeAttribute(RuleAnalysis analysis, Type contextType, Stack<MemberInfo> methodStack, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions)
 {
     foreach (MemberInfo info in contextType.GetMember(this.methodInvoked, MemberTypes.Property | MemberTypes.Method, BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
     {
         if (!methodStack.Contains(info))
         {
             methodStack.Push(info);
             object[] customAttributes = info.GetCustomAttributes(typeof(RuleAttribute), true);
             if ((customAttributes != null) && (customAttributes.Length != 0))
             {
                 foreach (RuleAttribute attribute in (RuleAttribute[]) customAttributes)
                 {
                     RuleReadWriteAttribute attribute2 = attribute as RuleReadWriteAttribute;
                     if (attribute2 != null)
                     {
                         attribute2.Analyze(analysis, info, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);
                     }
                     else
                     {
                         ((RuleInvokeAttribute) attribute).AnalyzeInvokeAttribute(analysis, contextType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);
                     }
                 }
             }
             methodStack.Pop();
         }
     }
 }

 internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions)
 {
     if (!analysis.ForWrites)
     {
         base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);
     }
 }

		public void Constructor1_NullItem ()
		{
			CodeExpression[] expressions = new CodeExpression[] { 
				new CodeExpression (), null };

			CodeExpressionCollection coll = new CodeExpressionCollection (
				expressions);
		}

 public static CodeExpressionCollection Clone(this CodeExpressionCollection collection)
 {
     if (collection == null) return null;
     CodeExpressionCollection c = new CodeExpressionCollection();
     foreach (CodeExpression expression in collection)
         c.Add(expression.Clone());
     return c;
 }

		public void Constructor0 ()
		{
			CodeExpressionCollection coll = new CodeExpressionCollection ();
			Assert.IsFalse (((IList) coll).IsFixedSize, "#1");
			Assert.IsFalse (((IList) coll).IsReadOnly, "#2");
			Assert.AreEqual (0, coll.Count, "#3");
			Assert.IsFalse (((ICollection) coll).IsSynchronized, "#4");
		}

 internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List<CodeExpression> attributedExprs)
 {
     object[] attrs = member.GetCustomAttributes(typeof(RuleAttribute), true);
     if (attrs != null && attrs.Length > 0)
     {
         RuleAttribute[] ruleAttrs = (RuleAttribute[])attrs;
         for (int i = 0; i < ruleAttrs.Length; ++i)
             ruleAttrs[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs);
     }
 }

 public void AddRange(CodeExpressionCollection value)
 {
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     int count = value.Count;
     for (int i = 0; i < count; i++)
     {
         this.Add(value[i]);
     }
 }

 internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List<CodeExpression> attributedExprs)
 {
     object[] customAttributes = member.GetCustomAttributes(typeof(RuleAttribute), true);
     if ((customAttributes != null) && (customAttributes.Length > 0))
     {
         RuleAttribute[] attributeArray = (RuleAttribute[]) customAttributes;
         for (int i = 0; i < attributeArray.Length; i++)
         {
             attributeArray[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs);
         }
     }
 }

        public void AddRange(CodeExpressionCollection value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }

            int currentCount = value.Count;
            for (int i = 0; i < currentCount; i++)
            {
                Add(value[i]);
            }
        }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeExpressionCollection coll = new CodeExpressionCollection (array);
			coll.CopyTo (array, 0);
			Assert.AreEqual (1, coll.Add (ce), "Add");
			Assert.AreSame (ce, coll[0], "this[int]");
			coll.AddRange (array);
			coll.AddRange (coll);
			Assert.IsTrue (coll.Contains (ce), "Contains");
			Assert.AreEqual (0, coll.IndexOf (ce), "IndexOf");
			coll.Insert (0, ce);
			coll.Remove (ce);
		}

		public void Constructor1 ()
		{
			CodeExpression exp1 = new CodeExpression ();
			CodeExpression exp2 = new CodeExpression ();

			CodeExpression[] expressions = new CodeExpression[] { exp1, exp2 };
			CodeExpressionCollection coll = new CodeExpressionCollection (
				expressions);

			Assert.AreEqual (2, coll.Count, "#1");
			Assert.AreEqual (0, coll.IndexOf (exp1), "#2");
			Assert.AreEqual (1, coll.IndexOf (exp2), "#3");
		}

 private static void AddTypes(string prepend, bool nested, CodeTypeDeclarationCollection types, CodeExpressionCollection into)
 {
     foreach (CodeTypeDeclaration t in types) {
         into.Add(new CodeTypeOfExpression(
             ((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name));
         CodeTypeDeclarationCollection ctd = new CodeTypeDeclarationCollection();
         foreach (CodeTypeMember m in t.Members) {
             if (m is CodeTypeDeclaration) ctd.Add((CodeTypeDeclaration)m);
         }
         AddTypes(
             ((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name,
             true, ctd, into);
     }
 }

 internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier)
 {
     CodeBinaryOperatorExpression expression2 = (CodeBinaryOperatorExpression) expression;
     RuleBinaryExpressionInfo info = analysis.Validation.ExpressionInfo(expression2) as RuleBinaryExpressionInfo;
     if (info != null)
     {
         MethodInfo methodInfo = info.MethodInfo;
         if (methodInfo != null)
         {
             List<CodeExpression> attributedExprs = new List<CodeExpression>();
             CodeExpressionCollection argExprs = new CodeExpressionCollection();
             argExprs.Add(expression2.Left);
             argExprs.Add(expression2.Right);
             CodeExpression targetExpr = new CodeTypeReferenceExpression(methodInfo.DeclaringType);
             analysis.AnalyzeRuleAttributes(methodInfo, targetExpr, qualifier, argExprs, methodInfo.GetParameters(), attributedExprs);
         }
     }
     RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Left, true, false, null);
     RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Right, true, false, null);
 }

 public CodeObjectCreateExpression(Type createType, params CodeExpression[] parameters)
 {
     this.parameters = new CodeExpressionCollection();
     this.CreateType = new CodeTypeReference(createType);
     this.Parameters.AddRange(parameters);
 }

		protected virtual void OutputExpressionList (CodeExpressionCollection expressions,
							     bool newLineBetweenItems)
		{
			++Indent;
			IEnumerator enumerator = expressions.GetEnumerator();
			if (enumerator.MoveNext()) {
				CodeExpression expression = (CodeExpression)enumerator.Current;

				GenerateExpression (expression);
				
				while (enumerator.MoveNext()) {
					expression = (CodeExpression)enumerator.Current;
					
					output.Write (',');
					if (newLineBetweenItems)
						output.WriteLine ();
					else
						output.Write (' ');
					
					GenerateExpression (expression);
				}
			}
			--Indent;
		}

 protected virtual void OutputParameters(CodeExpressionCollection parameters)
 {
     int count = parameters.Count;
     Output.Write("(");
     if (count > 0)
     {
         GenerateExpression(parameters[0]);
         for (int i = 1; i < count; ++i)
         {
             Output.Write(", ");
             GenerateExpression(parameters[i]);
         }
     }
     Output.Write(")");
 }

 /// <devdoc>
 ///    <para>
 ///       Generates code for the specified expression list.
 ///    </para>
 /// </devdoc>
 private void OutputExpressionList(CodeExpressionCollection expressions, bool newlineBetweenItems) {
     bool first = true;
     IEnumerator en = expressions.GetEnumerator();
     Indent++;
     while (en.MoveNext()) {
         if (first) {
             first = false;
         }
         else {
             if (newlineBetweenItems)
                 ContinueOnNewLine(",");
             else
                 Output.Write(", ");
         }
         ((ICodeGenerator)this).GenerateCodeFromExpression((CodeExpression)en.Current, output.InnerWriter, options);
     }
     Indent--;
 }

 private void ValidateExpressionList(CodeExpressionCollection expressions) {
     IEnumerator en = expressions.GetEnumerator();
     while (en.MoveNext()) {
         ValidateExpression((CodeExpression)en.Current);
     }
 }

		/// <summary>
		/// Appends initializers for an array.
		/// </summary>
		void AppendInitializers(CodeExpressionCollection initalizers)
		{
			codeBuilder.Append("(");
			codeBuilder.AppendLine();
			codeBuilder.IncreaseIndent();
			codeBuilder.AppendIndented("[");

			bool firstInitializer = true;
			foreach (CodeExpression expression in initalizers) {
				if (firstInitializer) {
					firstInitializer = false;					
				} else {
					codeBuilder.Append(",");
					codeBuilder.AppendLine();
					codeBuilder.AppendIndented(String.Empty);
				}
				AppendExpression(expression);
			}
			
			codeBuilder.Append("])");
			codeBuilder.DecreaseIndent();
		}