gracefully recover from extraneous top level modifiers

pkg/front_end/lib/src/scanner/token.dart

 // Copyright (c) 2016, 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.
 
 /**
  * Defines the tokens that are produced by the scanner, used by the parser, and
  * referenced from the [AST structure](ast.dart).
  */
 import 'dart:collection';
 
@@ skipping 120 matching lines @@
   }
 }
 
 /**
  * The keywords in the Dart programming language.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class Keyword extends TokenType {
   static const Keyword ABSTRACT =
-      const Keyword("abstract", "ABSTRACT", isBuiltIn: true);
+      const Keyword("abstract", "ABSTRACT", isBuiltIn: true, isModifier: true);
 
   static const Keyword AS = const Keyword("as", "AS",
       precedence: RELATIONAL_PRECEDENCE, isBuiltIn: true);
 
   static const Keyword ASSERT = const Keyword("assert", "ASSERT");
 
   static const Keyword ASYNC = const Keyword("async", "ASYNC", isPseudo: true);
 
   static const Keyword AWAIT = const Keyword("await", "AWAIT", isPseudo: true);
 
   static const Keyword BREAK = const Keyword("break", "BREAK");
 
   static const Keyword CASE = const Keyword("case", "CASE");
 
   static const Keyword CATCH = const Keyword("catch", "CATCH");
 
-  static const Keyword CLASS = const Keyword("class", "CLASS");
+  static const Keyword CLASS =
+      const Keyword("class", "CLASS", isTopLevelKeyword: true);
 
-  static const Keyword CONST = const Keyword("const", "CONST");
+  static const Keyword CONST =
+      const Keyword("const", "CONST", isModifier: true);
 
   static const Keyword CONTINUE = const Keyword("continue", "CONTINUE");
 
   static const Keyword COVARIANT =
       const Keyword("covariant", "COVARIANT", isBuiltIn: true);
 
   static const Keyword DEFAULT = const Keyword("default", "DEFAULT");
 
   static const Keyword DEFERRED =
       const Keyword("deferred", "DEFERRED", isBuiltIn: true);
 
   static const Keyword DO = const Keyword("do", "DO");
 
   static const Keyword DYNAMIC =
       const Keyword("dynamic", "DYNAMIC", isBuiltIn: true);
 
   static const Keyword ELSE = const Keyword("else", "ELSE");
 
-  static const Keyword ENUM = const Keyword("enum", "ENUM");
+  static const Keyword ENUM =
+      const Keyword("enum", "ENUM", isTopLevelKeyword: true);
 
-  static const Keyword EXPORT =
-      const Keyword("export", "EXPORT", isBuiltIn: true);
+  static const Keyword EXPORT = const Keyword("export", "EXPORT",
+      isBuiltIn: true, isTopLevelKeyword: true);
 
   static const Keyword EXTENDS = const Keyword("extends", "EXTENDS");
 
   static const Keyword EXTERNAL =
       const Keyword("external", "EXTERNAL", isBuiltIn: true);
 
   static const Keyword FACTORY =
       const Keyword("factory", "FACTORY", isBuiltIn: true);
 
   static const Keyword FALSE = const Keyword("false", "FALSE");
 
-  static const Keyword FINAL = const Keyword("final", "FINAL");
+  static const Keyword FINAL =
+      const Keyword("final", "FINAL", isModifier: true);
 
   static const Keyword FINALLY = const Keyword("finally", "FINALLY");
 
   static const Keyword FOR = const Keyword("for", "FOR");
 
   static const Keyword FUNCTION =
       const Keyword("Function", "FUNCTION", isPseudo: true);
 
   static const Keyword GET = const Keyword("get", "GET", isBuiltIn: true);
 
   static const Keyword HIDE = const Keyword("hide", "HIDE", isPseudo: true);
 
   static const Keyword IF = const Keyword("if", "IF");
 
   static const Keyword IMPLEMENTS =
       const Keyword("implements", "IMPLEMENTS", isBuiltIn: true);
 
-  static const Keyword IMPORT =
-      const Keyword("import", "IMPORT", isBuiltIn: true);
+  static const Keyword IMPORT = const Keyword("import", "IMPORT",
+      isBuiltIn: true, isTopLevelKeyword: true);
 
   static const Keyword IN = const Keyword("in", "IN");
 
   static const Keyword IS =
       const Keyword("is", "IS", precedence: RELATIONAL_PRECEDENCE);
 
-  static const Keyword LIBRARY =
-      const Keyword("library", "LIBRARY", isBuiltIn: true);
+  static const Keyword LIBRARY = const Keyword("library", "LIBRARY",
+      isBuiltIn: true, isTopLevelKeyword: true);
 
   static const Keyword NATIVE =
       const Keyword("native", "NATIVE", isPseudo: true);
 
   static const Keyword NEW = const Keyword("new", "NEW");
 
   static const Keyword NULL = const Keyword("null", "NULL");
 
   static const Keyword OF = const Keyword("of", "OF", isPseudo: true);
 
   static const Keyword ON = const Keyword("on", "ON", isPseudo: true);
 
   static const Keyword OPERATOR =
       const Keyword("operator", "OPERATOR", isBuiltIn: true);
 
-  static const Keyword PART = const Keyword("part", "PART", isBuiltIn: true);
+  static const Keyword PART =
+      const Keyword("part", "PART", isBuiltIn: true, isTopLevelKeyword: true);
 
   static const Keyword PATCH = const Keyword("patch", "PATCH", isPseudo: true);
 
   static const Keyword RETHROW = const Keyword("rethrow", "RETHROW");
 
   static const Keyword RETURN = const Keyword("return", "RETURN");
 
   static const Keyword SET = const Keyword("set", "SET", isBuiltIn: true);
 
   static const Keyword SHOW = const Keyword("show", "SHOW", isPseudo: true);
 
   static const Keyword SOURCE =
       const Keyword("source", "SOURCE", isPseudo: true);
 
   static const Keyword STATIC =
-      const Keyword("static", "STATIC", isBuiltIn: true);
+      const Keyword("static", "STATIC", isBuiltIn: true, isModifier: true);
 
   static const Keyword SUPER = const Keyword("super", "SUPER");
 
   static const Keyword SWITCH = const Keyword("switch", "SWITCH");
 
   static const Keyword SYNC = const Keyword("sync", "SYNC", isPseudo: true);
 
   static const Keyword THIS = const Keyword("this", "THIS");
 
   static const Keyword THROW = const Keyword("throw", "THROW");
 
   static const Keyword TRUE = const Keyword("true", "TRUE");
 
   static const Keyword TRY = const Keyword("try", "TRY");
 
-  static const Keyword TYPEDEF =
-      const Keyword("typedef", "TYPEDEF", isBuiltIn: true);
+  static const Keyword TYPEDEF = const Keyword("typedef", "TYPEDEF",
+      isBuiltIn: true, isTopLevelKeyword: true);
 
   static const Keyword VAR = const Keyword("var", "VAR");
 
   static const Keyword VOID = const Keyword("void", "VOID");
 
   static const Keyword WHILE = const Keyword("while", "WHILE");
 
   static const Keyword WITH = const Keyword("with", "WITH");
 
   static const Keyword YIELD = const Keyword("yield", "YIELD", isPseudo: true);
@@ skipping 75 matching lines @@
   final bool isBuiltIn;
 
   @override
   final bool isPseudo;
 
   /**
    * Initialize a newly created keyword.
    */
   const Keyword(String lexeme, String name,
       {this.isBuiltIn: false,
+      bool isModifier: false,
       this.isPseudo: false,
+      bool isTopLevelKeyword: false,
       int precedence: NO_PRECEDENCE})
