Fresh drop of analyzer-experimental.

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';
@@ skipping 74 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_215_impl(___name, ___ordinal, syntax);
+    _jtd_constructor_224_impl(___name, ___ordinal, syntax);
   }
-  _jtd_constructor_215_impl(String ___name, int ___ordinal, String syntax) {
-    _jtd_constructor_216_impl(___name, ___ordinal, syntax, false);
+  _jtd_constructor_224_impl(String ___name, int ___ordinal, String syntax) {
+    _jtd_constructor_225_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 syntax, bool isPseudoKeyword) {
-    _jtd_constructor_216_impl(___name, ___ordinal, syntax, isPseudoKeyword);
+  Keyword.con2(String ___name, int ___ordinal, String syntax2, bool isPseudoKeyword) {
+    _jtd_constructor_225_impl(___name, ___ordinal, syntax2, isPseudoKeyword);
   }
-  _jtd_constructor_216_impl(String ___name, int ___ordinal, String syntax, bool isPseudoKeyword) {
+  _jtd_constructor_225_impl(String ___name, int ___ordinal, String syntax2, bool isPseudoKeyword) {
     __name = ___name;
     __ordinal = ___ordinal;
-    this._syntax = syntax;
+    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.
@@ skipping 158 matching lines @@
    */
   bool 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;
-    token.previous2 = this;
+    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;
     return token;
   }
   /**
    * Set the offset from the beginning of the file to the first character in the token to the given
    * offset.
    * @param offset the offset from the beginning of the file to the first character in the token
    */
-  void set offset2(int offset) {
-    this._offset = offset;
+  void set offset(int offset3) {
+    this._offset = offset3;
   }
   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
    */
   Object value() => _type.lexeme;
   /**
    * Set the previous token in the token stream to the given token.
    * @param previous the previous token in the token stream
    */
-  void set previous2(Token previous) {
-    this._previous = previous;
+  void set previous(Token previous2) {
+    this._previous = previous2;
   }
 }
 /**
  * Instances of the class {@code KeywordToken} represent a keyword in the language.
  */
 class KeywordToken extends Token {
   /**
    * The keyword being represented by this token.
    */
   Keyword _keyword;
@@ skipping 168 matching lines @@
   /**
    * 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_227_impl(___name, ___ordinal);
+    _jtd_constructor_236_impl(___name, ___ordinal);
   }
-  _jtd_constructor_227_impl(String ___name, int ___ordinal) {
-    _jtd_constructor_228_impl(___name, ___ordinal, TokenClass.NO_CLASS, null);
+  _jtd_constructor_236_impl(String ___name, int ___ordinal) {
+    _jtd_constructor_237_impl(___name, ___ordinal, TokenClass.NO_CLASS, null);
   }
-  TokenType.con2(String ___name, int ___ordinal, TokenClass tokenClass, String lexeme) {
-    _jtd_constructor_228_impl(___name, ___ordinal, tokenClass, lexeme);
+  TokenType.con2(String ___name, int ___ordinal, TokenClass tokenClass2, String lexeme2) {
+    _jtd_constructor_237_impl(___name, ___ordinal, tokenClass2, lexeme2);
   }
-  _jtd_constructor_228_impl(String ___name, int ___ordinal, TokenClass tokenClass, String lexeme) {
+  _jtd_constructor_237_impl(String ___name, int ___ordinal, TokenClass tokenClass2, String lexeme2) {
     __name = ___name;
     __ordinal = ___ordinal;
-    this._tokenClass = tokenClass == null ? TokenClass.NO_CLASS : tokenClass;
-    this._lexeme = lexeme;
+    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
    */
   String get lexeme => _lexeme;
   /**
    * Return the precedence of the token, or {@code 0} if the token does not represent an operator.
    * @return the precedence of the token
    */
   int get precedence => _tokenClass.precedence;
   /**
    * Return {@code true} if this type of token represents an additive operator.
    * @return {@code true} if this type of token represents an additive operator
    */
-  bool isAdditiveOperator() => _tokenClass == TokenClass.ADDITIVE_OPERATOR;
+  bool isAdditiveOperator() => identical(_tokenClass, TokenClass.ADDITIVE_OPERATOR);
   /**
    * Return {@code true} if this type of token represents an assignment operator.
    * @return {@code true} if this type of token represents an assignment operator
    */
-  bool isAssignmentOperator() => _tokenClass == TokenClass.ASSIGNMENT_OPERATOR;
+  bool isAssignmentOperator() => identical(_tokenClass, TokenClass.ASSIGNMENT_OPERATOR);
+  /**
+   * Return {@code true} if this type of token represents an associative operator. An associative
+   * operator is an operator for which the following equality is true:{@code (a * b) * c == a * (b * c)}. In other words, if the result of applying the operator to
+   * multiple operands does not depend on the order in which those applications occur.
+   * <p>
+   * Note: This method considers the logical-and and logical-or operators to be associative, even
+   * though the order in which the application of those operators can have an effect because
+   * evaluation of the right-hand operand is conditional.
+   * @return {@code true} if this type of token represents an associative operator
+   */
+  bool isAssociativeOperator() => identical(this, AMPERSAND) || identical(this, AMPERSAND_AMPERSAND) || identical(this, BAR) || identical(this, BAR_BAR) || identical(this, CARET) || identical(this, PLUS) || identical(this, STAR);
   /**
    * Return {@code true} if this type of token represents an equality operator.
    * @return {@code true} if this type of token represents an equality operator
    */
-  bool isEqualityOperator() => _tokenClass == TokenClass.EQUALITY_OPERATOR;
+  bool isEqualityOperator() => identical(_tokenClass, TokenClass.EQUALITY_OPERATOR);
   /**
    * Return {@code true} if this type of token represents an increment operator.
    * @return {@code true} if this type of token represents an increment operator
    */
-  bool isIncrementOperator() => _lexeme == "++" || _lexeme == "--";
+  bool isIncrementOperator() => identical(_lexeme, "++") || identical(_lexeme, "--");
   /**
    * Return {@code true} if this type of token represents a multiplicative operator.
    * @return {@code true} if this type of token represents a multiplicative operator
    */
-  bool isMultiplicativeOperator() => _tokenClass == TokenClass.MULTIPLICATIVE_OPERATOR;
+  bool isMultiplicativeOperator() => identical(_tokenClass, TokenClass.MULTIPLICATIVE_OPERATOR);
   /**
    * Return {@code true} if this token type represents an operator.
    * @return {@code true} if this token type represents an operator
    */
-  bool isOperator() => _tokenClass != TokenClass.NO_CLASS && this != TokenType.OPEN_PAREN && this != TokenType.OPEN_SQUARE_BRACKET && this != TokenType.PERIOD;
+  bool isOperator() => _tokenClass != TokenClass.NO_CLASS && this != OPEN_PAREN && this != OPEN_SQUARE_BRACKET && this != PERIOD;
   /**
    * Return {@code true} if this type of token represents a relational operator.
    * @return {@code true} if this type of token represents a relational operator
    */
-  bool isRelationalOperator() => _tokenClass == TokenClass.RELATIONAL_OPERATOR;
+  bool isRelationalOperator() => identical(_tokenClass, TokenClass.RELATIONAL_OPERATOR);
   /**
    * Return {@code true} if this type of token represents a shift operator.
    * @return {@code true} if this type of token represents a shift operator
    */
-  bool isShiftOperator() => _tokenClass == TokenClass.SHIFT_OPERATOR;
+  bool isShiftOperator() => identical(_tokenClass, TokenClass.SHIFT_OPERATOR);
   /**
    * Return {@code true} if this type of token represents a unary postfix operator.
    * @return {@code true} if this type of token represents a unary postfix operator
    */
-  bool isUnaryPostfixOperator() => _tokenClass == TokenClass.UNARY_POSTFIX_OPERATOR;
+  bool isUnaryPostfixOperator() => identical(_tokenClass, TokenClass.UNARY_POSTFIX_OPERATOR);
   /**
    * Return {@code true} if this type of token represents a unary prefix operator.
    * @return {@code true} if this type of token represents a unary prefix operator
    */
-  bool isUnaryPrefixOperator() => _tokenClass == TokenClass.UNARY_PREFIX_OPERATOR;
+  bool isUnaryPrefixOperator() => identical(_tokenClass, TokenClass.UNARY_PREFIX_OPERATOR);
   /**
    * 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() => _lexeme == "==" || _lexeme == "~" || _lexeme == "[]" || _lexeme == "[]=" || _lexeme == "*" || _lexeme == "/" || _lexeme == "%" || _lexeme == "~/" || _lexeme == "+" || _lexeme == "-" || _lexeme == "<<" || _lexeme == ">>" || _lexeme == ">=" || _lexeme == ">" || _lexeme == "<=" || _lexeme == "<" || _lexeme == "&" || _lexeme == "^" || _lexeme == "|";
+  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-";
 }
 /**
  * Instances of the class {@code TokenWithComment} represent a string token that is preceded by
  * comments.
  */
@@ skipping 22 matching lines @@
   /**
    * 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((type == TokenType.OPEN_CURLY_BRACKET || type == TokenType.OPEN_PAREN || type == TokenType.OPEN_SQUARE_BRACKET || type == TokenType.STRING_INTERPOLATION_EXPRESSION));
+    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 endToken2(Token token) {
+  void set endToken(Token token) {
     this._endToken = token;
   }
 }
 /**
  * The enumeration {@code TokenClass} represents classes (or groups) of tokens with a similar use.
  */
 class TokenClass {
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
@@ skipping 60 matching lines @@
   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;
   /**
    * 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_225_impl(___name, ___ordinal);
+    _jtd_constructor_234_impl(___name, ___ordinal);
   }
-  _jtd_constructor_225_impl(String ___name, int ___ordinal) {
-    _jtd_constructor_226_impl(___name, ___ordinal, 0);
+  _jtd_constructor_234_impl(String ___name, int ___ordinal) {
+    _jtd_constructor_235_impl(___name, ___ordinal, 0);
   }
-  TokenClass.con2(String ___name, int ___ordinal, int precedence) {
-    _jtd_constructor_226_impl(___name, ___ordinal, precedence);
+  TokenClass.con2(String ___name, int ___ordinal, int precedence2) {
+    _jtd_constructor_235_impl(___name, ___ordinal, precedence2);
   }
-  _jtd_constructor_226_impl(String ___name, int ___ordinal, int precedence) {
+  _jtd_constructor_235_impl(String ___name, int ___ordinal, int precedence2) {
     __name = ___name;
     __ordinal = ___ordinal;
-    this._precedence = precedence;
+    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;
 }
 /**
@@ skipping 51 matching lines @@
       recordStartOfLine();
     }
     _offsetDelta = offset - column + 1;
     recordStartOfLine();
     _offsetDelta = offset;
   }
   int advance() {
     if (_charOffset + 1 >= _stringLength) {
       return -1;
     }
-    return _string.charCodeAt(++_charOffset);
+    return _string.codeUnitAt(++_charOffset);
   }
   String getString(int start, int endDelta) => _string.substring(start - _offsetDelta, _charOffset + 1 + endDelta);
   int peek() {
     if (_charOffset + 1 >= _string.length) {
       return -1;
     }
-    return _string.charCodeAt(_charOffset + 1);
+    return _string.codeUnitAt(_charOffset + 1);
   }
 }
 /**
  * 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
@@ skipping 130 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 type, TokenType beginType) {
+  void appendEndToken(TokenType type26, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
-      token = new Token(type, _tokenStart);
+      token = new Token(type26, _tokenStart);
     } else {
-      token = new TokenWithComment(type, _tokenStart, _firstComment);
+      token = new TokenWithComment(type26, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     _tail = _tail.setNext(token);
     int last = _groupingStack.length - 1;
     if (last >= 0) {
       BeginToken begin = _groupingStack[last];
-      if (begin.type == beginType) {
-        begin.endToken2 = token;
+      if (identical(begin.type, beginType)) {
+        begin.endToken = token;
         _groupingStack.removeAt(last);
       }
     }
   }
   void appendEofToken() {
     Token eofToken;
     if (_firstComment == null) {
       eofToken = new Token(TokenType.EOF, offset + 1);
     } else {
       eofToken = new TokenWithComment(TokenType.EOF, offset + 1, _firstComment);
@@ skipping 49 matching lines @@
       _tail = _tail.setNext(new TokenWithComment(type, offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void beginToken() {
     _tokenStart = offset;
   }
   int bigSwitch(int next) {
     beginToken();
-    if (next == 0xd) {
+    if (next == 0xD) {
       next = advance();
-      if (next == 0xa) {
+      if (next == 0xA) {
         next = advance();
       }
       recordStartOfLine();
       return next;
-    } else if (next == 0xa) {
+    } else if (next == 0xA) {
       recordStartOfLine();
       return advance();
     } else if (next == 0x9 || next == 0x20) {
       return advance();
     }
     if (next == 0x72) {
       int peek3 = peek();
       if (peek3 == 0x22 || peek3 == 0x27) {
         int start = offset;
         return tokenizeString(advance(), start, true);
       }
     }
-    if (0x61 <= next && next <= 0x7a) {
+    if (0x61 <= next && next <= 0x7A) {
       return tokenizeKeywordOrIdentifier(next, true);
     }
-    if ((0x41 <= next && next <= 0x5a) || next == 0x5f || next == 0x24) {
+    if ((0x41 <= next && next <= 0x5A) || next == 0x5F || next == 0x24) {
       return tokenizeIdentifier(next, offset, true);
     }
-    if (next == 0x3c) {
+    if (next == 0x3C) {
       return tokenizeLessThan(next);
     }
-    if (next == 0x3e) {
+    if (next == 0x3E) {
       return tokenizeGreaterThan(next);
     }
-    if (next == 0x3d) {
+    if (next == 0x3D) {
       return tokenizeEquals(next);
     }
     if (next == 0x21) {
       return tokenizeExclamation(next);
     }
-    if (next == 0x2b) {
+    if (next == 0x2B) {
       return tokenizePlus(next);
     }
-    if (next == 0x2d) {
+    if (next == 0x2D) {
       return tokenizeMinus(next);
     }
-    if (next == 0x2a) {
+    if (next == 0x2A) {
       return tokenizeMultiply(next);
     }
     if (next == 0x25) {
       return tokenizePercent(next);
     }
     if (next == 0x26) {
       return tokenizeAmpersand(next);
     }
-    if (next == 0x7c) {
+    if (next == 0x7C) {
       return tokenizeBar(next);
     }
-    if (next == 0x5e) {
+    if (next == 0x5E) {
       return tokenizeCaret(next);
     }
-    if (next == 0x5b) {
+    if (next == 0x5B) {
       return tokenizeOpenSquareBracket(next);
     }
-    if (next == 0x7e) {
+    if (next == 0x7E) {
       return tokenizeTilde(next);
     }
-    if (next == 0x5c) {
+    if (next == 0x5C) {
       appendToken(TokenType.BACKSLASH);
       return advance();
     }
     if (next == 0x23) {
       return tokenizeTag(next);
     }
     if (next == 0x28) {
       appendBeginToken(TokenType.OPEN_PAREN);
       return advance();
     }
     if (next == 0x29) {
       appendEndToken(TokenType.CLOSE_PAREN, TokenType.OPEN_PAREN);
       return advance();
     }
-    if (next == 0x2c) {
+    if (next == 0x2C) {
       appendToken(TokenType.COMMA);
       return advance();
     }
-    if (next == 0x3a) {
+    if (next == 0x3A) {
       appendToken(TokenType.COLON);
       return advance();
     }
-    if (next == 0x3b) {
+    if (next == 0x3B) {
       appendToken(TokenType.SEMICOLON);
       return advance();
     }
-    if (next == 0x3f) {
+    if (next == 0x3F) {
       appendToken(TokenType.QUESTION);
       return advance();
     }
-    if (next == 0x5d) {
+    if (next == 0x5D) {
       appendEndToken(TokenType.CLOSE_SQUARE_BRACKET, TokenType.OPEN_SQUARE_BRACKET);
       return advance();
     }
     if (next == 0x60) {
       appendToken(TokenType.BACKPING);
       return advance();
     }
-    if (next == 0x7b) {
+    if (next == 0x7B) {
       appendBeginToken(TokenType.OPEN_CURLY_BRACKET);
       return advance();
     }
-    if (next == 0x7d) {
+    if (next == 0x7D) {
       appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
       return advance();
     }
-    if (next == 0x2f) {
+    if (next == 0x2F) {
       return tokenizeSlashOrComment(next);
     }
     if (next == 0x40) {
       appendToken(TokenType.AT);
       return advance();
     }
     if (next == 0x22 || next == 0x27) {
       return tokenizeString(next, offset, false);
     }
-    if (next == 0x2e) {
+    if (next == 0x2E) {
       return tokenizeDotOrNumber(next);
     }
     if (next == 0x30) {
       return tokenizeHexOrNumber(next);
     }
     if (0x31 <= next && next <= 0x39) {
       return tokenizeNumber(next);
     }
     if (next == -1) {
       return -1;
     }
     if (Character.isLetter(next)) {
       return tokenizeIdentifier(next, offset, true);
     }
-    if (next == AbstractScanner._$NBSP) {
+    if (next == _$NBSP) {
       return advance();
     }
     reportError(ScannerErrorCode.ILLEGAL_CHARACTER, [next]);
     return advance();
   }
   /**
    * Return the beginning token corresponding to a closing brace that was found while scanning
    * inside a string interpolation expression. Tokens that cannot be matched with the closing brace
    * will be dropped from the stack.
    * @return the token to be paired with the closing brace
    */
   BeginToken findTokenMatchingClosingBraceInInterpolationExpression() {
     int last = _groupingStack.length - 1;
     while (last >= 0) {
       BeginToken begin = _groupingStack[last];
-      if (begin.type == TokenType.OPEN_CURLY_BRACKET || begin.type == TokenType.STRING_INTERPOLATION_EXPRESSION) {
+      if (identical(begin.type, TokenType.OPEN_CURLY_BRACKET) || identical(begin.type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         return begin;
       }
       _hasUnmatchedGroups2 = true;
       _groupingStack.removeAt(last);
       last--;
     }
     return null;
   }
   Token firstToken() => _tokens.next;
   /**
@@ skipping 27 matching lines @@
     } else {
       appendToken2(noType, offset);
       return next;
     }
   }
   int tokenizeAmpersand(int next) {
     next = advance();
     if (next == 0x26) {
       appendToken(TokenType.AMPERSAND_AMPERSAND);
       return advance();
-    } else if (next == 0x3d) {
+    } else if (next == 0x3D) {
       appendToken(TokenType.AMPERSAND_EQ);
       return advance();
     } else {
       appendToken(TokenType.AMPERSAND);
       return next;
     }
   }
   int tokenizeBar(int next) {
     next = advance();
-    if (next == 0x7c) {
+    if (next == 0x7C) {
       appendToken(TokenType.BAR_BAR);
       return advance();
-    } else if (next == 0x3d) {
+    } else if (next == 0x3D) {
       appendToken(TokenType.BAR_EQ);
       return advance();
     } else {
       appendToken(TokenType.BAR);
       return next;
     }
   }
-  int tokenizeCaret(int next) => select(0x3d, TokenType.CARET_EQ, TokenType.CARET);
+  int tokenizeCaret(int next) => select(0x3D, TokenType.CARET_EQ, TokenType.CARET);
   int tokenizeDotOrNumber(int next) {
     int start = offset;
     next = advance();
     if ((0x30 <= next && next <= 0x39)) {
       return tokenizeFractionPart(next, start);
-    } else if (0x2e == next) {
-      return select(0x2e, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
+    } else if (0x2E == next) {
+      return select(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
     } else {
       appendToken(TokenType.PERIOD);
       return next;
     }
   }
   int tokenizeEquals(int next) {
     next = advance();
-    if (next == 0x3d) {
+    if (next == 0x3D) {
       appendToken(TokenType.EQ_EQ);
       return advance();
-    } else if (next == 0x3e) {
+    } else if (next == 0x3E) {
       appendToken(TokenType.FUNCTION);
       return advance();
     }
     appendToken(TokenType.EQ);
     return next;
   }
   int tokenizeExclamation(int next) {
     next = advance();
-    if (next == 0x3d) {
+    if (next == 0x3D) {
       appendToken(TokenType.BANG_EQ);
       return advance();
     }
     appendToken(TokenType.BANG);
     return next;
   }
   int tokenizeExponent(int next) {
-    if (next == 0x2b || next == 0x2d) {
+    if (next == 0x2B || next == 0x2D) {
       next = advance();
     }
     bool hasDigits = false;
     while (true) {
       if (0x30 <= next && next <= 0x39) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           reportError(ScannerErrorCode.MISSING_DIGIT, []);
         }
@@ skipping 14 matching lines @@
         done = true;
         continue LOOP;
       } else {
         done = true;
         continue LOOP;
       }
       next = advance();
     }
     if (!hasDigit) {
       appendStringToken(TokenType.INT, getString(start, -2));
-      if (0x2e == next) {
-        return select2(0x2e, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD, offset - 1);
+      if (0x2E == next) {
+        return select2(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD, offset - 1);
       }
       appendToken2(TokenType.PERIOD, offset - 1);
       return bigSwitch(next);
     }
     if (next == 0x64 || next == 0x44) {
       next = advance();
     }
     appendStringToken(TokenType.DOUBLE, getString(start, next < 0 ? 0 : -1));
     return next;
   }
   int tokenizeGreaterThan(int next) {
     next = advance();
-    if (0x3d == next) {
+    if (0x3D == next) {
       appendToken(TokenType.GT_EQ);
       return advance();
-    } else if (0x3e == next) {
+    } else if (0x3E == next) {
       next = advance();
-      if (0x3d == next) {
+      if (0x3D == next) {
         appendToken(TokenType.GT_GT_EQ);
         return advance();
       } else {
         appendToken(TokenType.GT_GT);
         return next;
       }
     } else {
       appendToken(TokenType.GT);
       return next;
     }
@@ skipping 16 matching lines @@
   }
   int tokenizeHexOrNumber(int next) {
     int x = peek();
     if (x == 0x78 || x == 0x58) {
       advance();
       return tokenizeHex(x);
     }
     return tokenizeNumber(next);
   }
   int tokenizeIdentifier(int next, int start, bool allowDollar) {
-    while ((0x61 <= next && next <= 0x7a) || (0x41 <= next && next <= 0x5a) || (0x30 <= next && next <= 0x39) || next == 0x5f || (next == 0x24 && allowDollar) || Character.isLetterOrDigit(next)) {
+    while ((0x61 <= next && next <= 0x7A) || (0x41 <= next && next <= 0x5A) || (0x30 <= next && next <= 0x39) || next == 0x5F || (next == 0x24 && allowDollar) || Character.isLetterOrDigit(next)) {
       next = advance();
     }
     appendStringToken(TokenType.IDENTIFIER, getString(start, next < 0 ? 0 : -1));
     return next;
   }
   int tokenizeInterpolatedExpression(int next, int start) {
     appendBeginToken(TokenType.STRING_INTERPOLATION_EXPRESSION);
     next = advance();
     while (next != -1) {
-      if (next == 0x7d) {
+      if (next == 0x7D) {
         BeginToken begin = findTokenMatchingClosingBraceInInterpolationExpression();
         if (begin == null) {
           beginToken();
           appendToken(TokenType.CLOSE_CURLY_BRACKET);
           next = advance();
           beginToken();
           return next;
-        } else if (begin.type == TokenType.OPEN_CURLY_BRACKET) {
+        } else if (identical(begin.type, TokenType.OPEN_CURLY_BRACKET)) {
           beginToken();
           appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
           next = advance();
           beginToken();
-        } else if (begin.type == TokenType.STRING_INTERPOLATION_EXPRESSION) {
+        } else if (identical(begin.type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
           beginToken();
           appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.STRING_INTERPOLATION_EXPRESSION);
           next = advance();
           beginToken();
           return next;
         }
       } else {
         next = bigSwitch(next);
       }
     }
     if (next == -1) {
       return next;
     }
     next = advance();
     beginToken();
     return next;
   }
   int tokenizeInterpolatedIdentifier(int next, int start) {
     appendStringToken2(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 0);
     beginToken();
     next = tokenizeKeywordOrIdentifier(next, false);
     beginToken();
     return next;
   }
-  int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
+  int tokenizeKeywordOrIdentifier(int next2, bool allowDollar) {
     KeywordState state = KeywordState.KEYWORD_STATE;
     int start = offset;
-    while (state != null && 0x61 <= next && next <= 0x7a) {
-      state = state.next(next as int);
-      next = advance();
+    while (state != null && 0x61 <= next2 && next2 <= 0x7A) {
+      state = state.next((next2 as int));
+      next2 = advance();
     }
     if (state == null || state.keyword() == null) {
-      return tokenizeIdentifier(next, start, allowDollar);
+      return tokenizeIdentifier(next2, start, allowDollar);
     }
-    if ((0x41 <= next && next <= 0x5a) || (0x30 <= next && next <= 0x39) || next == 0x5f || next == 0x24) {
-      return tokenizeIdentifier(next, start, allowDollar);
-    } else if (next < 128) {
+    if ((0x41 <= next2 && next2 <= 0x5A) || (0x30 <= next2 && next2 <= 0x39) || next2 == 0x5F || next2 == 0x24) {
+      return tokenizeIdentifier(next2, start, allowDollar);
+    } else if (next2 < 128) {
       appendKeywordToken(state.keyword());
-      return next;
+      return next2;
     } else {
-      return tokenizeIdentifier(next, start, allowDollar);
+      return tokenizeIdentifier(next2, start, allowDollar);
     }
   }
   int tokenizeLessThan(int next) {
     next = advance();
-    if (0x3d == next) {
+    if (0x3D == next) {
       appendToken(TokenType.LT_EQ);
       return advance();
-    } else if (0x3c == next) {
-      return select(0x3d, TokenType.LT_LT_EQ, TokenType.LT_LT);
+    } else if (0x3C == next) {
+      return select(0x3D, TokenType.LT_LT_EQ, TokenType.LT_LT);
     } else {
       appendToken(TokenType.LT);
       return next;
     }
   }
   int tokenizeMinus(int next) {
     next = advance();
-    if (next == 0x2d) {
+    if (next == 0x2D) {
       appendToken(TokenType.MINUS_MINUS);
       return advance();
-    } else if (next == 0x3d) {
+    } else if (next == 0x3D) {
       appendToken(TokenType.MINUS_EQ);
       return advance();
     } else {
       appendToken(TokenType.MINUS);
       return next;
     }
   }
   int tokenizeMultiLineComment(int next) {
     int nesting = 1;
     next = advance();
     while (true) {
       if (-1 == next) {
         reportError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, []);
         appendCommentToken(TokenType.MULTI_LINE_COMMENT, getString(_tokenStart, 0));
         return next;
-      } else if (0x2a == next) {
+      } else if (0x2A == next) {
         next = advance();
-        if (0x2f == next) {
+        if (0x2F == next) {
           --nesting;
           if (0 == nesting) {
             appendCommentToken(TokenType.MULTI_LINE_COMMENT, getString(_tokenStart, 0));
             return advance();
           } else {
             next = advance();
           }
         }
-      } else if (0x2f == next) {
+      } else if (0x2F == next) {
         next = advance();
-        if (0x2a == next) {
+        if (0x2A == next) {
           next = advance();
           ++nesting;
         }
       } else {
         next = advance();
       }
     }
   }
   int tokenizeMultiLineRawString(int quoteChar, int start) {
     int next = advance();
@@ skipping 34 matching lines @@
         next = advance();
         if (next == quoteChar) {
           next = advance();
           if (next == quoteChar) {
             appendStringToken(TokenType.STRING, getString(start, 0));
             return advance();
           }
         }
         continue;
       }
-      if (next == 0x5c) {
+      if (next == 0x5C) {
         next = advance();
         if (next == -1) {
           break;
         }
       }
       next = advance();
     }
     reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
     appendStringToken(TokenType.STRING, getString(start, 0));
     return advance();
   }
-  int tokenizeMultiply(int next) => select(0x3d, TokenType.STAR_EQ, TokenType.STAR);
+  int tokenizeMultiply(int next) => select(0x3D, TokenType.STAR_EQ, TokenType.STAR);
   int tokenizeNumber(int next) {
     int start = offset;
     while (true) {
       next = advance();
       if (0x30 <= next && next <= 0x39) {
         continue;
-      } else if (next == 0x2e) {
+      } else if (next == 0x2E) {
         return tokenizeFractionPart(advance(), start);
       } else if (next == 0x64 || next == 0x44) {
         appendStringToken(TokenType.DOUBLE, getString(start, 0));
         return advance();
       } else if (next == 0x65 || next == 0x45) {
         return tokenizeFractionPart(next, start);
       } else {
         appendStringToken(TokenType.INT, getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
   int tokenizeOpenSquareBracket(int next) {
     next = advance();
-    if (next == 0x5d) {
-      return select(0x3d, TokenType.INDEX_EQ, TokenType.INDEX);
+    if (next == 0x5D) {
+      return select(0x3D, TokenType.INDEX_EQ, TokenType.INDEX);
     } else {
       appendBeginToken(TokenType.OPEN_SQUARE_BRACKET);
       return next;
     }
   }
-  int tokenizePercent(int next) => select(0x3d, TokenType.PERCENT_EQ, TokenType.PERCENT);
+  int tokenizePercent(int next) => select(0x3D, TokenType.PERCENT_EQ, TokenType.PERCENT);
   int tokenizePlus(int next) {
     next = advance();
-    if (0x2b == next) {
+    if (0x2B == next) {
       appendToken(TokenType.PLUS_PLUS);
       return advance();
-    } else if (0x3d == next) {
+    } else if (0x3D == next) {
       appendToken(TokenType.PLUS_EQ);
       return advance();
     } else {
       appendToken(TokenType.PLUS);
       return next;
     }
   }
   int tokenizeSingleLineComment(int next) {
     while (true) {
       next = advance();
-      if (0xa == next || 0xd == next || -1 == next) {
+      if (0xA == next || 0xD == next || -1 == next) {
         appendCommentToken(TokenType.SINGLE_LINE_COMMENT, getString(_tokenStart, 0));
         return next;
       }
     }
   }
   int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     next = advance();
     while (next != -1) {
       if (next == quoteChar) {
         appendStringToken(TokenType.STRING, getString(start, 0));
         return advance();
-      } else if (next == 0xd || next == 0xa) {
+      } else if (next == 0xD || next == 0xA) {
         reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
         appendStringToken(TokenType.STRING, getString(start, 0));
         return advance();
       }
       next = advance();
     }
     reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
     appendStringToken(TokenType.STRING, getString(start, 0));
     return advance();
   }
   int tokenizeSingleLineString(int next, int quoteChar, int start) {
     while (next != quoteChar) {
-      if (next == 0x5c) {
+      if (next == 0x5C) {
         next = advance();
       } else if (next == 0x24) {
         appendStringToken(TokenType.STRING, getString(start, -1));
         beginToken();
         next = tokenizeStringInterpolation(start);
         start = offset;
         continue;
       }
-      if (next <= 0xd && (next == 0xa || next == 0xd || next == -1)) {
+      if (next <= 0xD && (next == 0xA || next == 0xD || next == -1)) {
         reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
         appendStringToken(TokenType.STRING, getString(start, 0));
         return advance();
       }
       next = advance();
     }
     appendStringToken(TokenType.STRING, getString(start, 0));
     return advance();
   }
   int tokenizeSlashOrComment(int next) {
     next = advance();
-    if (0x2a == next) {
+    if (0x2A == next) {
       return tokenizeMultiLineComment(next);
-    } else if (0x2f == next) {
+    } else if (0x2F == next) {
       return tokenizeSingleLineComment(next);
-    } else if (0x3d == next) {
+    } else if (0x3D == next) {
       appendToken(TokenType.SLASH_EQ);
       return advance();
     } else {
       appendToken(TokenType.SLASH);
       return next;
     }
   }
   int tokenizeString(int next, int start, bool raw) {
     int quoteChar = next;
     next = advance();
     if (quoteChar == next) {
       next = advance();
       if (quoteChar == next) {
         return tokenizeMultiLineString(quoteChar, start, raw);
       } else {
         appendStringToken(TokenType.STRING, getString(start, -1));
         return next;
       }
     }
     if (raw) {
       return tokenizeSingleLineRawString(next, quoteChar, start);
     } else {
       return tokenizeSingleLineString(next, quoteChar, start);
     }
   }
   int tokenizeStringInterpolation(int start) {
     beginToken();
     int next = advance();
-    if (next == 0x7b) {
+    if (next == 0x7B) {
       return tokenizeInterpolatedExpression(next, start);
     } else {
       return tokenizeInterpolatedIdentifier(next, start);
     }
   }
   int tokenizeTag(int next) {
     if (offset == 0) {
       if (peek() == 0x21) {
         do {
           next = advance();
-        } while (next != 0xa && next != 0xd && next > 0);
+        } while (next != 0xA && next != 0xD && next > 0);
         appendStringToken(TokenType.SCRIPT_TAG, getString(_tokenStart, 0));
         return next;
       }
     }
     appendToken(TokenType.HASH);
     return advance();
   }
   int tokenizeTilde(int next) {
     next = advance();
-    if (next == 0x2f) {
-      return select(0x3d, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
+    if (next == 0x2F) {
+      return select(0x3D, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
     } else {
       appendToken(TokenType.TILDE);
       return next;
     }
   }
 }
 /**
  * Instances of the class {@code KeywordTokenWithComment} implement a keyword token that is preceded
  * by comments.
  */
@@ skipping 32 matching lines @@
    * strings in the given array of strings starting at the given offset and having the given length.
    * All of these strings have a common prefix and the next character is at the given start index.
    * @param start the index of the character in the strings used to transition to a new state
    * @param strings an array containing all of the strings that will be recognized by the state
    * machine
    * @param offset the offset of the first string in the array that has the prefix that is assumed
    * to have been recognized by the time we reach the state being built
    * @param length the number of strings in the array that pass through the state being built
    * @return the state that was created
    */
-  static KeywordState computeKeywordStateTable(int start, List<String> strings, int offset, int length) {
+  static KeywordState computeKeywordStateTable(int start, List<String> strings, int offset, int length12) {
     List<KeywordState> result = new List<KeywordState>.fixedLength(26);
-    assert(length != 0);
+    assert(length12 != 0);
     int chunk = 0x0;
     int chunkStart = -1;
     bool isLeaf = false;
-    for (int i = offset; i < offset + length; i++) {
+    for (int i = offset; i < offset + length12; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
-        int c = strings[i].charCodeAt(start);
+        int c = strings[i].codeUnitAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
             result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart);
           }
           chunkStart = i;
           chunk = c;
         }
       }
     }
     if (chunkStart != -1) {
       assert(result[chunk - 0x61] == null);
-      result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart);
+      result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, offset + length12 - chunkStart);
     } else {
-      assert(length == 1);
+      assert(length12 == 1);
       return new KeywordState(_EMPTY_TABLE, strings[offset]);
     }
     if (isLeaf) {
       return new KeywordState(result, strings[offset]);
     } else {
       return new KeywordState(result, null);
     }
   }
   /**
    * Create the initial state in the state machine.
@@ skipping 34 matching lines @@
    * @return the keyword that was matched by reaching this state
    */
   Keyword keyword() => _keyword2;
   /**
    * 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];
 }