Fix for issue 4482

pkg/analyzer/lib/src/generated/parser.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 4125 matching lines @@
    * @param expression the expression being checked
    */
   void _ensureAssignable(Expression expression) {
     if (expression != null && !expression.isAssignable) {
       _reportErrorForCurrentToken(
           ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE);
     }
   }
 
   /**
-   * If the current token has the expected type, return it after advancing to the next token.
-   * Otherwise report an error and return the current token without advancing. Note that the method
-   * [_expectGt] should be used if the argument to this method would be [TokenType.GT].
+   * If the current token has the expected type, return it after advancing to
+   * the next token. Otherwise report an error and return the current token
+   * without advancing.
    *
-   * @param type the type of token that is expected
-   * @return the token that matched the given type
+   * Note that the method [_expectGt] should be used if the argument to this
+   * method would be [TokenType.GT].
+   *
+   * The [type] is the type of token that is expected.
    */
   Token _expect(TokenType type) {
     if (_matches(type)) {
       return andAdvance;
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     if (type == TokenType.SEMICOLON) {
+      if (_tokenMatches(_currentToken.next, TokenType.SEMICOLON)) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.UNEXPECTED_TOKEN,
+            [_currentToken.lexeme]);
+        _advance();
+        return andAdvance;
+      }
       _reportErrorForToken(
           ParserErrorCode.EXPECTED_TOKEN,
           _currentToken.previous,
           [type.lexeme]);
     } else {
       _reportErrorForCurrentToken(
           ParserErrorCode.EXPECTED_TOKEN,
           [type.lexeme]);
     }
     return _currentToken;
@@ skipping 3120 matching lines @@
    * @param returnType the return type of the method
    * @return the method declaration that was parsed
    */
   MethodDeclaration
       _parseMethodDeclarationAfterReturnType(CommentAndMetadata commentAndMetadata,
       Token externalKeyword, Token staticKeyword, TypeName returnType) {
     SimpleIdentifier methodName = parseSimpleIdentifier();
     FormalParameterList parameters;
     if (!_matches(TokenType.OPEN_PAREN) &&
         (_matches(TokenType.OPEN_CURLY_BRACKET) || _matches(TokenType.FUNCTION))) {
-      _reportErrorForToken(ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
+      _reportErrorForToken(
+          ParserErrorCode.MISSING_METHOD_PARAMETERS,
+          _currentToken.previous);
       parameters = new FormalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN),
-                null,
-                null,
-                null,
-                _createSyntheticToken(TokenType.CLOSE_PAREN));
+          null,
+          null,
+          null,
+          _createSyntheticToken(TokenType.CLOSE_PAREN));
     } else {
       parameters = parseFormalParameterList();
     }
     _validateFormalParameterList(parameters);
     return _parseMethodDeclarationAfterParameters(
         commentAndMetadata,
         externalKeyword,
         staticKeyword,
         returnType,
         methodName,
@@ skipping 3090 matching lines @@
 
   static const ParserErrorCode MISSING_FUNCTION_BODY = const ParserErrorCode(
       'MISSING_FUNCTION_BODY',
       "A function body must be provided");
 
   static const ParserErrorCode MISSING_FUNCTION_PARAMETERS =
       const ParserErrorCode(
           'MISSING_FUNCTION_PARAMETERS',
           "Functions must have an explicit list of parameters");
 
-  static const ParserErrorCode MISSING_METHOD_PARAMETERS = const ParserErrorCode(
-      'MISSING_METHOD_PARAMETERS',
-      "Methods must have an explicit list of parameters");
+  static const ParserErrorCode MISSING_METHOD_PARAMETERS =
+      const ParserErrorCode(
+          'MISSING_METHOD_PARAMETERS',
+          "Methods must have an explicit list of parameters");
 
   static const ParserErrorCode MISSING_GET = const ParserErrorCode(
       'MISSING_GET',
       "Getters must have the keyword 'get' before the getter name");
 
   static const ParserErrorCode MISSING_IDENTIFIER =
       const ParserErrorCode('MISSING_IDENTIFIER', "Expected an identifier");
 
   static const ParserErrorCode MISSING_INITIALIZER =
       const ParserErrorCode('MISSING_INITIALIZER', "Expected an initializer");
@@ skipping 1680 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }