Simplify and unify how delimited bodies are handled. (#1113)

For mostly historical reasons, SourceVisitor used to create a flat list
of Chunks for some brace-delimited bodies like block statements and
switch bodies while using nested BlockChunks for function expression
bodies.

This now uniformly uses nested blocks for all of them. The visible
behavior is mostly unchanged except in a rare corner case with type
bodies containing only inline block comments where the old formatter
would arbitrarily split in one case but not the other. Now its behavior
is more consistent.

Author: munificent

CHANGELOG.md

@@ -1,5 +1,9 @@
 # 2.2.4-dev
 
+* Unify how brace-delimited syntax is formatted. This is mostly an internal
+  refactoring, but slightly changes how a type body containing only an inline
+  block comment is formatted.
+
 * Refactor Chunk to store split before text instead of after. This mostly does
   not affect the visible behavior of the formatter, but a few edge cases are
   handled slightly differently. These are all bug fixes where the previous

lib/src/ast_extensions.dart

@@ -22,6 +22,22 @@ extension AstNodeExtensions on AstNode {
   /// Whether there is a comma token immediately following this.
   bool get hasCommaAfter => commaAfter != null;
 
+  /// Whether this node is a statement or member with a braced body that isn't
+  /// empty.
+  ///
+  /// Used to determine if a blank line should be inserted after the node.
+  bool get hasNonEmptyBody {
+    AstNode? body;
+    var node = this;
+    if (node is MethodDeclaration) {
+      body = node.body;
+    } else if (node is FunctionDeclarationStatement) {
+      body = node.functionDeclaration.functionExpression.body;
+    }
+
+    return body is BlockFunctionBody && body.block.statements.isNotEmpty;
+  }
+
   bool get isControlFlowElement => this is IfElement || this is ForElement;
 
   /// Whether this is immediately contained within an anonymous

lib/src/chunk_builder.dart

@@ -581,12 +581,14 @@ class ChunkBuilder {
   ///
   /// Forces the chunk that owns the block to split if it can tell that the
   /// block contents will always split. It does that by looking for hard splits
-  /// in the block. If [ignoredSplit] is given, that rule will be ignored
-  /// when determining if a block contains a hard split. If [forceSplit] is
-  /// `true`, the block is considered to always split.
+  /// in the block. If [bodyRule] is given, that rule will be ignored when
+  /// determining if a block contains a hard split. If [space] is `true`, the
+  /// split at the end of the block will get a space when unsplit. If
+  /// [forceSplit] is `true`, the block always splits.
   ///
   /// Returns the previous writer for the surrounding block.
-  ChunkBuilder endBlock(Rule? ignoredSplit, {required bool forceSplit}) {
+  ChunkBuilder endBlock(
+      {Rule? bodyRule, bool space = false, bool forceSplit = true}) {
     _divideChunks();
 
     // If the last chunk ends with a comment that wants a newline after it,
@@ -609,31 +611,30 @@ class ChunkBuilder {
         // code), then force the collection to split.
         if (chunk != _chunks.first &&
             chunk.rule.isHardened &&
-            chunk.rule != ignoredSplit) {
+            chunk.rule != bodyRule) {
           forceSplit = true;
           break;
         }
       }
     }
 
-    if (forceSplit) {
-      forceRules();
-    }
+    if (forceSplit) forceRules();
 
-    _parent!._endChildBlock(forceSplit: forceSplit);
-    return _parent!;
+    var parent = _parent!;
+    parent._endChildBlock(space: space, forceSplit: forceSplit);
+    return parent;
   }
 
   /// Finishes off the last chunk in a child block of this parent.
-  void _endChildBlock({required bool forceSplit}) {
+  void _endChildBlock({required bool space, required bool forceSplit}) {
     // If there is a hard newline within the block, force the surrounding rule
     // for it so that we apply that constraint.
     if (forceSplit) forceRules();
 
     // Start a new chunk for the code after the block contents. The split at
     // the beginning of this chunk also determines whether the preceding block
     // splits and, if so, how it is indented.
-    _startChunk(_blockArgumentNesting.last, isHard: false);
+    _startChunk(_blockArgumentNesting.last, isHard: false, space: space);
 
     if (rule.isHardened) _handleHardSplit();
   }