gracefully recover from extraneous top level modifiers

pkg/front_end/lib/src/fasta/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 fasta.parser.parser;
 
 import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 242 matching lines @@
       count++;
     }
     listener.endCompilationUnit(count, token);
     // Clear fields that could lead to memory leak.
     firstToken = null;
     cachedRewriter = null;
     return token;
   }
 
   Token parseTopLevelDeclaration(Token token) {
-    token = _parseTopLevelDeclaration(token);
+    token = parseTopLevelDeclarationImpl(token);
     listener.endTopLevelDeclaration(token);
     return token;
   }
 
-  Token _parseTopLevelDeclaration(Token token) {
+  Token parseTopLevelDeclarationImpl(Token token) {
     if (identical(token.type, TokenType.SCRIPT_TAG)) {
       return parseScript(token);
     }
     token = parseMetadataStar(token);
-    String value = token.stringValue;
-    if (identical(value, 'abstract')) {
-      if (optional('class', token.next)) {
-        return parseClassOrNamedMixinApplication(token);
+    if (token.isTopLevelKeyword) {
+      return parseTopLevelKeywordDeclaration(null, token);
+    }
+    Token start = token;
+    // Skip modifiers to find a top level keyword or identifier
+    while (token.isModifier) {
+      token = token.next;
+    }
+    if (token.isTopLevelKeyword) {
+      Token abstractToken;
+      Token modifierToken = start;
+      while (modifierToken != token) {
+        if (optional('abstract', modifierToken) &&
+            optional('class', token) &&
+            abstractToken == null) {
+          abstractToken = modifierToken;
+        } else {
+          // TODO(danrubel): Report more specific recoverable error message
+          // for `const class` to better help the user.
+          // See ParserErrorCode CONST_CLASS
+
+          // Report an error for each extraneous modifier
+          reportRecoverableErrorWithToken(
+              modifierToken, fasta.templateExtraneousModifier);
+        }
+        modifierToken = modifierToken.next;
       }
-      reportRecoverableErrorWithToken(token, fasta.templateExtraneousModifier);
-      token = token.next;
-      value = token.stringValue;
+      return parseTopLevelKeywordDeclaration(abstractToken, token);
+    } else if (token.isIdentifier || token.keyword != null) {
+      // TODO(danrubel): improve parseTopLevelMember
+      // so that we don't parse modifiers twice.
+      return parseTopLevelMember(start);
+    } else if (start != token) {
+      // Handle the edge case where a modifier is being used as an identifier
+      return parseTopLevelMember(start);
     }
+    // Ignore any preceding modifiers and just report the unexpected token
+    reportRecoverableErrorWithToken(token, fasta.templateExpectedDeclaration);
+    listener.handleInvalidTopLevelDeclaration(token);
+    return token.next;
+  }
+
+  Token parseTopLevelKeywordDeclaration(Token abstractToken, Token token) {
+    final String value = token.stringValue;
     if (identical(value, 'class')) {
-      return parseClassOrNamedMixinApplication(token);
+      return parseClassOrNamedMixinApplication(abstractToken, token);
     } else if (identical(value, 'enum')) {
       return parseEnum(token);
-    } else if (identical(value, 'typedef') &&
-        (token.next.isIdentifier || optional("void", token.next))) {
-      return parseTypedef(token);
+    } else if (identical(value, 'typedef')) {
+      Token next = token.next;
+      if (next.isIdentifier || optional("void", next)) {
+        return parseTypedef(token);
+      } else {
+        return parseTopLevelMember(token);
+      }
     } else if (identical(value, 'library')) {
       return parseLibraryName(token);
     } else if (identical(value, 'import')) {
       return parseImport(token);
     } else if (identical(value, 'export')) {
       return parseExport(token);
     } else if (identical(value, 'part')) {
       return parsePartOrPartOf(token);
-    } else if (token.type == TokenType.IDENTIFIER || token.keyword != null) {
-      return parseTopLevelMember(token);
-    } else {
-      reportRecoverableErrorWithToken(token, fasta.templateExpectedDeclaration);
-      listener.handleInvalidTopLevelDeclaration(token);
-      return token.next;
     }
+
+    throw "Internal error: Unhandled top level keyword '$value'.";
   }
 
   /// library qualified ';'
   Token parseLibraryName(Token token) {
     Token libraryKeyword = token;
     listener.beginLibraryName(libraryKeyword);
     assert(optional('library', token));
     token = parseQualified(token.next, IdentifierContext.libraryName,
         IdentifierContext.libraryNameContinuation);
     Token semicolon = token;
@@ skipping 506 matching lines @@
         token = parseIdentifier(token, IdentifierContext.enumValueDeclaration);
         count++;
       }
     }
     Token endBrace = token;
     token = expect('}', token);
     listener.endEnum(enumKeyword, endBrace, count);
     return token;
   }
 
-  Token parseClassOrNamedMixinApplication(Token token) {
+  Token parseClassOrNamedMixinApplication(Token abstractToken, Token token) {
     listener.beginClassOrNamedMixinApplication(token);
-    Token begin = token;
-    if (optional('abstract', token)) {
-      token = parseModifier(token);
+    Token begin = abstractToken ?? token;
+    if (abstractToken != null) {
+      token = parseModifier(abstractToken);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
     Token classKeyword = token;
     token = expect("class", token);
     Token name = token;
     token =
         parseIdentifier(name, IdentifierContext.classOrNamedMixinDeclaration);
     token = parseTypeVariablesOpt(token);
@@ skipping 3303 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);