internal static void AddCallbackImplementation(CodeTypeDeclaration codeClass, string callbackName, string handlerName, string handlerArgs, bool methodHasOutParameters)
 {
     CodeFlags[] parameterFlags = new CodeFlags[1];
     CodeMemberMethod method = AddMethod(codeClass, callbackName, parameterFlags, new string[] { typeof(object).FullName }, new string[] { "arg" }, typeof(void).FullName, null, (CodeFlags) 0);
     CodeEventReferenceExpression left = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName);
     CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
     CodeStatement[] trueStatements = new CodeStatement[2];
     trueStatements[0] = new CodeVariableDeclarationStatement(typeof(InvokeCompletedEventArgs), "invokeArgs", new CodeCastExpression(typeof(InvokeCompletedEventArgs), new CodeArgumentReferenceExpression("arg")));
     CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression("invokeArgs");
     CodeObjectCreateExpression expression4 = new CodeObjectCreateExpression();
     if (methodHasOutParameters)
     {
         expression4.CreateType = new CodeTypeReference(handlerArgs);
         expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Results"));
     }
     else
     {
         expression4.CreateType = new CodeTypeReference(typeof(AsyncCompletedEventArgs));
     }
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Error"));
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Cancelled"));
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "UserState"));
     trueStatements[1] = new CodeExpressionStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName), new CodeExpression[] { new CodeThisReferenceExpression(), expression4 }));
     method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0]));
 }

		/// <summary>
		/// Creation method.
		/// </summary>
		/// <param name="className">Class name</param>
		/// <param name="isGet">isGet flag</param>
		/// <param name="member">Member</param>
		/// <param name="statement">Statement</param>
		/// <returns></returns>
		/// <remarks>For properties.</remarks>
		public static MethodInfo CreateProperty(string className,
		                                        bool isGet,
												CodeTypeMember member,
		                                        CodeStatement statement)
		{
			return new MethodInfo(member, className, true, isGet, statement);
		}

 internal static CodeMemberMethod AddAsyncMethod(CodeTypeDeclaration codeClass, string methodName, string[] parameterTypeNames, string[] parameterNames, string callbackMember, string callbackName, string userState)
 {
     CodeMemberMethod method = AddMethod(codeClass, methodName, new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
     method.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
     CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), methodName, new CodeExpression[0]);
     for (int i = 0; i < parameterNames.Length; i++)
     {
         expression.Parameters.Add(new CodeArgumentReferenceExpression(parameterNames[i]));
     }
     expression.Parameters.Add(new CodePrimitiveExpression(null));
     method.Statements.Add(expression);
     method = AddMethod(codeClass, methodName, new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
     method.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
     method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userState));
     CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), callbackMember);
     CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
     CodeDelegateCreateExpression right = new CodeDelegateCreateExpression {
         DelegateType = new CodeTypeReference(typeof(SendOrPostCallback)),
         TargetObject = new CodeThisReferenceExpression(),
         MethodName = callbackName
     };
     CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(left, right) };
     method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0]));
     return method;
 }

 private void NotifyChanged(CollectionChangeAction action, CodeStatement option, int index)
 {
     if (_changed != null)
     {
         _changed(action, option, index);
     }
 }

		private static void EmitPragma(bool emitPragmas, CodeStatement statement, string fileName, int line)
		{
			if (emitPragmas)
			{
				statement.LinePragma = new CodeLinePragma(fileName, line);
			}
		}

 protected object DeserializeStatementToInstance(IDesignerSerializationManager manager, CodeStatement statement)
 {
     object obj2 = null;
     CodeVariableDeclarationStatement statement3;
     CodeAssignStatement statement2 = statement as CodeAssignStatement;
     if (statement2 != null)
     {
         CodeFieldReferenceExpression left = statement2.Left as CodeFieldReferenceExpression;
         if (left != null)
         {
             return base.DeserializeExpression(manager, left.FieldName, statement2.Right);
         }
         CodeVariableReferenceExpression expression2 = statement2.Left as CodeVariableReferenceExpression;
         if (expression2 != null)
         {
             return base.DeserializeExpression(manager, expression2.VariableName, statement2.Right);
         }
         base.DeserializeStatement(manager, statement2);
         return obj2;
     }
     if (((statement3 = statement as CodeVariableDeclarationStatement) != null) && (statement3.InitExpression != null))
     {
         return base.DeserializeExpression(manager, statement3.Name, statement3.InitExpression);
     }
     base.DeserializeStatement(manager, statement);
     return obj2;
 }

        public override void GenerateCodeFromStatement(CodeStatement statement, 
                                                       TextWriter writer, 
                                                       CodeGeneratorOptions options)
        {
            var codeExpressionStatement = statement as CodeExpressionStatement;
            if (codeExpressionStatement != null)
            {
                var methodInvokeExpression =
                    codeExpressionStatement.Expression as CodeMethodInvokeExpression;
                if (methodInvokeExpression != null)
                {
                    if (methodInvokeExpression.Method.MethodName == "Write"
                        && methodInvokeExpression.Parameters.Count == 1)
                    {
                        var parameter = methodInvokeExpression.Parameters[0] as CodeSnippetExpression;
                        if ((parameter != null) && (!string.IsNullOrEmpty(parameter.Value)))
                        {
                            // Appears to be a candidate for rewriting
                            string originalValue = parameter.Value;
                            var processor =
                                SnippetModifiers.OfType<ICodeSnippetTextModifier>()
                                    .FirstOrDefault(m => m.CanProcessString(originalValue));

                            if (processor != null)
                                originalValue = processor.ProcessString(originalValue);
                            parameter.Value =
                                "global::" + GetType().FullName + ".PreProcessObject(this, "
                                + originalValue + ")";
                        }
                    }
                }
            }

            base.GenerateCodeFromStatement(statement, writer, options);
        }

	public void AddRange(CodeStatement[] value)
			{
				foreach(CodeStatement e in value)
				{
					List.Add(e);
				}
			}

 public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses)
 {
     this.tryStatments = new CodeStatementCollection();
     this.finallyStatments = new CodeStatementCollection();
     this.catchClauses = new CodeCatchClauseCollection();
     this.TryStatements.AddRange(tryStatements);
     this.CatchClauses.AddRange(catchClauses);
 }

		public CodeTryCatchFinallyStatement (CodeStatement [] tryStatements,
						     CodeCatchClause [] catchClauses,
						     CodeStatement [] finallyStatements)
		{
			TryStatements.AddRange( tryStatements );
			CatchClauses.AddRange( catchClauses );
			FinallyStatements.AddRange( finallyStatements );
		}

		public void Constructor0_Deny_Unrestricted ()
		{
			CodeStatement cs = new CodeStatement ();
			Assert.IsNull (cs.LinePragma, "LinePragma");
			cs.LinePragma = new CodeLinePragma (String.Empty, Int16.MinValue);
			Assert.AreEqual (0, cs.StartDirectives.Count, "StartDirectives");
			Assert.AreEqual (0, cs.EndDirectives.Count, "EndDirectives");
		}

 internal static CodeStatement Clone(CodeStatement statement)
 {
     if (statement == null)
     {
         return null;
     }
     return GetStatement(statement).Clone();
 }

 /// <devdoc>
 /// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.CodeStatementCollection'/>.</para>
 /// </devdoc>
 public void AddRange(CodeStatement[] value) {
     if (value == null) {
         throw new ArgumentNullException("value");
     }
     for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
         this.Add(value[i]);
     }
 }

		public void Constructor1_NullItem ()
		{
			CodeStatement[] statements = new CodeStatement[] { 
				new CodeStatement (), null };

			CodeStatementCollection coll = new CodeStatementCollection (
				statements);
		}

	public CodeConditionStatement(CodeExpression condition,
								  CodeStatement[] trueStatements,
								  CodeStatement[] falseStatements)
			{
				this.condition = condition;
				TrueStatements.AddRange(trueStatements);
				FalseStatements.AddRange(falseStatements);
			}

 public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements)
 {
     this.statements = new CodeStatementCollection();
     this.InitStatement = initStatement;
     this.TestExpression = testExpression;
     this.IncrementStatement = incrementStatement;
     this.Statements.AddRange(statements);
 }

		void AddStmt(CodeStatement stmt)
		{
			if (codeStack.Count == 0)
				return;
			CodeStatementCollection stmtCollection = codeStack.Peek();
			if (stmtCollection != null) {
				stmtCollection.Add(stmt);
			}
		}

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeStatement[] try_statements = new CodeStatement[1] { new CodeStatement () };
			CodeCatchClause[] catch_clauses = new CodeCatchClause[1] { new CodeCatchClause () };
			CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement (try_statements, catch_clauses);
			Assert.AreEqual (1, ctcfs.CatchClauses.Count, "CatchClauses");
			Assert.AreEqual (0, ctcfs.FinallyStatements.Count, "FinallyStatements");
			Assert.AreEqual (1, ctcfs.TryStatements.Count, "TryStatements");
		}

 private static CodeCatchClause Catch(System.Type type, string name, CodeStatement catchStmnt)
 {
     CodeCatchClause clause = new CodeCatchClause {
         CatchExceptionType = Type(type),
         LocalName = name
     };
     clause.Statements.Add(catchStmnt);
     return clause;
 }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeExpression condition = new CodeExpression ();
			CodeStatement[] cs = new CodeStatement[1] { new CodeStatement () };
			CodeConditionStatement css = new CodeConditionStatement (condition, cs);
			Assert.AreSame (condition, css.Condition, "Condition");
			css.Condition = new CodeExpression ();
			Assert.AreEqual (0, css.FalseStatements.Count, "FalseStatements");
			Assert.AreEqual (1, css.TrueStatements.Count, "TrueStatements");
		}