Reorganize the code for selecting a block argument.

To determine which argument list in an argument list should be block
formatted, if any, we need to look at all of them. We can't do it
eagerly because the heuristics are generally of the form "If only one
argument is like X, then it is block formatted."

But before this commit, DelimitedListBuilder never saw all arguments at
once. It was given them one at a time. That meant that it had to stuff
the information needed to select a block argument (BlockFormat) into
ListPiece. This is kind of dumb because once we've selected a block
argument, that data is no longer needed, but ListPiece lives all the
way through the rest of the formatting process.

Fortunately, the only expressions that support block arguments are
argument lists, and those *do* add all of the arguments to the
DelimitedListBuilder at once. So this commit adds a method to
DelimitedListBuilder to pass them all in.

There are no behavior changes in this commit. This is just rearranging
code (and saving a bit of memory) to get ready for tweaking the
heuristics.

Author: munificent

lib/src/front_end/delimited_list_builder.dart

@@ -62,8 +62,6 @@ class DelimitedListBuilder {
       });
     }
 
-    if (_style.allowBlockElement) _setBlockElementFormatting();
-
     var piece =
         ListPiece(_leftBracket, _elements, _blanksAfter, _rightBracket, _style);
     if (_mustSplit || forceSplit) piece.pin(State.split);
