Fix VariableDefinitions.endToken for formal parameters.

sdk/lib/_internal/compiler/implementation/scanner/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.
 
 part of scanner;
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
@@ skipping 345 matching lines @@
       token = parseFormalParameters(token);
       listener.handleFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
     }
-    listener.endFormalParameter(token, thisKeyword);
+    listener.endFormalParameter(thisKeyword);
     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;
@@ skipping 170 matching lines @@
     } else {
       listener.handleNoType(token);
     }
     listener.endTypeVariable(token);
     return token;
   }
 
   /**
    * Returns true if the stringValue of the [token] is [value].
    */
-  bool optional(String value, Token token) => identical(value, token.stringValue);
+  bool optional(String value, Token token) =>
+      identical(value, token.stringValue);

[ahe, 2013/02/04 13:38:26]

Since it doesn't fit on one line, I'd prefer using { return ... }.

[Johnni Winther, 2013/02/05 09:03:09]

Done.

+
+  /**
+   * Returns true if the stringValue of the [token] is either [value1],
+   * [value2], [value3], or [value4].
+   */
+  bool isOneOf4(Token token,
+                String value1, String value2, String value3, String value4) {
+    String stringValue = token.stringValue;
+    return identical(value1, stringValue) ||
+           identical(value2, stringValue) ||
+           identical(value3, stringValue) ||
+           identical(value4, stringValue);
+  }
 
   bool notEofOrValue(String value, Token token) {
-    return !identical(token.kind, EOF_TOKEN) && !identical(value, token.stringValue);
+    return !identical(token.kind, EOF_TOKEN) &&
+           !identical(value, token.stringValue);
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isValidTypeReference(token)) {
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
       token = listener.expectedType(token);
     }
@@ skipping 1290 matching lines @@
     listener.handleAsOperator(operator, token);
     String value = token.stringValue;
     if (identical(value, 'is') || identical(value, 'as')) {
       // The is- and as-operators cannot be chained.
       listener.unexpected(token);
     }
     return token;
   }
 
   Token parseVariablesDeclaration(Token token) {
-    token = parseVariablesDeclarationNoSemicolon(token);
-    return expectSemicolon(token);
+    return parseVariablesDeclarationMaybeSemicolon(token, true);
   }
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
+    return parseVariablesDeclarationMaybeSemicolon(token, false);
+  }
+
+  Token parseVariablesDeclarationMaybeSemicolon(Token token,
+                                                bool endWithSemicolon) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseModifiers(token);
     token = parseTypeOpt(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
       ++count;
     }
-    listener.endVariablesDeclaration(count, token);
-    return token;
+    if (endWithSemicolon) {
+      expectSemicolon(token);

[ahe, 2013/02/04 13:38:26]

I have a prototype that recovers on missing semicolons, and this version should
just work:

Token semicolon = token;
token = expectSemicolon(token);
listener.endVariablesDeclaration(count, semiColon);
return token;

In particular, it is important that we let expectSemicolon control what the next
token is.

[Johnni Winther, 2013/02/05 09:03:09]

Done.

+      listener.endVariablesDeclaration(count, token);
+      return token.next;
+    } else {
+      listener.endVariablesDeclaration(count, null);
+      return token;
+    }
   }
 
   Token parseOptionallyInitializedIdentifier(Token token) {
     listener.beginInitializedIdentifier(token);
     token = parseIdentifier(token);
     token = parseVariableInitializerOpt(token);
     listener.endInitializedIdentifier();
     return token;
   }
 
@@ skipping 29 matching lines @@
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
     } else if ((identical(value, 'var')) || (identical(value, 'final'))) {
       return parseVariablesDeclarationNoSemicolon(token);
     }
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
       assert(identifier.isIdentifier());
-      Token afterId = identifier.next;
-      int afterIdKind = afterId.kind;
-      if (identical(afterIdKind, EQ_TOKEN) || identical(afterIdKind, SEMICOLON_TOKEN) ||
-          identical(afterIdKind, COMMA_TOKEN) || optional('in', afterId)) {
+      if (isOneOf4(identifier.next, '=', ';', ',', 'in')) {
         return parseVariablesDeclarationNoSemicolon(token);
       }
     }
     return parseExpression(token);
   }
 
   Token parseForRest(Token forToken, Token token) {
     token = expectSemicolon(token);
     if (optional(';', token)) {
       token = parseEmptyStatement(token);
@@ skipping 247 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }