public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
		{
            var token = CreateBlock(string.Format("while ({0})", doWhileStatement.Condition.GetText()), SDNodeRole.DoWhileLoop);
            _tokenList.Add(token);

            VisitChildren(token.Statements, doWhileStatement.EmbeddedStatement);
		}

		static void ConvertToWhileLoop(Script script, DoWhileStatement originalStatement)
		{
			script.Replace(originalStatement, new WhileStatement {
				Condition = originalStatement.Condition.Clone(),
				EmbeddedStatement = originalStatement.EmbeddedStatement.Clone()
			});
		}

		void ApplyAction(Script script, WhileStatement statement) {
			var doWhile = new DoWhileStatement {
				Condition = statement.Condition.Clone(),
				EmbeddedStatement = statement.EmbeddedStatement.Clone()
			};

			script.Replace(statement, doWhile);
		}

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     bool oldIsInsideLoop = _isInsideLoop;
     try {
         _isInsideLoop = true;
         base.VisitDoWhileStatement(doWhileStatement);
     }
     finally {
         _isInsideLoop = oldIsInsideLoop;
     }
 }

 public override object VisitDoWhileStatement(DoWhileStatement doWhileStatement, object data)
 {
     if (doWhileStatement.EmbeddedStatement is BlockStatement)
     {
         foreach (Statement innerstatement in (BlockStatement)doWhileStatement.EmbeddedStatement)
         {
             if (innerstatement is WhileStatement || innerstatement is DoWhileStatement)
                 UnlockWith(doWhileStatement);
         }
     }
     return base.VisitDoWhileStatement(doWhileStatement, data);
 }

        static BlockStatement ReplaceJump(JumpStatement jump, BlockStatement block)
        {
            if (jump.StartOffset < block.StartOffset)
                throw new ArgumentOutOfRangeException("jump", "jump should be inside the given block");
            if (jump.JumpOffset > block.EndOffset)
                throw new ArgumentOutOfRangeException("jump", "jump should be inside the given block");

            var newBlock = new BlockStatement();
            var doWhileStatement = new DoWhileStatement(jump.Condition, new BlockStatement()){ StartOffset = jump.StartOffset, EndOffset = jump.JumpOffset };
            var inside = false;
            foreach (var statement in block)
            {
                if (statement.StartOffset == jump.JumpOffset)
                {                    
                    ((BlockStatement)doWhileStatement.Statement).AddStatement(statement);
                    inside = true;
                }
                else if (statement.StartOffset == jump.StartOffset)
                {
                    if (doWhileStatement == null)
                        throw new InvalidOperationException("DoWhileStatement can't be null");
                    newBlock.AddStatement(doWhileStatement);
                    doWhileStatement = null;
                    inside = false;
                }
                else if (inside)
                {
                    ((BlockStatement)doWhileStatement.Statement).AddStatement(statement);
                }
                else
                {
                    var lastStatement = newBlock.LastOrDefault();
                    if (lastStatement != null && lastStatement.EndOffset > statement.StartOffset)
                    {
                        throw new NotSupportedException("invalid Statement");
                    }
                    newBlock.AddStatement(statement);
                }
            }
            return newBlock;
        }

 public void Visit(DoWhileStatement expression)
 {
     outStream.WriteLine("do {");
     expression.Statement.Accept(this);
     outStream.WriteLine();
     outStream.Write("} while (");
     expression.Condition.Accept(this);
     outStream.Write(")");
 }

 private Statement ParseDoWhile(TokenSet followers)
   //^ requires this.currentToken == Token.Do;
   //^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
 {
   SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
   this.GetNextToken();
   Statement body = this.ParseStatement(followers|Token.While);
   if (body is EmptyStatement)
     this.HandleError(body.SourceLocation, Error.PossibleMistakenNullStatement);
   this.Skip(Token.While);
   Expression condition = this.ParseParenthesizedExpression(false, followers|Token.Semicolon);
   DoWhileStatement result = new DoWhileStatement(body, condition, slb);
   this.SkipSemiColon(followers);
   return result;
 }

		public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
		{
			PlaceOnNewLine(policy.PlaceWhileOnNewLine, doWhileStatement.WhileToken);
			FixEmbeddedStatment(policy.StatementBraceStyle, policy.WhileBraceForcement, doWhileStatement.EmbeddedStatement);
		}

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     if (findReturn)
     {
         base.VisitDoWhileStatement(doWhileStatement);
     }
 }

 public void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     VisitExpression(doWhileStatement.Condition);
     VisitStatement(doWhileStatement.Body);
 }

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     new DoWhileBlock(this, doWhileStatement).Emit();
 }

			public override void VisitDoWhileStatement (DoWhileStatement doWhileStatement)
			{
				base.VisitDoWhileStatement (doWhileStatement);

				CheckCondition (doWhileStatement.Condition);
			}

		public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement) {
			var body = CreateInnerCompiler().Compile(doWhileStatement.EmbeddedStatement);
			var compiledCondition = CompileExpression(doWhileStatement.Condition, CompileExpressionFlags.ReturnValueIsImportant);
			if (compiledCondition.AdditionalStatements.Count > 0)
				body = JsStatement.Block(body.Statements.Concat(compiledCondition.AdditionalStatements));
			_result.Add(JsStatement.DoWhile(compiledCondition.Expression, body));
		}

		public virtual void VisitDoWhileStatement (DoWhileStatement doWhileStatement)
		{
			VisitChildren (doWhileStatement);
		}

			public override object Visit (Do doStatement)
			{
				var result = new DoWhileStatement ();
				var location = LocationsBag.GetLocations (doStatement);
				result.AddChild (new CSharpTokenNode (Convert (doStatement.loc), "do".Length), DoWhileStatement.DoKeywordRole);
				result.AddChild ((MonoDevelop.CSharp.Ast.Statement)doStatement.EmbeddedStatement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
				if (location != null)
					result.AddChild (new CSharpTokenNode (Convert (location[0]), "while".Length), DoWhileStatement.WhileKeywordRole);
				if (location != null)
					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DoWhileStatement.Roles.LPar);
				result.AddChild ((MonoDevelop.CSharp.Ast.Expression)doStatement.expr.Accept (this), DoWhileStatement.Roles.Condition);
				if (location != null) {
					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DoWhileStatement.Roles.RPar);
					result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DoWhileStatement.Roles.Semicolon);
				}
				
				return result;
			}

        /// <summary>
        ///     Generates the code for a DoWhileStatement node.
        /// </summary>
        /// <param name="dws">The DoWhileStatement node.</param>
        /// <returns>String containing C# code for DoWhileStatement dws.</returns>
        private string GenerateDoWhileStatement(DoWhileStatement dws)
        {
            StringBuilder retVal = new StringBuilder();

            retVal.Append(GenerateIndentedLine("do", dws));
            if (IsParentEnumerable)
            {
                retVal.Append(GenerateLine("{")); // SLAM!
                retVal.Append(GenerateLine("if (CheckSlice()) yield return null;"));
            }

            // CompoundStatement handles indentation itself but we need to do it
            // otherwise.
            bool indentHere = dws.kids.Top is Statement;
            if (indentHere) m_braceCount++;
            retVal.Append(GenerateNode((SYMBOL) dws.kids.Pop()));
            if (indentHere) m_braceCount--;

            if (IsParentEnumerable)
                retVal.Append(GenerateLine("}"));

            bool marc = FuncCallsMarc();

            //Forces all functions to use MoveNext() instead of .Current, as it never changes otherwise, and the loop runs infinitely

            m_isInEnumeratedDeclaration = true;

            retVal.Append(GenerateIndented("while (", dws));
            retVal.Append(GenerateNode((SYMBOL) dws.kids.Pop()));
            retVal.Append(GenerateLine(");"));

            m_isInEnumeratedDeclaration = false; //End above

            return DumpFunc(marc) + retVal.ToString() + DumpAfterFunc(marc);
        }

 public virtual void Visit(DoWhileStatement node)
 {
     DefaultVisit(node);
 }

        public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
        {
            this.loopLevel++;

            doWhileStatement.EmbeddedStatement = GetLoopBlock (doWhileStatement.EmbeddedStatement);

            base.VisitDoWhileStatement (doWhileStatement);

            this.loopLevel--;
        }

 public DoWhileBlock(IEmitter emitter, DoWhileStatement doWhileStatement)
     : base(emitter, doWhileStatement)
 {
     this.Emitter = emitter;
     this.DoWhileStatement = doWhileStatement;
 }