Format map and set literals. (#1283)

I'm formatting map entries the same way that assignments and variable
declarations are handled, so that we get nice "block-like" formatting
for delimited expressions, as in:

```
var map = {
  list: [
    1,
    2,
  ]
};
```

While I was at it, I also updated named arguments to do the same thing:

```
function(
  list: [
    1,
    2,
  ]
);
```

Also handle the "const" keyword on lists. I missed that when adding
initial support for lists.

Author: munificent

lib/src/ast_extensions.dart

@@ -113,7 +113,7 @@ extension ExpressionExtensions on Expression {
         ParenthesizedExpression(:var expression) => expression.isDelimited,
         ListLiteral() => true,
         MethodInvocation() => true,
-        // TODO(tall): Map and set literals.
+        SetOrMapLiteral() => true,
         // TODO(tall): Record literals.
         // TODO(tall): Instance creation expressions (`new` and `const`).
         // TODO(tall): Switch expressions.

lib/src/front_end/ast_node_visitor.dart

@@ -526,28 +526,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitListLiteral(ListLiteral node) {
-    visit(node.typeArguments);
-
-    var builder = DelimitedListBuilder(this);
-    builder.leftBracket(node.leftBracket);
-
-    // TODO(tall): Support a line comment inside a list literal as a signal to
-    // preserve internal newlines. So if you have:
-    //
-    // ```
-    // var list = [
-    //   1, 2, 3, // comment
-    //   4, 5, 6,
-    // ];
-    // ```
-    //
-    // The formatter will preserve the newline after element 3 and the lack of
-    // them after the other elements.
-
-    node.elements.forEach(builder.add);
-
-    builder.rightBracket(node.rightBracket);
-    writer.push(builder.build());
+    createCollection(node, node.leftBracket, node.elements, node.rightBracket);
   }
 
   @override
@@ -567,7 +546,8 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitMapLiteralEntry(MapLiteralEntry node) {
-    throw UnimplementedError();
+    visit(node.key);
+    finishAssignment(node.separator, node.value);
   }
 
   @override
@@ -611,9 +591,8 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitNamedExpression(NamedExpression node) {
-    visit(node.name);
-    writer.space();
-    visit(node.expression);
+    visit(node.name.label);
+    finishAssignment(node.name.colon, node.expression);
   }
 
   @override
@@ -805,7 +784,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitSetOrMapLiteral(SetOrMapLiteral node) {
-    throw UnimplementedError();
+    createCollection(node, node.leftBracket, node.elements, node.rightBracket);
   }
 
   @override
@@ -920,7 +899,9 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
   @override
   void visitVariableDeclaration(VariableDeclaration node) {
     token(node.name);
-    finishAssignment(node.equals, node.initializer);
+    if ((node.equals, node.initializer) case (var equals?, var initializer?)) {
+      finishAssignment(equals, initializer);
+    }
   }
 
   @override

lib/src/front_end/piece_factory.dart

@@ -13,6 +13,7 @@ import '../piece/piece.dart';
 import '../piece/postfix.dart';
 import 'ast_node_visitor.dart';
 import 'comment_writer.dart';
+import 'delimited_list_builder.dart';
 import 'piece_writer.dart';
 import 'sequence_builder.dart';
 
@@ -74,6 +75,34 @@ mixin PieceFactory implements CommentWriter {
         alwaysSplit: nodes.isNotEmpty));
   }
 
+  /// Creates a [ListPiece] for a collection literal.
+  void createCollection(TypedLiteral literal, Token leftBracket,
+      List<AstNode> elements, Token rightBracket) {
+    modifier(literal.constKeyword);
+    visit(literal.typeArguments);
+
+    var builder = DelimitedListBuilder(this);
+    builder.leftBracket(leftBracket);
+
+    // TODO(tall): Support a line comment inside a collection literal as a
+    // signal to preserve internal newlines. So if you have:
+    //
+    // ```
+    // var list = [
+    //   1, 2, 3, // comment
+    //   4, 5, 6,
+    // ];
+    // ```
+    //
+    // The formatter will preserve the newline after element 3 and the lack of
+    // them after the other elements.
+
+    elements.forEach(builder.add);
+
+    builder.rightBracket(rightBracket);
+    writer.push(builder.build());
+  }
+
   /// Creates metadata annotations for a directive.
   ///
   /// Always forces the annotations to be on a previous line.
@@ -237,23 +266,22 @@ mixin PieceFactory implements CommentWriter {
   /// * Variable declaration
   /// * Constructor initializer
   ///
-  /// This method assumes the code to the left of the `=` has already been
-  /// visited.
+  /// This is also used for map literal entries and named arguments which are
+  /// also sort of like bindings. In that case, [operator] is the `:`.
   ///
-  /// Does nothing if [equalsOperator] is `null`.
-  void finishAssignment(Token? equalsOperator, Expression? rightHandSide) {
-    if (equalsOperator == null) return;
-
-    writer.space();
-    token(equalsOperator);
+  /// This method assumes the code to the left of the `=` or `:` has already
+  /// been visited.
+  void finishAssignment(Token operator, Expression rightHandSide) {
+    if (operator.type == TokenType.EQ) writer.space();
+    token(operator);
     var target = writer.pop();
     writer.split();
 
     visit(rightHandSide);
 
     var initializer = writer.pop();
     writer.push(AssignPiece(target, initializer,
-        isValueDelimited: rightHandSide!.isDelimited));
+        isValueDelimited: rightHandSide.isDelimited));
   }
 
   /// Writes an optional modifier that precedes other code.

lib/src/front_end/piece_writer.dart

@@ -152,7 +152,7 @@ class PieceWriter {
     if (!hanging) _pendingSplit = false;
   }
 
