Push new analyzer-experimental with Resolver and ResolverTest.

pkg/analyzer-experimental/lib/src/generated/scanner.dart

 // 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.scanner;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'source.dart';
 import 'error.dart';
 import 'instrumentation.dart';
 
 /**
  * Instances of the abstract class {@code KeywordState} represent a state in a state machine used to
  * scan keywords.
+ * @coverage dart.engine.parser
  */
 class KeywordState {
   /**
    * An empty transition table used by leaf states.
    */
   static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>(26);
   /**
    * The initial state in the state machine.
    */
   static KeywordState KEYWORD_STATE = createKeywordStateTable();
@@ skipping 85 matching lines @@
   /**
    * Return the state that follows this state on a transition of the given character, or{@code null} if there is no valid state reachable from this state with such a transition.
    * @param c the character used to transition from this state to another state
    * @return the state that follows this state on a transition of the given character
    */
   KeywordState next(int c) => _table[c - 0x61];
 }
 /**
  * The enumeration {@code ScannerErrorCode} defines the error codes used for errors detected by the
  * scanner.
+ * @coverage dart.engine.parser
  */
 class ScannerErrorCode implements ErrorCode {
   static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode('ILLEGAL_CHARACTER', 0, "Illegal character %x");
   static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode('MISSING_DIGIT', 1, "Decimal digit expected");
   static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode('MISSING_HEX_DIGIT', 2, "Hexidecimal digit expected");
   static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode('MISSING_QUOTE', 3, "Expected quote (' or \")");
   static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode('UNTERMINATED_MULTI_LINE_COMMENT', 4, "Unterminated multi-line comment");
   static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode('UNTERMINATED_STRING_LITERAL', 5, "Unterminated string literal");
   static final List<ScannerErrorCode> values = [ILLEGAL_CHARACTER, MISSING_DIGIT, MISSING_HEX_DIGIT, MISSING_QUOTE, UNTERMINATED_MULTI_LINE_COMMENT, UNTERMINATED_STRING_LITERAL];
   final String __name;
   final int __ordinal;
+  int get ordinal => __ordinal;
   /**
    * The message template used to create the message to be displayed for this error.
    */
   String _message;
   /**
    * Initialize a newly created error code to have the given message.
    * @param message the message template used to create the message to be displayed for this error
    */
   ScannerErrorCode(this.__name, this.__ordinal, String message) {
     this._message = message;
   }
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
   String get message => _message;
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
   bool needsRecompilation() => true;
   String toString() => __name;
 }
 /**
  * Instances of the class {@code TokenWithComment} represent a string token that is preceded by
  * comments.
+ * @coverage dart.engine.parser
  */
 class StringTokenWithComment extends StringToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   StringTokenWithComment(TokenType type, String value, int offset, Token precedingComment) : super(type, value, offset) {
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * The enumeration {@code Keyword} defines the keywords in the Dart programming language.
+ * @coverage dart.engine.parser
  */
 class Keyword {
   static final Keyword ASSERT = new Keyword.con1('ASSERT', 0, "assert");
   static final Keyword BREAK = new Keyword.con1('BREAK', 1, "break");
   static final Keyword CASE = new Keyword.con1('CASE', 2, "case");
   static final Keyword CATCH = new Keyword.con1('CATCH', 3, "catch");
   static final Keyword CLASS = new Keyword.con1('CLASS', 4, "class");
   static final Keyword CONST = new Keyword.con1('CONST', 5, "const");
   static final Keyword CONTINUE = new Keyword.con1('CONTINUE', 6, "continue");
   static final Keyword DEFAULT = new Keyword.con1('DEFAULT', 7, "default");
@@ skipping 31 matching lines @@
   static final Keyword IMPORT = new Keyword.con2('IMPORT', 39, "import", true);
   static final Keyword LIBRARY = new Keyword.con2('LIBRARY', 40, "library", true);
   static final Keyword OPERATOR = new Keyword.con2('OPERATOR', 41, "operator", true);
   static final Keyword PART = new Keyword.con2('PART', 42, "part", true);
   static final Keyword SET = new Keyword.con2('SET', 43, "set", true);
   static final Keyword STATIC = new Keyword.con2('STATIC', 44, "static", true);
   static final Keyword TYPEDEF = new Keyword.con2('TYPEDEF', 45, "typedef", true);
   static final List<Keyword> values = [ASSERT, BREAK, CASE, CATCH, CLASS, CONST, CONTINUE, DEFAULT, DO, ELSE, EXTENDS, FALSE, FINAL, FINALLY, FOR, IF, IN, IS, NEW, NULL, RETURN, SUPER, SWITCH, THIS, THROW, TRUE, TRY, VAR, VOID, WHILE, WITH, ABSTRACT, AS, DYNAMIC, EXPORT, EXTERNAL, FACTORY, GET, IMPLEMENTS, IMPORT, LIBRARY, OPERATOR, PART, SET, STATIC, TYPEDEF];
   String __name;
   int __ordinal = 0;
+  int get ordinal => __ordinal;
   /**
    * The lexeme for the keyword.
    */
   String _syntax;
   /**
    * A flag indicating whether the keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    */
   bool _isPseudoKeyword2 = false;
   /**
@@ skipping 10 matching lines @@
       result[keyword._syntax] = keyword;
     }
     return result;
   }
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is not a
    * pseudo-keyword.
    * @param syntax the lexeme for the keyword
    */
   Keyword.con1(String ___name, int ___ordinal, String syntax) {
-    _jtd_constructor_259_impl(___name, ___ordinal, syntax);
+    _jtd_constructor_265_impl(___name, ___ordinal, syntax);
   }
-  _jtd_constructor_259_impl(String ___name, int ___ordinal, String syntax) {
-    _jtd_constructor_260_impl(___name, ___ordinal, syntax, false);
+  _jtd_constructor_265_impl(String ___name, int ___ordinal, String syntax) {
+    _jtd_constructor_266_impl(___name, ___ordinal, syntax, false);
   }
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is a pseudo-keyword if
    * the given flag is {@code true}.
    * @param syntax the lexeme for the keyword
    * @param isPseudoKeyword {@code true} if this keyword is a pseudo-keyword
    */
   Keyword.con2(String ___name, int ___ordinal, String syntax2, bool isPseudoKeyword) {
-    _jtd_constructor_260_impl(___name, ___ordinal, syntax2, isPseudoKeyword);
+    _jtd_constructor_266_impl(___name, ___ordinal, syntax2, isPseudoKeyword);
   }
-  _jtd_constructor_260_impl(String ___name, int ___ordinal, String syntax2, bool isPseudoKeyword) {
+  _jtd_constructor_266_impl(String ___name, int ___ordinal, String syntax2, bool isPseudoKeyword) {
     __name = ___name;
     __ordinal = ___ordinal;
     this._syntax = syntax2;
     this._isPseudoKeyword2 = isPseudoKeyword;
   }
   /**
    * Return the lexeme for the keyword.
    * @return the lexeme for the keyword
    */
   String get syntax => _syntax;
   /**
    * Return {@code true} if this keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    * @return {@code true} if this keyword is a pseudo-keyword
    */
   bool isPseudoKeyword() => _isPseudoKeyword2;
   String toString() => __name;
 }
 /**
  * The abstract class {@code AbstractScanner} implements a scanner for Dart code. Subclasses are
  * required to implement the interface used to access the characters being scanned.
  * <p>
  * The lexical structure of Dart is ambiguous without knowledge of the context in which a token is
  * being scanned. For example, without context we cannot determine whether source of the form "<<"
  * should be scanned as a single left-shift operator or as two left angle brackets. This scanner
  * does not have any context, so it always resolves such conflicts by scanning the longest possible
  * token.
+ * @coverage dart.engine.parser
  */
 abstract class AbstractScanner {
   /**
    * The source being scanned.
    */
   Source _source;
   /**
    * The error listener that will be informed of any errors that are found during the scan.
    */
   AnalysisErrorListener _errorListener;
@@ skipping 116 matching lines @@
     _groupingStack.add(token);
   }
   void appendCommentToken(TokenType type, String value) {
     if (_firstComment == null) {
       _firstComment = new StringToken(type, value, _tokenStart);
       _lastComment = _firstComment;
     } else {
       _lastComment = _lastComment.setNext(new StringToken(type, value, _tokenStart));
     }
   }
-  void appendEndToken(TokenType type31, TokenType beginType) {
+  void appendEndToken(TokenType type32, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
-      token = new Token(type31, _tokenStart);
+      token = new Token(type32, _tokenStart);
     } else {
-      token = new TokenWithComment(type31, _tokenStart, _firstComment);
+      token = new TokenWithComment(type32, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     _tail = _tail.setNext(token);
     int last = _groupingStack.length - 1;
     if (last >= 0) {
       BeginToken begin = _groupingStack[last];
       if (identical(begin.type, beginType)) {
         begin.endToken = token;
         _groupingStack.removeAt(last);
@@ skipping 743 matching lines @@
       return select(0x3D, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
     } else {
       appendToken(TokenType.TILDE);
       return next;
     }
   }
 }
 /**
  * Instances of the class {@code StringToken} represent a token whose value is independent of it's
  * type.
+ * @coverage dart.engine.parser
  */
 class StringToken extends Token {
   /**
    * The lexeme represented by this token.
    */
   String _value2;
   /**
    * Initialize a newly created token to represent a token of the given type with the given value.
    * @param type the type of the token
    * @param value the lexeme represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   StringToken(TokenType type, String value, int offset) : super(type, offset) {
     this._value2 = value;
   }
   String get lexeme => _value2;
   String value() => _value2;
 }
 /**
  * Instances of the class {@code CharBufferScanner} implement a scanner that reads from a character
  * buffer. The scanning logic is in the superclass.
+ * @coverage dart.engine.parser
  */
 class CharBufferScanner extends AbstractScanner {
   /**
    * The buffer from which characters will be read.
    */
   CharBuffer _buffer;
   /**
    * The number of characters in the buffer.
    */
   int _bufferLength = 0;
@@ skipping 23 matching lines @@
   int peek() {
     if (_charOffset + 1 >= _buffer.length()) {
       return -1;
     }
     return _buffer.charAt(_charOffset + 1);
   }
 }
 /**
  * Instances of the class {@code TokenWithComment} represent a normal token that is preceded by
  * comments.
+ * @coverage dart.engine.parser
  */
 class TokenWithComment extends Token {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   TokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * Instances of the class {@code Token} represent a token that was scanned from the input. Each
  * token knows which token follows it, acting as the head of a linked list of tokens.
+ * @coverage dart.engine.parser
  */
 class Token {
   /**
    * The type of the token.
    */
   TokenType _type;
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
   int _offset = 0;
@@ skipping 115 matching lines @@
    * Set the previous token in the token stream to the given token.
    * @param previous the previous token in the token stream
    */
   void set previous(Token previous3) {
     this._previous = previous3;
   }
 }
 /**
  * Instances of the class {@code StringScanner} implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
+ * @coverage dart.engine.parser
  */
 class StringScanner extends AbstractScanner {
   /**
    * The offset from the beginning of the file to the beginning of the source being scanned.
    */
   int _offsetDelta = 0;
   /**
    * The string from which characters will be read.
    */
   String _string;
@@ skipping 52 matching lines @@
   int peek() {
     if (_charOffset + 1 >= _string.length) {
       return -1;
     }
     return _string.codeUnitAt(_charOffset + 1);
   }
 }
 /**
  * Instances of the class {@code BeginTokenWithComment} represent a begin token that is preceded by
  * comments.
+ * @coverage dart.engine.parser
  */
 class BeginTokenWithComment extends BeginToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   BeginTokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * Instances of the class {@code KeywordToken} represent a keyword in the language.
+ * @coverage dart.engine.parser
  */
 class KeywordToken extends Token {
   /**
    * The keyword being represented by this token.
    */
   Keyword _keyword;
   /**
    * Initialize a newly created token to represent the given keyword.
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   KeywordToken(Keyword keyword, int offset) : super(TokenType.KEYWORD, offset) {
     this._keyword = keyword;
   }
   /**
    * Return the keyword being represented by this token.
    * @return the keyword being represented by this token
    */
   Keyword get keyword => _keyword;
   String get lexeme => _keyword.syntax;
   Keyword value() => _keyword;
 }
 /**
  * Instances of the class {@code BeginToken} represent the opening half of a grouping pair of
  * tokens. This is used for curly brackets ('{'), parentheses ('('), and square brackets ('[').
+ * @coverage dart.engine.parser
  */
 class BeginToken extends Token {
   /**
    * The token that corresponds to this token.
    */
   Token _endToken;
   /**
    * Initialize a newly created token representing the opening half of a grouping pair of tokens.
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   BeginToken(TokenType type, int offset) : super(type, offset) {
     assert((identical(type, TokenType.OPEN_CURLY_BRACKET) || identical(type, TokenType.OPEN_PAREN) || identical(type, TokenType.OPEN_SQUARE_BRACKET) || identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)));
   }
   /**
    * Return the token that corresponds to this token.
    * @return the token that corresponds to this token
    */
   Token get endToken => _endToken;
   /**
    * Set the token that corresponds to this token to the given token.
    * @param token the token that corresponds to this token
    */
   void set endToken(Token token) {
     this._endToken = token;
   }
 }
 /**
  * The enumeration {@code TokenClass} represents classes (or groups) of tokens with a similar use.
+ * @coverage dart.engine.parser
  */
 class TokenClass {
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
   static final TokenClass NO_CLASS = new TokenClass.con1('NO_CLASS', 0);
   /**
    * A value used to indicate that the token type is an additive operator.
    */
   static final TokenClass ADDITIVE_OPERATOR = new TokenClass.con2('ADDITIVE_OPERATOR', 1, 12);
@@ skipping 49 matching lines @@
    * A value used to indicate that the token type is a unary operator.
    */
   static final TokenClass UNARY_POSTFIX_OPERATOR = new TokenClass.con2('UNARY_POSTFIX_OPERATOR', 14, 15);
   /**
    * A value used to indicate that the token type is a unary operator.
    */
   static final TokenClass UNARY_PREFIX_OPERATOR = new TokenClass.con2('UNARY_PREFIX_OPERATOR', 15, 14);
   static final List<TokenClass> values = [NO_CLASS, ADDITIVE_OPERATOR, ASSIGNMENT_OPERATOR, BITWISE_AND_OPERATOR, BITWISE_OR_OPERATOR, BITWISE_XOR_OPERATOR, CASCADE_OPERATOR, CONDITIONAL_OPERATOR, EQUALITY_OPERATOR, LOGICAL_AND_OPERATOR, LOGICAL_OR_OPERATOR, MULTIPLICATIVE_OPERATOR, RELATIONAL_OPERATOR, SHIFT_OPERATOR, UNARY_POSTFIX_OPERATOR, UNARY_PREFIX_OPERATOR];
   String __name;
   int __ordinal = 0;
+  int get ordinal => __ordinal;
   /**
    * The precedence of tokens of this class, or {@code 0} if the such tokens do not represent an
    * operator.
    */
   int _precedence = 0;
   TokenClass.con1(String ___name, int ___ordinal) {
-    _jtd_constructor_269_impl(___name, ___ordinal);
+    _jtd_constructor_275_impl(___name, ___ordinal);
   }
-  _jtd_constructor_269_impl(String ___name, int ___ordinal) {
-    _jtd_constructor_270_impl(___name, ___ordinal, 0);
+  _jtd_constructor_275_impl(String ___name, int ___ordinal) {
+    _jtd_constructor_276_impl(___name, ___ordinal, 0);
   }
   TokenClass.con2(String ___name, int ___ordinal, int precedence2) {
-    _jtd_constructor_270_impl(___name, ___ordinal, precedence2);
+    _jtd_constructor_276_impl(___name, ___ordinal, precedence2);
   }
-  _jtd_constructor_270_impl(String ___name, int ___ordinal, int precedence2) {
+  _jtd_constructor_276_impl(String ___name, int ___ordinal, int precedence2) {
     __name = ___name;
     __ordinal = ___ordinal;
     this._precedence = precedence2;
   }
   /**
    * Return the precedence of tokens of this class, or {@code 0} if the such tokens do not represent
    * an operator.
    * @return the precedence of tokens of this class
    */
   int get precedence => _precedence;
   String toString() => __name;
 }
 /**
  * Instances of the class {@code KeywordTokenWithComment} implement a keyword token that is preceded
  * by comments.
+ * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
   /**
    * Initialize a newly created token to to represent the given keyword and to be preceded by the
    * comments reachable from the given comment.
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   KeywordTokenWithComment(Keyword keyword, int offset, Token precedingComment) : super(keyword, offset) {
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * The enumeration {@code TokenType} defines the types of tokens that can be returned by the
  * scanner.
+ * @coverage dart.engine.parser
  */
 class TokenType {
   /**
    * The type of the token that marks the end of the input.
    */
   static final TokenType EOF = new TokenType_EOF('EOF', 0, null, "");
   static final TokenType DOUBLE = new TokenType.con1('DOUBLE', 1);
   static final TokenType HEXADECIMAL = new TokenType.con1('HEXADECIMAL', 2);
   static final TokenType IDENTIFIER = new TokenType.con1('IDENTIFIER', 3);
   static final TokenType INT = new TokenType.con1('INT', 4);
@@ skipping 56 matching lines @@
   static final TokenType STRING_INTERPOLATION_IDENTIFIER = new TokenType.con2('STRING_INTERPOLATION_IDENTIFIER', 61, null, "\$");
   static final TokenType TILDE = new TokenType.con2('TILDE', 62, TokenClass.UNARY_PREFIX_OPERATOR, "~");
   static final TokenType TILDE_SLASH = new TokenType.con2('TILDE_SLASH', 63, TokenClass.MULTIPLICATIVE_OPERATOR, "~/");
   static final TokenType TILDE_SLASH_EQ = new TokenType.con2('TILDE_SLASH_EQ', 64, TokenClass.ASSIGNMENT_OPERATOR, "~/=");
   static final TokenType BACKPING = new TokenType.con2('BACKPING', 65, null, "`");
   static final TokenType BACKSLASH = new TokenType.con2('BACKSLASH', 66, null, "\\");
   static final TokenType PERIOD_PERIOD_PERIOD = new TokenType.con2('PERIOD_PERIOD_PERIOD', 67, null, "...");
   static final List<TokenType> values = [EOF, DOUBLE, HEXADECIMAL, IDENTIFIER, INT, KEYWORD, MULTI_LINE_COMMENT, SCRIPT_TAG, SINGLE_LINE_COMMENT, STRING, AMPERSAND, AMPERSAND_AMPERSAND, AMPERSAND_EQ, AT, BANG, BANG_EQ, BAR, BAR_BAR, BAR_EQ, COLON, COMMA, CARET, CARET_EQ, CLOSE_CURLY_BRACKET, CLOSE_PAREN, CLOSE_SQUARE_BRACKET, EQ, EQ_EQ, FUNCTION, GT, GT_EQ, GT_GT, GT_GT_EQ, HASH, INDEX, INDEX_EQ, IS, LT, LT_EQ, LT_LT, LT_LT_EQ, MINUS, MINUS_EQ, MINUS_MINUS, OPEN_CURLY_BRACKET, OPEN_PAREN, OPEN_SQUARE_BRACKET, PERCENT, PERCENT_EQ, PERIOD, PERIOD_PERIOD, PLUS, PLUS_EQ, PLUS_PLUS, QUESTION, SEMICOLON, SLASH, SLASH_EQ, STAR, STAR_EQ, STRING_INTERPOLATION_EXPRESSION, STRING_INTERPOLATION_IDENTIFIER, TILDE, TILDE_SLASH, TILDE_SLASH_EQ, BACKPING, BACKSLASH, PERIOD_PERIOD_PERIOD];
   String __name;
   int __ordinal = 0;
+  int get ordinal => __ordinal;
   /**
    * The class of the token.
    */
   TokenClass _tokenClass;
   /**
    * The lexeme that defines this type of token, or {@code null} if there is more than one possible
    * lexeme for this type of token.
    */
   String _lexeme;
   TokenType.con1(String ___name, int ___ordinal) {
-    _jtd_constructor_271_impl(___name, ___ordinal);
+    _jtd_constructor_277_impl(___name, ___ordinal);
   }
-  _jtd_constructor_271_impl(String ___name, int ___ordinal) {
-    _jtd_constructor_272_impl(___name, ___ordinal, TokenClass.NO_CLASS, null);
+  _jtd_constructor_277_impl(String ___name, int ___ordinal) {
+    _jtd_constructor_278_impl(___name, ___ordinal, TokenClass.NO_CLASS, null);
   }
   TokenType.con2(String ___name, int ___ordinal, TokenClass tokenClass2, String lexeme2) {
-    _jtd_constructor_272_impl(___name, ___ordinal, tokenClass2, lexeme2);
+    _jtd_constructor_278_impl(___name, ___ordinal, tokenClass2, lexeme2);
   }
-  _jtd_constructor_272_impl(String ___name, int ___ordinal, TokenClass tokenClass2, String lexeme2) {
+  _jtd_constructor_278_impl(String ___name, int ___ordinal, TokenClass tokenClass2, String lexeme2) {
     __name = ___name;
     __ordinal = ___ordinal;
     this._tokenClass = tokenClass2 == null ? TokenClass.NO_CLASS : tokenClass2;
     this._lexeme = lexeme2;
   }
   /**
    * Return the lexeme that defines this type of token, or {@code null} if there is more than one
    * possible lexeme for this type of token.
    * @return the lexeme that defines this type of token
    */
@@ skipping 68 matching lines @@
    * Return {@code true} if this token type represents an operator that can be defined by users.
    * @return {@code true} if this token type represents an operator that can be defined by users
    */
   bool isUserDefinableOperator() => identical(_lexeme, "==") || identical(_lexeme, "~") || identical(_lexeme, "[]") || identical(_lexeme, "[]=") || identical(_lexeme, "*") || identical(_lexeme, "/") || identical(_lexeme, "%") || identical(_lexeme, "~/") || identical(_lexeme, "+") || identical(_lexeme, "-") || identical(_lexeme, "<<") || identical(_lexeme, ">>") || identical(_lexeme, ">=") || identical(_lexeme, ">") || identical(_lexeme, "<=") || identical(_lexeme, "<") || identical(_lexeme, "&") || identical(_lexeme, "^") || identical(_lexeme, "|");
   String toString() => __name;
 }
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String ___name, int ___ordinal, TokenClass arg0, String arg1) : super.con2(___name, ___ordinal, arg0, arg1);
   String toString() => "-eof-";
 }