New analyzer snapshot.

pkg/analyzer/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 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
@@ skipping 145 matching lines @@
       ILLEGAL_CHARACTER,
       MISSING_DIGIT,
       MISSING_HEX_DIGIT,
       MISSING_QUOTE,
       UNTERMINATED_MULTI_LINE_COMMENT,
       UNTERMINATED_STRING_LITERAL];
 
   /**
    * The template used to create the message to be displayed for this error.
    */
-  String _message;
+  final String message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
   String correction10;
 
   /**
    * 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.con1(String name, int ordinal, String message) : super(name, ordinal) {
-    this._message = message;
-  }
+  ScannerErrorCode.con1(String name, int ordinal, this.message) : super(name, ordinal);
 
   /**
    * Initialize a newly created error code to have the given message and correction.
    *
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
-  ScannerErrorCode.con2(String name, int ordinal, String message, String correction) : super(name, ordinal) {
-    this._message = message;
+  ScannerErrorCode.con2(String name, int ordinal, this.message, String correction) : super(name, ordinal) {
     this.correction10 = correction;
   }
 
   String get correction => correction10;
 
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
-  String get message => _message;
-
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
 
 /**
  * Instances of the class `SubSequenceReader` implement a [CharacterReader] that reads
  * characters from a character sequence, but adds a delta when reporting the current character
  * offset so that the character sequence can be a subsequence from a larger sequence.
  */
 class SubSequenceReader extends CharSequenceReader {
   /**
@@ skipping 207 matching lines @@
       LIBRARY,
       OPERATOR,
       PART,
       SET,
       STATIC,
       TYPEDEF];
 
   /**
    * The lexeme for the keyword.
    */
-  String syntax;
+  String _syntax;
 
   /**
    * A flag indicating whether the keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    */
-  bool isPseudoKeyword = false;
+  bool _isPseudoKeyword2 = false;
 
   /**
    * A table mapping the lexemes of keywords to the corresponding keyword.
    */
   static Map<String, Keyword> keywords = createKeywordMap();
 
   /**
    * Create a table mapping the lexemes of keywords to the corresponding keyword.
    *
    * @return the table that was created
    */
   static Map<String, Keyword> createKeywordMap() {
     LinkedHashMap<String, Keyword> result = new LinkedHashMap<String, Keyword>();
     for (Keyword keyword in values) {
-      result[keyword.syntax] = keyword;
+      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) : this.con2(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 `true`.
    *
    * @param syntax the lexeme for the keyword
    * @param isPseudoKeyword `true` if this keyword is a pseudo-keyword
    */
   Keyword.con2(String name, int ordinal, String syntax, bool isPseudoKeyword) : super(name, ordinal) {
-    this.syntax = syntax;
-    this.isPseudoKeyword = isPseudoKeyword;
+    this._syntax = syntax;
+    this._isPseudoKeyword2 = isPseudoKeyword;
   }
+
+  /**
+   * Return the lexeme for the keyword.
+   *
+   * @return the lexeme for the keyword
+   */
+  String get syntax => _syntax;
+
+  /**
+   * Return `true` if this keyword is a pseudo-keyword. Pseudo keywords can be used as
+   * identifiers.
+   *
+   * @return `true` if this keyword is a pseudo-keyword
+   */
+  bool get isPseudoKeyword => _isPseudoKeyword2;
 }
 
 /**
  * Instances of the class `CharSequenceReader` implement a [CharacterReader] that reads
  * characters from a character sequence.
  */
 class CharSequenceReader implements CharacterReader {
   /**
    * The sequence from which characters will be read.
    */
@@ skipping 69 matching lines @@
  */
 class IncrementalScanner extends Scanner {
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
   /**
    * A map from tokens that were copied to the copies of the tokens.
    */
-  final TokenMap tokenMap = new TokenMap();
+  TokenMap _tokenMap = new TokenMap();
 
   /**
    * The token in the new token stream immediately to the left of the range of tokens that were
    * inserted, or the token immediately to the left of the modified region if there were no new
    * tokens.
    */
-  Token leftToken;
+  Token _leftToken;
 
   /**
    * The token in the new token stream immediately to the right of the range of tokens that were
    * inserted, or the token immediately to the right of the modified region if there were no new
    * tokens.
    */
-  Token rightToken;
+  Token _rightToken;
 
   /**
    * A flag indicating whether there were any tokens changed as a result of the modification.
    */
   bool _hasNonWhitespaceChange2 = false;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    * @param reader the character reader used to read the characters in the source
    * @param errorListener the error listener that will be informed of any errors that are found
    */
   IncrementalScanner(Source source, CharacterReader reader, AnalysisErrorListener errorListener) : super(source, reader, errorListener) {
     this._reader = reader;
   }
 
   /**
+   * Return the token in the new token stream immediately to the left of the range of tokens that
+   * were inserted, or the token immediately to the left of the modified region if there were no new
+   * tokens.
+   *
+   * @return the token to the left of the inserted tokens
+   */
+  Token get leftToken => _leftToken;
+
+  /**
+   * Return the token in the new token stream immediately to the right of the range of tokens that
+   * were inserted, or the token immediately to the right of the modified region if there were no
+   * new tokens.
+   *
+   * @return the token to the right of the inserted tokens
+   */
+  Token get rightToken => _rightToken;
+
+  /**
+   * Return a map from tokens that were copied to the copies of the tokens.
+   *
+   * @return a map from tokens that were copied to the copies of the tokens
+   */
+  TokenMap get tokenMap => _tokenMap;
+
+  /**
    * Return `true` if there were any tokens either added or removed (or both) as a result of
    * the modification.
    *
    * @return `true` if there were any tokens changed as a result of the modification
    */
   bool hasNonWhitespaceChange() => _hasNonWhitespaceChange2;
 
   /**
    * Given the stream of tokens scanned from the original source, the modified source (the result of
    * replacing one contiguous range of characters with another string of characters), and a
    * specification of the modification that was made, return a stream of tokens scanned from the
    * modified source. The original stream of tokens will not be modified.
    *
    * @param originalStream the stream of tokens scanned from the original source
    * @param index the index of the first character in both the original and modified source that was
    *          affected by the modification
    * @param removedLength the number of characters removed from the original source
    * @param insertedLength the number of characters added to the modified source
    */
   Token rescan(Token originalStream, int index, int removedLength, int insertedLength) {
     while (originalStream.type != TokenType.EOF && originalStream.end < index) {
       originalStream = copyAndAdvance(originalStream, 0);
     }
     Token oldFirst = originalStream;
     Token oldLeftToken = originalStream.previous;
-    leftToken = tail;
+    _leftToken = tail;
     int removedEnd = index + (removedLength == 0 ? 0 : removedLength - 1);
     while (originalStream.type != TokenType.EOF && originalStream.offset <= removedEnd) {
       originalStream = originalStream.next;
     }
     Token oldLast;
     Token oldRightToken;
     if (originalStream.type != TokenType.EOF && removedEnd + 1 == originalStream.offset) {
       oldLast = originalStream;
       originalStream = originalStream.next;
       oldRightToken = originalStream;
     } else {
       oldLast = originalStream.previous;
       oldRightToken = originalStream;
     }
     int delta = insertedLength - removedLength;
     int scanStart = Math.min(oldFirst.offset, index);
     int oldEnd = oldLast.end + delta - 1;
     int newEnd = index + insertedLength - 1;
     int scanEnd = Math.max(newEnd, oldEnd);
     _reader.offset = scanStart - 1;
     int next = _reader.advance();
     while (next != -1 && _reader.offset <= scanEnd) {
       next = bigSwitch(next);
     }
     if (identical(originalStream.type, TokenType.EOF)) {
       copyAndAdvance(originalStream, delta);
-      rightToken = tail;
-      rightToken.setNextWithoutSettingPrevious(rightToken);
+      _rightToken = tail;
+      _rightToken.setNextWithoutSettingPrevious(_rightToken);
     } else {
       originalStream = copyAndAdvance(originalStream, delta);
-      rightToken = tail;
+      _rightToken = tail;
       while (originalStream.type != TokenType.EOF) {
         originalStream = copyAndAdvance(originalStream, delta);
       }
       Token eof = copyAndAdvance(originalStream, delta);
       eof.setNextWithoutSettingPrevious(eof);
     }
-    Token newFirst = leftToken.next;
-    while (newFirst != rightToken && oldFirst != oldRightToken && newFirst.type != TokenType.EOF && equals3(oldFirst, newFirst)) {
-      tokenMap.put(oldFirst, newFirst);
+    Token newFirst = _leftToken.next;
+    while (newFirst != _rightToken && oldFirst != oldRightToken && newFirst.type != TokenType.EOF && equals3(oldFirst, newFirst)) {
+      _tokenMap.put(oldFirst, newFirst);
       oldLeftToken = oldFirst;
       oldFirst = oldFirst.next;
-      leftToken = newFirst;
+      _leftToken = newFirst;
       newFirst = newFirst.next;
     }
-    Token newLast = rightToken.previous;
-    while (newLast != leftToken && oldLast != oldLeftToken && newLast.type != TokenType.EOF && equals3(oldLast, newLast)) {
-      tokenMap.put(oldLast, newLast);
+    Token newLast = _rightToken.previous;
+    while (newLast != _leftToken && oldLast != oldLeftToken && newLast.type != TokenType.EOF && equals3(oldLast, newLast)) {
+      _tokenMap.put(oldLast, newLast);
       oldRightToken = oldLast;
       oldLast = oldLast.previous;
-      rightToken = newLast;
+      _rightToken = newLast;
       newLast = newLast.previous;
     }
-    _hasNonWhitespaceChange2 = leftToken.next != rightToken || oldLeftToken.next != oldRightToken;
+    _hasNonWhitespaceChange2 = _leftToken.next != _rightToken || oldLeftToken.next != oldRightToken;
     return firstToken;
   }
 
   Token copyAndAdvance(Token originalToken, int delta) {
     Token copiedToken = originalToken.copy();
-    tokenMap.put(originalToken, copiedToken);
+    _tokenMap.put(originalToken, copiedToken);
     copiedToken.applyDelta(delta);
     appendToken(copiedToken);
     Token originalComment = originalToken.precedingComments;
     Token copiedComment = originalToken.precedingComments;
     while (originalComment != null) {
-      tokenMap.put(originalComment, copiedComment);
+      _tokenMap.put(originalComment, copiedComment);
       originalComment = originalComment.next;
       copiedComment = copiedComment.next;
     }
     return originalToken.next;
   }
 
   /**
    * Return `true` if the two tokens are equal to each other. For the purposes of the
    * incremental scanner, two tokens are equal if they have the same type and lexeme.
    *
@@ skipping 12 matching lines @@
  * 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
  */
 class Scanner {
   /**
    * The source being scanned.
    */
-  Source source;
+  final Source source;
 
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
   /**
    * The error listener that will be informed of any errors that are found during the scan.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The flag specifying if documentation comments should be parsed.
    */
   bool _preserveComments = true;
 
   /**
    * The token pointing to the head of the linked list of tokens.
    */
   Token _tokens;
 
   /**
    * The last token that was scanned.
    */
-  Token tail;
+  Token _tail;
 
   /**
    * The first token in the list of comment tokens found since the last non-comment token.
    */
   Token _firstComment;
 
   /**
    * The last token in the list of comment tokens found since the last non-comment token.
    */
   Token _lastComment;
@@ skipping 24 matching lines @@
    */
   bool _hasUnmatchedGroups2 = false;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    * @param reader the character reader used to read the characters in the source
    * @param errorListener the error listener that will be informed of any errors that are found
    */
-  Scanner(Source source, CharacterReader reader, AnalysisErrorListener errorListener) {
-    this.source = source;
+  Scanner(this.source, CharacterReader reader, AnalysisErrorListener errorListener) {
     this._reader = reader;
     this._errorListener = errorListener;
     _tokens = new Token(TokenType.EOF, -1);
     _tokens.setNext(_tokens);
-    tail = _tokens;
+    _tail = _tokens;
     _tokenStart = -1;
     _lineStarts.add(0);
   }
 
   /**
    * Return an array containing the offsets of the first character of each line in the source code.
    *
    * @return an array containing the offsets of the first character of each line in the source code
    */
   List<int> get lineStarts => _lineStarts;
@@ skipping 59 matching lines @@
   }
 
   /**
    * Append the given token to the end of the token stream being scanned. This method is intended to
    * be used by subclasses that copy existing tokens and should not normally be used because it will
    * fail to correctly associate any comments with the token being passed in.
    *
    * @param token the token to be appended
    */
   void appendToken(Token token) {
-    tail = tail.setNext(token);
+    _tail = _tail.setNext(token);
   }
 
   int bigSwitch(int next) {
     beginToken();
     if (next == 0xD) {
       next = _reader.advance();
       if (next == 0xA) {
         next = _reader.advance();
       }
       recordStartOfLine();
@@ skipping 131 matching lines @@
   }
 
   /**
    * Return the first token in the token stream that was scanned.
    *
    * @return the first token in the token stream that was scanned
    */
   Token get firstToken => _tokens.next;
 
   /**
+   * Return the last token that was scanned.
+   *
+   * @return the last token that was scanned
+   */
+  Token get tail => _tail;
+
+  /**
    * Record the fact that we are at the beginning of a new line in the source.
    */
   void recordStartOfLine() {
     _lineStarts.add(_reader.offset);
   }
 
   void appendBeginToken(TokenType type) {
     BeginToken token;
     if (_firstComment == null) {
       token = new BeginToken(type, _tokenStart);
     } else {
       token = new BeginTokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
-    tail = tail.setNext(token);
+    _tail = _tail.setNext(token);
     _groupingStack.add(token);
     _stackEnd++;
   }
 
   void appendCommentToken(TokenType type, String value) {
     if (!_preserveComments) {
       return;
     }
     if (_firstComment == null) {
       _firstComment = new StringToken(type, value, _tokenStart);
       _lastComment = _firstComment;
     } else {
       _lastComment = _lastComment.setNext(new StringToken(type, value, _tokenStart));
     }
   }
 
   void appendEndToken(TokenType type, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
       token = new Token(type, _tokenStart);
     } else {
       token = new TokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
-    tail = tail.setNext(token);
+    _tail = _tail.setNext(token);
     if (_stackEnd >= 0) {
       BeginToken begin = _groupingStack[_stackEnd];
       if (identical(begin.type, beginType)) {
         begin.endToken = token;
         _groupingStack.removeAt(_stackEnd--);
       }
     }
   }
 
   void appendEofToken() {
     Token eofToken;
     if (_firstComment == null) {
       eofToken = new Token(TokenType.EOF, _reader.offset + 1);
     } else {
       eofToken = new TokenWithComment(TokenType.EOF, _reader.offset + 1, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     eofToken.setNext(eofToken);
-    tail = tail.setNext(eofToken);
+    _tail = _tail.setNext(eofToken);
     if (_stackEnd >= 0) {
       _hasUnmatchedGroups2 = true;
     }
   }
 
   void appendKeywordToken(Keyword keyword) {
     if (_firstComment == null) {
-      tail = tail.setNext(new KeywordToken(keyword, _tokenStart));
+      _tail = _tail.setNext(new KeywordToken(keyword, _tokenStart));
     } else {
-      tail = tail.setNext(new KeywordTokenWithComment(keyword, _tokenStart, _firstComment));
+      _tail = _tail.setNext(new KeywordTokenWithComment(keyword, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void appendStringToken(TokenType type, String value) {
     if (_firstComment == null) {
-      tail = tail.setNext(new StringToken(type, value, _tokenStart));
+      _tail = _tail.setNext(new StringToken(type, value, _tokenStart));
     } else {
-      tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart, _firstComment));
+      _tail = _tail.setNext(new StringTokenWithComment(type, value, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void appendStringToken2(TokenType type, String value, int offset) {
     if (_firstComment == null) {
-      tail = tail.setNext(new StringToken(type, value, _tokenStart + offset));
+      _tail = _tail.setNext(new StringToken(type, value, _tokenStart + offset));
     } else {
-      tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart + offset, _firstComment));
+      _tail = _tail.setNext(new StringTokenWithComment(type, value, _tokenStart + offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void appendToken2(TokenType type) {
     if (_firstComment == null) {
-      tail = tail.setNext(new Token(type, _tokenStart));
+      _tail = _tail.setNext(new Token(type, _tokenStart));
     } else {
-      tail = tail.setNext(new TokenWithComment(type, _tokenStart, _firstComment));
+      _tail = _tail.setNext(new TokenWithComment(type, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void appendToken3(TokenType type, int offset) {
     if (_firstComment == null) {
-      tail = tail.setNext(new Token(type, offset));
+      _tail = _tail.setNext(new Token(type, offset));
     } else {
-      tail = tail.setNext(new TokenWithComment(type, offset, _firstComment));
+      _tail = _tail.setNext(new TokenWithComment(type, offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void beginToken() {
     _tokenStart = _reader.offset;
   }
 
   /**
@@ skipping 667 matching lines @@
 /**
  * Instances of the class `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;
+  final TokenType type;
 
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
   int offset = 0;
 
   /**
    * The previous token in the token stream.
    */
   Token previous;
 
   /**
    * The next token in the token stream.
    */
-  Token next;
+  Token _next;
 
   /**
    * Initialize a newly created token to have the given type and offset.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
-  Token(TokenType type, int offset) {
-    this.type = type;
+  Token(this.type, int offset) {
     this.offset = offset;
   }
 
   /**
    * Return a newly created token that is a copy of this token but that is not a part of any token
    * stream.
    *
    * @return a newly created token that is a copy of this token
    */
   Token copy() => new Token(type, offset);
@@ skipping 15 matching lines @@
   int get length => lexeme.length;
 
   /**
    * Return the lexeme that represents this token.
    *
    * @return the lexeme that represents this token
    */
   String get lexeme => type.lexeme;
 
   /**
+   * Return the next token in the token stream.
+   *
+   * @return the next token in the token stream
+   */
+  Token get next => _next;
+
+  /**
    * Return the first comment in the list of comments that precede this token, or `null` if
    * there are no comments preceding this token. Additional comments can be reached by following the
    * token stream using [getNext] until `null` is returned.
    *
    * @return the first comment in the list of comments that precede this token
    */
   Token get precedingComments => null;
 
   /**
    * Return `true` if this token represents an operator.
@@ skipping 18 matching lines @@
   bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
   /**
    * Set the next token in the token stream to the given token. This has the side-effect of setting
    * this token to be the previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNext(Token token) {
-    next = token;
+    _next = token;
     token.previous = this;
     return token;
   }
 
   /**
    * Set the next token in the token stream to the given token without changing which token is the
    * previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNextWithoutSettingPrevious(Token token) {
-    next = token;
+    _next = token;
     return token;
   }
 
   String toString() => lexeme;
 
   /**
    * Return the value of this token. For keyword tokens, this is the keyword associated with the
    * token, for other tokens it is the lexeme associated with the token.
    *
    * @return the value of this token
@@ skipping 118 matching lines @@
 
 /**
  * Instances of the class `KeywordToken` represent a keyword in the language.
  *
  * @coverage dart.engine.parser
  */
 class KeywordToken extends Token {
   /**
    * The keyword being represented by this token.
    */
-  Keyword keyword;
+  final 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;
-  }
+  KeywordToken(this.keyword, int offset) : super(TokenType.KEYWORD, offset);
 
   Token copy() => new KeywordToken(keyword, offset);
 
   String get lexeme => keyword.syntax;
 
   Keyword value() => keyword;
 }
 
 /**
  * Instances of the class `BeginToken` represent the opening half of a grouping pair of
@@ skipping 121 matching lines @@
       MULTIPLICATIVE_OPERATOR,
       RELATIONAL_OPERATOR,
       SHIFT_OPERATOR,
       UNARY_POSTFIX_OPERATOR,
       UNARY_PREFIX_OPERATOR];
 
   /**
    * The precedence of tokens of this class, or `0` if the such tokens do not represent an
    * operator.
    */
-  int precedence = 0;
+  int _precedence = 0;
 
   TokenClass.con1(String name, int ordinal) : this.con2(name, ordinal, 0);
 
   TokenClass.con2(String name, int ordinal, int precedence) : super(name, ordinal) {
-    this.precedence = precedence;
+    this._precedence = precedence;
   }
+
+  /**
+   * Return the precedence of tokens of this class, or `0` if the such tokens do not represent
+   * an operator.
+   *
+   * @return the precedence of tokens of this class
+   */
+  int get precedence => _precedence;
 }
 
 /**
  * Instances of the class `KeywordTokenWithComment` implement a keyword token that is preceded
  * by comments.
  *
  * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
   /**
@@ skipping 245 matching lines @@
 
   /**
    * The class of the token.
    */
   TokenClass _tokenClass;
 
   /**
    * The lexeme that defines this type of token, or `null` if there is more than one possible
    * lexeme for this type of token.
    */
-  String lexeme;
+  String _lexeme;
 
   TokenType.con1(String name, int ordinal) : this.con2(name, ordinal, TokenClass.NO_CLASS, null);
 
   TokenType.con2(String name, int ordinal, TokenClass tokenClass, String lexeme) : super(name, ordinal) {
     this._tokenClass = tokenClass == null ? TokenClass.NO_CLASS : tokenClass;
-    this.lexeme = lexeme;
+    this._lexeme = lexeme;
   }
 
   /**
+   * Return the lexeme that defines this type of token, or `null` if there is more than one
+   * possible lexeme for this type of token.
+   *
+   * @return the lexeme that defines this type of token
+   */
+  String get lexeme => _lexeme;
+
+  /**
    * Return the precedence of the token, or `0` if the token does not represent an operator.
    *
    * @return the precedence of the token
    */
   int get precedence => _tokenClass.precedence;
 
   /**
    * Return `true` if this type of token represents an additive operator.
    *
    * @return `true` if this type of token represents an additive operator
@@ skipping 26 matching lines @@
    *
    * @return `true` if this type of token represents an equality operator
    */
   bool get isEqualityOperator => identical(_tokenClass, TokenClass.EQUALITY_OPERATOR);
 
   /**
    * Return `true` if this type of token represents an increment operator.
    *
    * @return `true` if this type of token represents an increment operator
    */
-  bool get isIncrementOperator => identical(lexeme, "++") || identical(lexeme, "--");
+  bool get isIncrementOperator => identical(_lexeme, "++") || identical(_lexeme, "--");
 
   /**
    * Return `true` if this type of token represents a multiplicative operator.
    *
    * @return `true` if this type of token represents a multiplicative operator
    */
   bool get isMultiplicativeOperator => identical(_tokenClass, TokenClass.MULTIPLICATIVE_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator.
@@ skipping 28 matching lines @@
    *
    * @return `true` if this type of token represents a unary prefix operator
    */
   bool get isUnaryPrefixOperator => identical(_tokenClass, TokenClass.UNARY_PREFIX_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator that can be defined by users.
    *
    * @return `true` if this token type represents an operator that can be defined by users
    */
-  bool get 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, "|");
+  bool get 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, "|");
 }
 
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
 
   String toString() => "-eof-";
 }