Format parameter lists with trailing commas like argument lists.

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 861 matching lines @@
     if (node.parameters.isEmpty) {
       token(node.leftParenthesis);
 
       // If there is a comment, do allow splitting before it.
       if (node.rightParenthesis.precedingComments != null) soloZeroSplit();
 
       token(node.rightParenthesis);
       return;
     }
 
+    // If the parameter list has a trailing comma, format it like a collection
+    // literal where each parameter goes on its own line, they are indented +2,
+    // and the ")" ends up on its own line.
+    if (node.parameters.last.endToken.next.type == TokenType.COMMA) {
+      _visitTrailingCommaParameterList(node);
+      return;
+    }
+
     var requiredParams = node.parameters
         .where((param) => param is! DefaultFormalParameter)
         .toList();
     var optionalParams = node.parameters
         .where((param) => param is DefaultFormalParameter)
         .toList();
 
     builder.nestExpression();
     token(node.leftParenthesis);
 
@@ skipping 955 matching lines @@
     //             parameter) =>
     //         function(
     //             argument);
     if (body is ExpressionFunctionBody) {
       builder.nestExpression();
 
       // This rule is ended by visitExpressionFunctionBody().
       builder.startLazyRule(new Rule(Cost.arrow));
     }
 
-    if (parameters != null) {
-      builder.nestExpression();
-      visit(parameters);
-      builder.unnest();
-    }
+    if (parameters != null) visit(parameters);
 
     if (beforeBody != null) beforeBody();
     visit(body);
 
     if (body is ExpressionFunctionBody) builder.unnest();
   }
 
   /// Visits the body statement of a `for`, `for in`, or `while` loop.
   void _visitLoopBody(Statement body) {
     if (body is EmptyStatement) {
@@ skipping 141 matching lines @@
 
     // 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);
   }
 
+  /// Writes [parameters], which is assumed to have a trailing comma after the
+  /// last parameter.
+  ///
+  /// Parameter lists with trailing commas are formatted differently from
+  /// regular parameter lists. They are treated more like collection literals.
+  ///
+  /// We don't reuse [_visitCollectionLiteral] here because there are enough
+  /// weird differences around optional parameters that it's easiest just to
+  /// give them their own method.
+  void _visitTrailingCommaParameterList(FormalParameterList parameters) {
+    // Can't have a trailing comma if there are no parameters.
+    assert(parameters.parameters.isNotEmpty);

[jakemac, 2016/07/29 21:57:05]

or possibly assert(node.parameters.last.endToken.next.type == TokenType.COMMA)?

[Bob Nystrom, 2016/07/29 22:18:26]

I could assert that too, but it felt a bit gratuitous to me. I'm asserting the
list isn't empty mainly because we call ".first" on it below, which will throw
an exception if the list is empty. If there isn't a trailing comma, we shouldn't
get here, but it should still do the right thing.

+
+    // Always split the parameters.
+    builder.startRule(new Rule.hard());
+
+    token(parameters.leftParenthesis);
+
+    // Find the parameter immediately preceding the optional parameters (if
+    // there are any).
+    FormalParameter lastRequired;
+    for (var i = 0; i < parameters.parameters.length; i++) {
+      if (parameters.parameters[i] is DefaultFormalParameter) {
+        if (i > 0) lastRequired = parameters.parameters[i - 1];
+        break;
+      }
+    }
+
+    // If all parameters are optional, put the "[" or "{" right after "(".
+    if (parameters.parameters.first is DefaultFormalParameter) {
+      token(parameters.leftDelimiter);
+    }
+
+    // Process the parameters as a separate set of chunks.
+    builder = builder.startBlock(null);
+
+    for (var parameter in parameters.parameters) {
+      builder.nestExpression();
+      visit(parameter);
+
+      // The comma after the parameter.
+      if (parameter.endToken.next.type == TokenType.COMMA) {
+        token(parameter.endToken.next);
+      }
+
+      // If the optional parameters start after this one, put the delimiter
+      // at the end of its line.
+      if (parameter == lastRequired) {
+        space();
+        token(parameters.leftDelimiter);
+        lastRequired = null;
+      }
+
+      builder.unnest();
+      newline();
+    }
+
+    // Put comments before the closing ")", "]", or "}" inside the block.
+    var firstDelimiter =
+        parameters.rightDelimiter ?? parameters.rightParenthesis;
+    writePrecedingCommentsAndNewlines(firstDelimiter);
+    builder = builder.endBlock(null, forceSplit: true);
+    builder.endRule();
+
+    // Now write the delimiter itself.
+    _writeText(firstDelimiter.lexeme, firstDelimiter.offset);
+    if (firstDelimiter != parameters.rightParenthesis) {
+      token(parameters.rightParenthesis);
+    }
+  }
+
   /// 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 = [
   ///       element,
   ///       element,
   ///       element
@@ skipping 458 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;
 }