-      : super(lexeme, name, precedence, KEYWORD_TOKEN);
+      : super(lexeme, name, precedence, KEYWORD_TOKEN,
+            isModifier: isModifier, isTopLevelKeyword: isTopLevelKeyword);
 
   bool get isBuiltInOrPseudo => isBuiltIn || isPseudo;
 
   /**
    * A flag indicating whether the keyword is "built-in" identifier.
    * This method exists for backward compatibility and will be removed.
    * Use [isBuiltIn] instead.
    */
   @deprecated
   bool get isPseudoKeyword => isBuiltIn; // TODO (danrubel): remove this
@@ skipping 104 matching lines @@
   @override
   int get end => offset + length;
 
   @override
   bool get isEof => type == TokenType.EOF;
 
   @override
   bool get isIdentifier => false;
 
   @override
+  bool get isModifier => type.isModifier;
+
+  @override
   bool get isOperator => type.isOperator;
 
   @override
   bool get isSynthetic => length == 0;
 
   @override
+  bool get isTopLevelKeyword => type.isTopLevelKeyword;
+
+  @override
   bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
   @override
   Keyword get keyword => null;
 
   @override
   int get kind => type.kind;
 
   @override
   int get length => lexeme.length;
@@ skipping 206 matching lines @@
    */
   bool get isEof;
 
   /**
    * True if this token is an identifier. Some keywords allowed as identifiers,
    * see implementation in [KeywordToken].
    */
   bool get isIdentifier;
 
   /**
+   * Return `true` if this token is a modifier such as `abstract` or `const`.
+   */
+  bool get isModifier;
+
+  /**
    * Return `true` if this token represents an operator.
    */
   bool get isOperator;
 
   /**
    * Return `true` if this token is a synthetic token. A synthetic token is a
    * token that was introduced by the parser in order to recover from an error
    * in the code.
    */
   bool get isSynthetic;
 
   /**
+   * Return `true` if this token is a keyword starting a top level declaration
+   * such as `class`, `enum`, `import`, etc.
+   */
+  bool get isTopLevelKeyword;
+
+  /**
    * Return `true` if this token represents an operator that can be defined by
    * users.
    */
   bool get isUserDefinableOperator;
 
   /**
    * Return the keyword, if a keyword token, or `null` otherwise.
    */
   Keyword get keyword;
 
