Format while, do-while, break, and continue statements. (#1285)

Format while, do-while, break, and continue statements.

Reuses the existing formatting logic for if statements to format while
statements. (A goal of the rewrite is to reuse as much formatting code
as possible across different syntactic elements so that the architecture
of the formatter itself ensures consistent formatting.)

Do-while loops are kind of weird, so they get their own handling.

Author: munificent

lib/src/front_end/ast_node_visitor.dart

@@ -6,6 +6,8 @@ import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/source/line_info.dart';
 
 import '../dart_formatter.dart';
+import '../piece/do_while.dart';
+import '../piece/if.dart';
 import '../piece/piece.dart';
 import '../piece/variable.dart';
 import '../source_code.dart';
@@ -158,7 +160,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitBreakStatement(BreakStatement node) {
-    throw UnimplementedError();
+    createBreak(node.breakKeyword, node.label, node.semicolon);
   }
 
   @override
@@ -250,7 +252,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitContinueStatement(ContinueStatement node) {
-    throw UnimplementedError();
+    createBreak(node.continueKeyword, node.label, node.semicolon);
   }
 
   @override
@@ -270,7 +272,21 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitDoStatement(DoStatement node) {
-    throw UnimplementedError();
+    token(node.doKeyword);
+    writer.space();
+    visit(node.body);
+    writer.space();
+    token(node.whileKeyword);
+    var body = writer.pop();
+    writer.split();
+
+    token(node.leftParenthesis);
+    visit(node.condition);
+    token(node.rightParenthesis);
+    token(node.semicolon);
+    var condition = writer.pop();
+
+    writer.push(DoWhilePiece(body, condition));
   }
 
   @override
@@ -947,7 +963,20 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitWhileStatement(WhileStatement node) {
-    throw UnimplementedError();
+    token(node.whileKeyword);
+    writer.space();
+    token(node.leftParenthesis);
+    visit(node.condition);
+    token(node.rightParenthesis);
+    var condition = writer.pop();
+    writer.split();
+
+    visit(node.body);
+    var body = writer.pop();
+
+    var piece = IfPiece();
+    piece.add(condition, body, isBlock: node.body is Block);
+    writer.push(piece);
   }
 
   @override

lib/src/front_end/piece_factory.dart

@@ -85,6 +85,16 @@ mixin PieceFactory implements CommentWriter {
         alwaysSplit: forceSplit || block.statements.isNotEmpty));
   }
 
+  /// Creates a piece for a `break` or `continue` statement.
+  void createBreak(Token keyword, SimpleIdentifier? label, Token semicolon) {
+    token(keyword);
+    if (label != null) {
+      writer.space();
+      visit(label);
+    }
+    token(semicolon);
+  }
+
   /// Creates a [ListPiece] for a collection literal.
   void createCollection(TypedLiteral literal, Token leftBracket,
       List<AstNode> elements, Token rightBracket) {

lib/src/piece/do_while.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+import '../back_end/code_writer.dart';
+import '../constants.dart';
+import 'piece.dart';
+
+/// A piece for a do-while statement.
+class DoWhilePiece extends Piece {
+  final Piece _body;
+  final Piece _condition;
+
+  DoWhilePiece(this._body, this._condition);
+
+  @override
+  List<State> get states => const [];
+
+  @override
+  void format(CodeWriter writer, State state) {
+    writer.setIndent(Indent.none);
+    writer.format(_body);
+    writer.space();
+    writer.format(_condition);
+  }
+
+  @override
+  void forEachChild(void Function(Piece piece) callback) {
+    callback(_body);
+    callback(_condition);
+  }
+
+  @override
+  String toString() => 'DoWhile';
+}

lib/src/piece/if.dart

@@ -6,6 +6,9 @@ import '../constants.dart';
 import 'piece.dart';
 
 /// A piece for an if statement.
+///
+/// We also use this for while statements, which are formatted exactly like an
+/// if statement with no else clause.
 class IfPiece extends Piece {
   final List<_IfSection> _sections = [];
 

test/statement/do_while.stmt

@@ -0,0 +1,26 @@
+40 columns                              |
+>>> Empty block body.
+do {} while (true);
+<<<
+do {} while (true);
+>>> Don't split before long condition.
+do {
+  ;
+} while (aLongConditionExpressionThatWraps);
+<<<
+do {
+  ;
+} while (aLongConditionExpressionThatWraps);
+>>> Split inside condition.
+do {
+  ;
+} while (aLongCondition + expressionThatWraps);
+<<<
+do {
+  ;
+} while (aLongCondition +
+    expressionThatWraps);
+>>> Unbraced body.
+do something(i); while (condition);
+<<<
+do something(i); while (condition);

test/statement/other.stmt

@@ -0,0 +1,33 @@
+40 columns                              |
+>>> Break.
+while (true) {
+  break  ;
+}
+<<<
+while (true) {
+  break;
+}
+>>> Break to label.
+while (true) {
+  break  someLabel  ;
+}
+<<<
+while (true) {
+  break someLabel;
+}
+>>> Continue.
+while (true) {
+  continue  ;
+}
+<<<
+while (true) {
+  continue;
+}
+>>> Continue to label.
+while (true) {
+  continue  someLabel  ;
+}
+<<<
+while (true) {
+  continue someLabel;
+}

test/statement/other_comment.stmt

@@ -0,0 +1,37 @@
+40 columns                              |
+>>> Break with comment after keyword.
+while (true) {
+  break // comment
+  ;
+}
+<<<
+while (true) {
+  break // comment
+  ;
+}
+>>> Break with comment after semicolon.
+while (true) {
+  break; // comment
+}
+<<<
+while (true) {
+  break; // comment
+}
+>>> Continue with comment after keyword.
+while (true) {
+  break // comment
+  ;
+}
+<<<
+while (true) {
+  break // comment
+  ;
+}
+>>> Continue with comment after semicolon.
+while (true) {
+  break; // comment
+}
+<<<
+while (true) {
+  break; // comment
+}

test/statement/while.stmt

@@ -0,0 +1,48 @@
+40 columns                              |
+>>> Empty block body.
+while (true) {}
+<<<
+while (true) {}
+>>> Semicolon body.
+while (true);
+<<<
+while (true) ;
+>>> Don't split before long condition.
+while (aLongConditionExpressionThatWraps) {
+  ;
+}
+<<<
+while (aLongConditionExpressionThatWraps) {
+  ;
+}
+>>> Split inside condition.
+while (aLongCondition + expressionThatWraps) {
+  ;
+}
+<<<
+while (aLongCondition +
+    expressionThatWraps) {
+  ;
+}
+>>> Unbraced body.
+while (condition) something(i);
+<<<
+while (condition) something(i);
+>>> Split unbraced body.
+### This goes against the style guide, but the formatter still has to handle it.
+while (condition) someLong(argument, another);
+<<<
+while (condition)
+  someLong(argument, another);
+>>> Split in condition forces split before body.
+while (veryLongCondition || veryLongExpression) body;
+<<<
+while (veryLongCondition ||
+    veryLongExpression)
+  body;
+>>> Split in body forces split before body.
+while (condition) veryLongExpression + anotherLongExpression;
+<<<
+while (condition)
+  veryLongExpression +
+      anotherLongExpression;