Always split collections and argument lists with trailing commas.

lib/src/source_visitor.dart

 // Copyright (c) 2014, 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.
 
 library dart_style.src.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/source.dart';
 
@@ skipping 127 matching lines @@
     if (node.arguments.isEmpty) {
       token(node.leftParenthesis);
 
       // If there is a comment inside the parens, do allow splitting before it.
       if (node.rightParenthesis.precedingComments != null) soloZeroSplit();
 
       token(node.rightParenthesis);
       return;
     }
 
+    // If the argument list has a trailing comma, format it like a collection
+    // literal where each argument goes on its own line, they are indented +2,
+    // and the ")" ends up on its own line.
+    if (node.arguments.last.endToken.next.type == TokenType.COMMA) {
+      _visitCollectionLiteral(null, node.leftParenthesis, node.arguments, node.rightParenthesis);

[nweiz, 2016/07/25 22:29:06]

Long line.

[Bob Nystrom, 2016/07/26 21:22:07]

Ironically, I forgot to format. Done.

+      return;
+    }
+
     new ArgumentListVisitor(this, node).visit();
   }
 
   visitAsExpression(AsExpression node) {
     builder.startSpan();
     visit(node.expression);
     soloSplit();
     token(node.asOperator);
     space();
     visit(node.type);
@@ skipping 1724 matching lines @@
 
       visit(node);
 
       // The comma after the node.
       if (node.endToken.next.lexeme == ",") token(node.endToken.next);
     }
   }
 
   /// Visits the collection literal [node] whose body starts with [leftBracket],
   /// ends with [rightBracket] and contains [elements].
+  ///
+  /// This is also used for argument lists with a trailing comma which are
+  /// considered "collection-like". In that case, [node] is `null`.
   void _visitCollectionLiteral(TypedLiteral node, Token leftBracket,
       Iterable<AstNode> elements, Token rightBracket,
       [int cost]) {
-    modifier(node.constKeyword);
-    visit(node.typeArguments);
+    if (node != null) {
+      modifier(node.constKeyword);
+      visit(node.typeArguments);
+    }
 
     // Don't allow splitting in an empty collection.
     if (elements.isEmpty && rightBracket.precedingComments == null) {
       token(leftBracket);
       token(rightBracket);
       return;
     }
 
     // Force all of the surrounding collections to split.
     for (var i = 0; i < _collectionSplits.length; i++) {
@@ skipping 44 matching lines @@
           }
         } else {
           builder.split(nest: false, space: true);
         }
       }
 
       builder.nestExpression();
       visit(element);
 
       // The comma after the element.
-      if (element.endToken.next.lexeme == ",") token(element.endToken.next);
+      if (element.endToken.next.type == TokenType.COMMA) {
+        token(element.endToken.next);
+      }
 
       builder.unnest();
     }
 
     builder.endRule();
 
     // If there is a collection inside this one, it forces this one to split.
     var force = _collectionSplits.removeLast();
 
+    // If the collection has a trailing comma, the user must want it to split.
+    if (elements.isNotEmpty &&
+        elements.last.endToken.next.type == TokenType.COMMA) {
+      force = true;
+    }
+
     _endLiteralBody(rightBracket, ignoredRule: rule, forceSplit: force);
   }
 
   /// Gets the cost to split at an assignment (or `:` in the case of a named
   /// default value) with the given [rightHandSide].
   ///
   /// "Block-like" expressions (collections and cascades) bind a bit tighter
   /// because it looks better to have code like:
   ///
   ///     var list = [
@@ skipping 465 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }