diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0fe3947..fcccee8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.2.8
+
+* Format parameter lists with trailing commas like argument lists (#447).
+
 # 0.2.7
 
 * Make it strong mode clean.
diff --git a/bin/format.dart b/bin/format.dart
index 410d0c8..a25680e 100644
--- a/bin/format.dart
+++ b/bin/format.dart
@@ -14,7 +14,7 @@
 import 'package:dart_style/src/source_code.dart';
 
 // Note: The following line of code is modified by tool/grind.dart.
-const version = "0.2.7";
+const version = "0.2.8";
 
 void main(List<String> args) {
   var parser = new ArgParser(allowTrailingOptions: true);
diff --git a/lib/src/source_visitor.dart b/lib/src/source_visitor.dart
index a80a960..cb19267 100644
--- a/lib/src/source_visitor.dart
+++ b/lib/src/source_visitor.dart
@@ -879,6 +879,14 @@
       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();
@@ -1854,11 +1862,7 @@
       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);
@@ -2020,6 +2024,77 @@
     _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);
+
+    // 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].
   ///
diff --git a/pubspec.yaml b/pubspec.yaml
index 8ae5477..9464315 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: dart_style
 # Note: See tool/grind.dart for how to bump the version.
-version: 0.2.7
+version: 0.2.8
 author: Dart Team <misc@dartlang.org>
 description: Opinionated, automatic Dart source code formatter.
 homepage: https://github.com/dart-lang/dart_style
diff --git a/test/comments/functions.unit b/test/comments/functions.unit
index b2d0bc9..00c235b 100644
--- a/test/comments/functions.unit
+++ b/test/comments/functions.unit
@@ -126,4 +126,21 @@
 <<<
 main() {
   // comment
+}
+>>> comment before "]" with trailing comma
+function([parameter,/* c */]) {;}
+<<<
+function([
+  parameter,
+  /* c */
+]) {
+  ;
+}
+>>> comment before ")" with trailing comma
+function([parameter,]/* c */) {;}
+<<<
+function([
+  parameter,
+] /* c */) {
+  ;
 }
\ No newline at end of file
diff --git a/test/whitespace/functions.unit b/test/whitespace/functions.unit
index 2e8f487..206ec2b 100644
--- a/test/whitespace/functions.unit
+++ b/test/whitespace/functions.unit
@@ -77,10 +77,88 @@
   var lambda = () sync* {};
 }
 >>> trailing comma in single parameter list
-function(argument   ,   ) {}
+function(parameter   ,   ) {;}
 <<<
-function(argument,) {}
+function(
+  parameter,
+) {
+  ;
+}
 >>> trailing comma in parameter list
-function(argument,argument  ,  ) {}
+function(parameter,parameter  ,  ) {;}
 <<<
-function(argument, argument,) {}
\ No newline at end of file
+function(
+  parameter,
+  parameter,
+) {
+  ;
+}
+>>> trailing comma in all optional parameter list
+function([parameter,parameter  ,  ]) {;}
+<<<
+function([
+  parameter,
+  parameter,
+]) {
+  ;
+}
+>>> trailing comma in all named parameter list
+function({parameter,parameter  ,  }) {;}
+<<<
+function({
+  parameter,
+  parameter,
+}) {
+  ;
+}
+>>> trailing comma in mixed optional parameter list
+function(parameter,[parameter,parameter  ,  ]) {;}
+<<<
+function(
+  parameter, [
+  parameter,
+  parameter,
+]) {
+  ;
+}
+>>> trailing comma in mixed named parameter list
+function(parameter,{parameter,parameter  ,  }) {;}
+<<<
+function(
+  parameter, {
+  parameter,
+  parameter,
+}) {
+  ;
+}
+>>> trailing comma with => function containing split
+function(parameter,parameter,) => veryLongBodyThatWraps(argument, argument, argument, argument);
+<<<
+function(
+  parameter,
+  parameter,
+) =>
+    veryLongBodyThatWraps(argument,
+        argument, argument, argument);
+>>> trailing comma with wrap at =>
+function(parameter,parameter,) /* comment */ => "a very very long string";
+<<<
+function(
+  parameter,
+  parameter,
+) /* comment */ =>
+    "a very very long string";
+>>> trailing comma function nested in expression
+main() {
+  someVeryLongFunction(argument, argument, (parameter, parameter,) {;});
+}
+<<< (this looks weird, but it should rare and at least we test it)
+main() {
+  someVeryLongFunction(
+      argument, argument, (
+    parameter,
+    parameter,
+  ) {
+    ;
+  });
+}
\ No newline at end of file