@@ -134,8 +132,8 @@ class DelimitedListBuilder {
   /// [addCommentsBefore()] for the first token in the [piece].
   ///
   /// Assumes there is no comma after this piece.
-  void add(Piece piece, [BlockFormat format = BlockFormat.none]) {
-    _elements.add(ListElementPiece(_leadingComments, piece, format));
+  void add(Piece piece) {
+    _elements.add(ListElementPiece(_leadingComments, piece));
     _leadingComments.clear();
     _commentsBeforeComma = CommentSequence.empty;
   }
@@ -152,25 +150,33 @@ class DelimitedListBuilder {
     // Handle comments between the preceding element and this one.
     addCommentsBefore(element.firstNonCommentToken);
 
-    // See if it's an expression that supports block formatting.
-    var format = switch (element) {
-      AdjacentStrings(indentStrings: true) =>
-        BlockFormat.indentedAdjacentStrings,
-      AdjacentStrings() => BlockFormat.unindentedAdjacentStrings,
-      Expression() => element.blockFormatType,
-      DartPattern() when element.canBlockSplit => BlockFormat.collection,
-      _ => BlockFormat.none,
-    };
-
     // Traverse the element itself.
-    add(_visitor.nodePiece(element), format);
+    add(_visitor.nodePiece(element));
 
     var nextToken = element.endToken.next!;
     if (nextToken.lexeme == ',') {
       _commentsBeforeComma = _visitor.comments.takeCommentsBefore(nextToken);
     }
   }
 
+  /// Visits a list of [elements].
+  ///
+  /// If [allowBlockArgument] is `true`, then allows one element to receive
+  /// block formatting if appropriate, as in:
+  ///
+  ///     function(argument, [
+  ///       block,
+  ///       like,
+  ///     ], argument);
+  void visitAll(List<AstNode> elements, {bool allowBlockArgument = false}) {
+    for (var i = 0; i < elements.length; i++) {
+      var element = elements[i];
+      visit(element);
+    }
+
+    if (allowBlockArgument) _setBlockArgument(elements);
+  }
+
   /// Inserts an inner left delimiter between two elements.
   ///
   /// This is used for parameter lists when there are both mandatory and
@@ -398,6 +404,14 @@ class DelimitedListBuilder {
     );
   }
 
+  /// Given an argument list, determines which if any of the arguments should
+  /// get special block-like formatting as in the list literal in:
+  ///
+  ///     function(argument, [
+  ///       block,
+  ///       like,
+  ///     ], argument);
+  ///
   /// Looks at the [BlockFormat] types of all of the elements to determine if
   /// one of them should be block formatted.
   ///
@@ -426,14 +440,29 @@ class DelimitedListBuilder {
   ///
   /// Stores the result of this calculation by setting flags on the
   /// [ListElement]s.
-  void _setBlockElementFormatting() {
-    // TODO(tall): These heuristics will probably need some iteration.
+  void _setBlockArgument(List<AstNode> arguments) {
+    var firstIsUnindentedAdjacentStrings = false;
     var functions = <int>[];
     var collections = <int>[];
     var adjacentStrings = <int>[];
 
-    for (var i = 0; i < _elements.length; i++) {
-      switch (_elements[i].blockFormat) {
+    for (var i = 0; i < arguments.length; i++) {
+      var argument = arguments[i];
+      // See if it's an expression that supports block formatting.
+      var format = switch (argument) {
+        AdjacentStrings(indentStrings: true) =>
+          BlockFormat.indentedAdjacentStrings,
+        AdjacentStrings() => BlockFormat.unindentedAdjacentStrings,
+        Expression() => argument.blockFormatType,
+        DartPattern() when argument.canBlockSplit => BlockFormat.collection,
+        _ => BlockFormat.none,
+      };
+
+      if (i == 0 && format == BlockFormat.unindentedAdjacentStrings) {
+        firstIsUnindentedAdjacentStrings = true;
+      }
+
+      switch (format) {
         case BlockFormat.function:
           functions.add(i);
         case BlockFormat.collection:
@@ -471,6 +500,7 @@ class DelimitedListBuilder {
       }
     }
 
+    // TODO(tall): These heuristics will probably need some iteration.
     switch ((functions, collections, adjacentStrings)) {
       // Only allow block formatting in an argument list containing adjacent
       // strings when:
@@ -487,7 +517,7 @@ class DelimitedListBuilder {
       case ([1], _, [0]):
         // The adjacent strings.
         _elements[0].allowNewlinesWhenUnsplit = true;
-        if (_elements[0].blockFormat == BlockFormat.unindentedAdjacentStrings) {
+        if (firstIsUnindentedAdjacentStrings) {
           _elements[0].indentWhenBlockFormatted = true;
         }
 
@@ -503,8 +533,5 @@ class DelimitedListBuilder {
       case ([], [var element], _):
         _elements[element].allowNewlinesWhenUnsplit = true;
     }
-
-    // If we get here, there are no block element, or it's ambiguous as to
-    // which one should be it so none are.
   }
 }

lib/src/front_end/piece_factory.dart

@@ -123,7 +123,7 @@ mixin PieceFactory {
         leftBracket: leftBracket,
         elements,
         rightBracket: rightBracket,
-        style: const ListStyle(allowBlockElement: true));
+        allowBlockArgument: true);
   }
 
   /// Writes a bracket-delimited block or declaration body.
@@ -974,7 +974,8 @@ mixin PieceFactory {
       {required Token leftBracket,
       required Token rightBracket,
       ListStyle style = const ListStyle(),
-      bool preserveNewlines = false}) {
+      bool preserveNewlines = false,
+      bool allowBlockArgument = false}) {
     // If the list is completely empty, write the brackets directly inline so
     // that we create fewer pieces.
     if (!elements.canSplit(rightBracket)) {
@@ -990,7 +991,7 @@ mixin PieceFactory {
     if (preserveNewlines && elements.containsLineComments(rightBracket)) {
       _preserveNewlinesInCollection(elements, builder);
     } else {
-      elements.forEach(builder.visit);
+      builder.visitAll(elements, allowBlockArgument: allowBlockArgument);
     }
 
     builder.rightBracket(rightBracket);

lib/src/piece/list.dart

@@ -252,9 +252,6 @@ final class ListElementPiece extends Piece {
 
   final Piece? _content;
 
-  /// What kind of block formatting can be applied to this element.
-  final BlockFormat blockFormat;
-
   /// Whether newlines are allowed in this element when this list is unsplit.
   ///
   /// This is generally only true for a single "block" element, as in:
@@ -312,16 +309,13 @@ final class ListElementPiece extends Piece {
   /// delimiter (here `,` and 2).
   int _commentsBeforeDelimiter = 0;
 
-  ListElementPiece(
-      List<Piece> leadingComments, Piece element, BlockFormat format)
+  ListElementPiece(List<Piece> leadingComments, Piece element)
       : _leadingComments = [...leadingComments],
-        _content = element,
-        blockFormat = format;
+        _content = element;
 
   ListElementPiece.comment(Piece comment)
       : _leadingComments = const [],
-        _content = null,
-        blockFormat = BlockFormat.none {
+        _content = null {
     _hangingComments.add(comment);
   }
 
@@ -459,18 +453,8 @@ class ListStyle {
   ///     //              ^                      ^
   final bool spaceWhenUnsplit;
 
-  /// Whether an element in the list is allowed to have block-like formatting,
-  /// as in:
-  ///
-  ///     function(argument, [
-  ///       block,
-  ///       like,
-  ///     ], argument);
-  final bool allowBlockElement;
-
   const ListStyle(
       {this.commas = Commas.trailing,
       this.splitCost = Cost.normal,
-      this.spaceWhenUnsplit = false,
-      this.allowBlockElement = false});
+      this.spaceWhenUnsplit = false});
 }