public override void VisitDoStatement(DoStatementSyntax node)
        {
            var token = CreateBlock($"while ({node.Condition})", SDNodeRole.DoWhileLoop);
            _tokenList.Add(token);

            VisitChildren(token.Statements, node.Statement);
        }

        private BoundStatement BindDoStatement(DoStatementSyntax syntax, Symbol parent)
        {
            BindAttributes(syntax.Attributes);

            return new BoundDoStatement(
                Bind(syntax.Condition, BindExpression),
                Bind(syntax.Statement, x => BindStatement(x, parent)));
        }

        public static DoStatementSyntax AddBraces(DoStatementSyntax doStatement)
        {
            Debug.Assert(doStatement != null && NeedsBraces(doStatement));

            return doStatement
                .WithStatement(SyntaxFactory.Block(doStatement.Statement))
                .WithAdditionalAnnotations(Formatter.Annotation);
        }

 public BoundDoStatement BindDo(DoStatementSyntax node)
 {
     var condition = BindBooleanExpression(node.Condition);
     var loopContext = this.containingMethod.BlockMap.GetValueOrDefault(node);
     Debug.Assert(loopContext != null);
     var analyzer = new SemanticAnalyzer(this.containingMethod, loopContext, this.diagnostics);
     var body = analyzer.BindStatement(node.Statement);
     return new BoundDoStatement(node, condition, body, loopContext.GetBreakLabel(), loopContext.GetContinueLabel());
 }

        protected override SyntaxNode VisitDoStatement(DoStatementSyntax node)
        {
            if (!node.DescendentNodes().OfType<BlockSyntax>().Any())
            {
                node = node.Update (node.DoKeyword, Syntax.Block (statements: node.Statement), node.WhileKeyword,
                                    node.OpenParenToken, node.Condition, node.CloseParenToken, node.SemicolonToken);
            }

            return base.VisitDoStatement (node);
        }

            public override SyntaxNode VisitDoStatement(DoStatementSyntax node)
            {
                node = (DoStatementSyntax)base.VisitDoStatement(node);

                if (!node.Statement.IsKind(SyntaxKind.Block))
                {
                    this.addedAnnotations = true;
                    node = node.WithStatement(SyntaxFactory.Block(node.Statement));
                }

                return node;
            }

        public static void Go(OutputWriter writer, DoStatementSyntax statement)
        {
            var info = new LoopInfo(statement);

            writer.WriteLine("do");
            writer.OpenBrace();
            Core.WriteStatementAsBlock(writer, statement.Statement, false);
            writer.CloseBrace();

            writer.WriteIndent();
            writer.Write("while (");
            Core.Write(writer, statement.Condition);
            writer.Write(");\r\n");
        }

        public override SyntaxNode VisitDoStatement(DoStatementSyntax node)
        {
            node = (DoStatementSyntax)base.VisitDoStatement(node);

            if (!node.CloseParenToken.IsMissing && node.Statement.Kind != SyntaxKind.Block)
            {
                return CodeAnnotations.Formatting.AddAnnotationTo(
                    Syntax.DoStatement(
                        node.DoKeyword,
                        WrapStatementWithBlock(node.Statement),
                        node.WhileKeyword,
                        node.OpenParenToken,
                        node.Condition,
                        node.CloseParenToken,
                        node.SemicolonToken));
            }
            else
            {
                return node;
            }
        }

 public virtual void VisitDoStatement(DoStatementSyntax node)
 {
     DefaultVisit(node);
 }

 public override void VisitDoStatement(DoStatementSyntax node) => CheckNesting(node.DoKeyword, () => base.VisitDoStatement(node));

 private static bool AreEquivalentActiveStatements(DoStatementSyntax oldNode, DoStatementSyntax newNode)
 {
     // only check the condition, edits in the body are allowed:
     return AreEquivalentIgnoringLambdaBodies(oldNode.Condition, newNode.Condition);
 }

        public override void VisitDoStatement(DoStatementSyntax node)
        {
            if (!YieldChecker.HasSpecialStatement(node))
            {
                currentState.Add(StateMachineThisFixer.Fix(node));
            }
            else
            {
                MaybeCreateNewState();

                var nextState = GetNextState(node);

                var conditionState = new State(this) { BreakState = nextState };

                var iterationState = currentState;

                conditionState.Add(Cs.If(StateMachineThisFixer.Fix(node.Condition), ChangeState(iterationState), ChangeState(nextState)));
                conditionState.Add(GotoTop());
                SetClosed(conditionState);
                iterationState.NextState = conditionState;

                node.Statement.Accept(this);
                if (currentState != nextState)
                {
                    Close(currentState);
                }

                currentState = nextState;
            }
        }

 public BoundDoStatement BindDo(DoStatementSyntax node, DiagnosticBag diagnostics)
 {
     var loopBinder = this.GetBinder(node);
     Debug.Assert(loopBinder != null);
     return loopBinder.BindDoParts(diagnostics, loopBinder);
 }

            private IEnumerable<ITypeSymbol> InferTypeInDoStatement(DoStatementSyntax doStatement, SyntaxToken? previousToken = null)
            {
                // If we have a position, we need to be after "do { } while("
                if (previousToken.HasValue && previousToken.Value != doStatement.OpenParenToken)
                {
                    return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
                }

                return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Boolean));
            }

        /// <summary>
        /// Handles the given do statement.
        /// </summary>
        /// <param name="stmt">Statement</param>
        /// <param name="successor">Successor</param>
        private void HandleDoStatement(DoStatementSyntax stmt, ControlFlowGraphNode successor)
        {
            this.SyntaxNodes.Add(stmt.Condition);
            this.IsLoopHeadNode = true;

            if (successor != null)
            {
                this.ISuccessors.Add(successor);
                successor.IPredecessors.Add(this);
                this.LoopExitNode = successor;
            }

            var doNode = new ControlFlowGraphNode(this.Summary);
            this.ISuccessors.Add(doNode);
            doNode.IPredecessors.Add(this);

            if (stmt.Statement is BlockSyntax)
            {
                doNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this);
            }
            else
            {
                doNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, this);
            }
        }

 public override void VisitDoStatement(DoStatementSyntax node)
 {
     Visit(node.Condition);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 /// <remarks>
 /// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
 /// tree by visiting the node.
 /// </remarks>
 public override void VisitDoStatement(DoStatementSyntax node)
 {
     this.VisitStatement(node);
 }

        protected override SyntaxNode VisitDoStatement(DoStatementSyntax node)
        {
            node = node.Update (node.DoKeyword, GetLoopBlock (node.Statement), node.WhileKeyword,
                                node.OpenParenToken, node.Condition, node.CloseParenToken, node.SemicolonToken);

            this.loopLevel++;
            var statement = base.VisitDoStatement ((DoStatementSyntax) node.WithAdditionalAnnotations (this.isLoop));
            this.loopLevel--;
            return statement;
        }

        public override void VisitDoStatement(DoStatementSyntax node)
        {
            Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda);
            var patternBinder = new PatternVariableBinder(node, _enclosing);
            var whileBinder = new WhileBinder(patternBinder, node);
            AddToMap(node, whileBinder);

            Visit(node.Condition, whileBinder);
            VisitPossibleEmbeddedStatement(node.Statement, whileBinder);
        }

        public override SyntaxNode VisitDoStatement(DoStatementSyntax node)
        {
            this.loopLevel++;

            var statement = base.VisitDoStatement (node
                                .WithStatement (GetLoopBlock (node.Statement)))
                            .WithAdditionalAnnotations (this.isLoop);

            this.loopLevel--;

            return statement;
        }