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 252 matching lines @@
     token = _parseTopLevelDeclaration(token);
     listener.endTopLevelDeclaration(token);
     return token;
   }
 
   Token _parseTopLevelDeclaration(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;
+    Link<Token> modifiers = const Link<Token>();

[ahe, 2017/09/01 14:42:52]

Perhaps we can take advantage of the next pointer in the tokens themselves? That
is, not create a Link?

[danrubel, 2017/09/01 15:13:55]

I was following what you do in parseTopLevelMember so that we would not check
modifier tokens more than once. That said, I like your idea about using the next
token pointer rather than creating a separate Link object. I'll take another
crack at it.

+    while (token.isModifier) {
+      modifiers = modifiers.prepend(token);
+      token = token.next;
+    }
+    if (token.isTopLevelKeyword) {
+      Token abstractToken;
+      while (modifiers.isNotEmpty) {
+        Token modifierToken = modifiers.head;
+        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);
+        }
+        modifiers = modifiers.tail;
       }
-      reportRecoverableErrorWithToken(token, fasta.templateExtraneousModifier);
-      token = token.next;
-      value = token.stringValue;
+      return parseTopLevelKeywordDeclaration(abstractToken, token);
+    } else if (token.isIdentifier || token.keyword != null) {
+      return parseTopLevelMember(token, start, modifiers);
+    } else if (modifiers.isNotEmpty && modifiers.head.type.isBuiltIn) {
+      // 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 723 matching lines @@
         token.next = new Token(TokenType.GT, token.charOffset + 1);
         token.next.next = next;
       }
       endStuff(count, begin, token);
       return expect('>', token);
     }
     handleNoStuff(token);
     return token;
   }
 
-  Token parseTopLevelMember(Token token) {
-    Token start = token;
+  Token parseTopLevelMember(Token token,
+      [Token start, Link<Token> identifiers = const Link<Token>()]) {

[ahe, 2017/09/01 14:42:52]

I try to avoid optional arguments in the parser, as I'm not sure they have great
performance.

+    start ??= token;
     listener.beginTopLevelMember(token);
 
-    Link<Token> identifiers = findMemberName(token);
+    identifiers = findMemberName(token, identifiers);
     if (identifiers.isEmpty) {
       return reportUnrecoverableErrorWithToken(
               start, fasta.templateExpectedDeclaration)
           .next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
       return reportUnrecoverableErrorWithToken(
@@ skipping 177 matching lines @@
   ///
   ///     get foo async* { return null }
   /// results in
   ///     ['{', 'foo', 'get']
   ///
   ///
   ///     operator *(arg) => null;
   /// results in
   ///     ['(', '*', 'operator']
   ///
-  Link<Token> findMemberName(Token token) {
+  Link<Token> findMemberName(Token token,
+      [Link<Token> identifiers = const Link<Token>()]) {
     // TODO(ahe): This method is rather broken for examples like this:
     //
     //     get<T>(){}
     //
     // In addition, the loop below will include things that can't be
     // identifiers. This may be desirable (for error recovery), or
     // not. Regardless, this method probably needs an overhaul.
-    Link<Token> identifiers = const Link<Token>();
 
     // `true` if 'get' has been seen.
     bool isGetter = false;
     // `true` if an identifier has been seen after 'get'.
     bool hasName = false;
 
     while (token.kind != EOF_TOKEN) {
       if (optional('get', token)) {
         isGetter = true;
       } else if (hasName &&
@@ skipping 2349 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);