@@ skipping 690 matching lines @@
     //TokenType.EQ_EQ_EQ,
 
     // Used by synthetic tokens generated during recovery
     //TokenType.BAD_INPUT,
     //TokenType.RECOVERY,
   ];
 
   final int kind;
 
   /**
+   * `true` if this token type represents a modifier
+   * such as `abstract` or `const`.
+   */
+  final bool isModifier;
+
+  /**
    * `true` if this token type represents an operator.
    */
   final bool isOperator;
 
   /**
+   * `true` if this token type represents a keyword starting a top level
+   * declaration such as `class`, `enum`, `import`, etc.
+   */
+  final bool isTopLevelKeyword;
+
+  /**
    * `true` if this token type represents an operator
    * that can be defined by users.
    */
   final bool isUserDefinableOperator;
 
   /**
    * The lexeme that defines this type of token,
    * or `null` if there is more than one possible lexeme for this type of token.
    */
   final String lexeme;
 
   /**
    * The name of the token type.
    */
   final String name;
 
   /**
    * The precedence of this type of token,
    * or `0` if the token does not represent an operator.
    */
   final int precedence;
 
   /**
    * See [Token.stringValue] for an explanation.
    */
   final String stringValue;
 
   const TokenType(this.lexeme, this.name, this.precedence, this.kind,
-      {this.isOperator: false,
+      {this.isModifier: false,
+      this.isOperator: false,
+      this.isTopLevelKeyword: false,
       this.isUserDefinableOperator: false,
       String stringValue: 'unspecified'})
       : this.stringValue = stringValue == 'unspecified' ? lexeme : stringValue;
 
   /**
    * Return `true` if this type of token represents an additive operator.
    */
   bool get isAdditiveOperator => precedence == ADDITIVE_PRECEDENCE;
 
   /**
@@ skipping 84 matching lines @@
 
   @override
   String toString() => name;
 
   /**
    * Use [lexeme] instead of this method
    */
   @deprecated
   String get value => lexeme;
 }