-  /// Writes a mandatory newline from a comment in the current [TextPiece].
+  /// Writes a mandatory newline from a comment to the current [TextPiece].
   void writeNewline() {
     _pendingNewline = true;
   }

lib/src/piece/assign.dart

@@ -6,8 +6,13 @@ import '../constants.dart';
 import 'piece.dart';
 
 /// A piece for any construct where `=` is followed by an expression: variable
-/// initializer, assignment, constructor initializer, etc. Assignments can be
-/// formatted three ways:
+/// initializer, assignment, constructor initializer, etc.
+///
+/// This piece is also used for map entries and named arguments where `:` is
+/// followed by an expression or element because those also want to support the
+/// "block-like" formatting of delimited expressions on the right.
+///
+/// These constructs can be formatted three ways:
 ///
 /// [State.initial] No split at all:
 ///
@@ -59,15 +64,15 @@ class AssignPiece extends Piece {
 
   @override
   void format(CodeWriter writer, State state) {
-    writer.format(target);
-
-    // A split inside the value forces splitting at the "=" unless it's a
-    // delimited expression.
+    // A split in either child piece forces splitting after the "=" unless it's
+    // a delimited expression.
     if (state == State.initial) writer.setAllowNewlines(false);
 
     // Don't indent a split delimited expression.
     if (state != _insideValue) writer.setIndent(Indent.expression);
 
+    writer.format(target);
+
     writer.splitIf(state == _atEquals);
     writer.format(value);
   }

test/expression/list.stmt

@@ -3,6 +3,10 @@
 [];
 <<<
 [];
+>>> Const.
+const  [  1  ,  2  ,  3  ]  ;
+<<<
+const [1, 2, 3];
 >>> Exactly page width.
 [  first  ,  second  ,  third  ,  fourth  ,  seventh  ]  ;
 <<<
@@ -69,6 +73,15 @@
 <  int  >  [  1  ,  2  ,  3  ];
 <<<
 <int>[1, 2, 3];
+>>> Split list but not type arguments.
+<Map<int, String>>
+[firstElement, secondElement, thirdElement];
+<<<
+<Map<int, String>>[
+  firstElement,
+  secondElement,
+  thirdElement,
+];
 >>> Split type arguments but not list.
 <Map<VeryLongTypeName, AnotherLongTypeName>>[1, 2, 3];
 <<<

test/expression/map.stmt

@@ -0,0 +1,141 @@
+40 columns                              |
+>>> Empty.
+(  {  }  );
+<<<
+({});
+>>> Const.
+const  {  first  :  1  ,  second  :  2  }  ;
+<<<
+const {first: 1, second: 2};
+>>> Exactly page width.
+(  {  first  :  1  ,  second  :  2  ,  third  :  3  ,  f  :  4  }  );
+<<<
+({first: 1, second: 2, third: 3, f: 4});
+>>> Split.
+({first: 1, second: 2, third: 3, fourth: 4,});
+<<<
+({
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+});
+>>> Add trailing comma if split.
+({first: 1, second: 2, third: 3, fourth: 4});
+<<<
+({
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+});
+>>> Remove trailing comma if unsplit.
+({first: 1, second: 2, third: 3,});
+<<<
+({first: 1, second: 2, third: 3});
+>>> Prefer to split entry instead of key.
+({
+  first + second + third + fourth: fifth
+});
+<<<
+({
+  first + second + third + fourth:
+      fifth,
+});
+>>> Prefer to split entry instead of value.
+({
+  first: second + third + fourth + fifth
+});
+<<<
+({
+  first:
+      second + third + fourth + fifth,
+});
+>>> Split in key forces entry to split.
+({
+  first + second + third + fourth + fifth: sixth
+});
+<<<
+({
+  first +
+          second +
+          third +
+          fourth +
+          fifth:
+      sixth,
+});
+>>> Split in value forces entry to split.
+({
+  first: second + third + fourth + fifth + sixth
+});
+<<<
+({
+  first:
+      second +
+          third +
+          fourth +
+          fifth +
+          sixth,
+});
+>>> Remove blank lines around entries.
+({
+
+
+  firstElement: 1,
+
+
+
+  secondElement: 2,
+
+
+
+  thirdElement: 3
+
+
+});
+<<<
+({
+  firstElement: 1,
+  secondElement: 2,
+  thirdElement: 3,
+});
+>>> With type arguments.
+<  int  ,  String  >  {  1  :  'one'  ,  2  :  'two'  };
+<<<
+<int, String>{1: 'one', 2: 'two'};
+>>> Split map but not type arguments.
+<int, String>{firstElement: 'one', secondElement: 'two'};
+<<<
+<int, String>{
+  firstElement: 'one',
+  secondElement: 'two',
+};
+>>> Split type arguments but not map.
+<VeryLongTypeName, AnotherReallyLongTypeName>{1: 'one', 2: 'two'};
+<<<
+<
+  VeryLongTypeName,
+  AnotherReallyLongTypeName
+>{1: 'one', 2: 'two'};
+>>> Split type arguments and map.
+<VeryLongTypeName, AnotherReallyLongTypeName>
+{1: 'value one', 2: 'value two', 3: 'value three'};
+<<<
+<
+  VeryLongTypeName,
+  AnotherReallyLongTypeName
+>{
+  1: 'value one',
+  2: 'value two',
+  3: 'value three',
+};
+>>> Split in nested type argument.
+<List<NotSplit>, Map<VeryLongTypeName, AnotherLongTypeName>>{1: 'one', 2: 'two'};
+<<<
+<
+  List<NotSplit>,
+  Map<
+    VeryLongTypeName,
+    AnotherLongTypeName
+  >
+>{1: 'one', 2: 'two'};