dart2js: allow trailing commas in parameter and argument lists

pkg/compiler/lib/src/parser/parser.dart

 // Copyright (c) 2012, 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 dart2js.parser;
 
 import '../options.dart' show ParserOptions;
 import '../common.dart';
 import '../tokens/keyword.dart' show Keyword;
 import '../tokens/precedence.dart' show PrecedenceInfo;
@@ skipping 409 matching lines @@
   }
 
   Token parseFormalParameters(Token token) {
     Token begin = token;
     listener.beginFormalParameters(begin);
     expect('(', token);
     int parameterCount = 0;
     if (optional(')', token.next)) {
       listener.endFormalParameters(parameterCount, begin, token.next);
       return token.next.next;
     }

[Lasse Reichstein Nielsen, 2016/07/08 05:45:18]

Is this `if` necessary now?

     do {
+      token = token.next;
+      if (optional(')', token)) {
+        break;
+      }
       ++parameterCount;
-      token = token.next;
       String value = token.stringValue;
       if (identical(value, '[')) {
         token = parseOptionalFormalParameters(token, false);
         break;
       } else if (identical(value, '{')) {
         token = parseOptionalFormalParameters(token, true);
         break;
       }
       token = parseFormalParameter(token, FormalParameterType.REQUIRED);
     } while (optional(',', token));
@@ skipping 44 matching lines @@
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
+      if (isNamed && optional('}', token)) {
+        break;
+      } else if (!isNamed && optional(']', token)) {
+        break;
+      }
       var type =
           isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
       token = parseFormalParameter(token, type);
       ++parameterCount;
     } while (optional(',', token));
+    if (parameterCount == 0) {
+      listener.reportError(
+          token,
+          isNamed
+              ? MessageKind.EMPTY_NAMED_PARAMETER_LIST
+              : MessageKind.EMPTY_OPTIONAL_PARAMETER_LIST);
+    }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
     Token peek = peekAfterIfType(token);
@@ skipping 2045 matching lines @@
     listener.beginArguments(begin);
     assert(identical('(', token.stringValue));
     int argumentCount = 0;
     if (optional(')', token.next)) {
       listener.endArguments(argumentCount, begin, token.next);
       return token.next.next;
     }
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = true;
     do {
+      if (optional(')', token.next)) {
+        token = token.next;
+        break;
+      }
       Token colon = null;
       if (optional(':', token.next.next)) {
         token = parseIdentifier(token.next);
         colon = token;
       }
       token = parseExpression(token.next);
       if (colon != null) listener.handleNamedArgument(colon);
       ++argumentCount;
     } while (optional(',', token));
     mayParseFunctionExpressions = old;
@@ skipping 404 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }