Reformat

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.scanner;
 
 import 'dart:collection';
 
 import 'error.dart';
 import 'java_engine.dart';
@@ skipping 357 matching lines @@
 
   static const Keyword PART = const Keyword('PART', "part", true);
 
   static const Keyword SET = const Keyword('SET', "set", true);
 
   static const Keyword STATIC = const Keyword('STATIC', "static", true);
 
   static const Keyword TYPEDEF = const Keyword('TYPEDEF', "typedef", true);
 
   static const List<Keyword> values = const [
-      ASSERT,
-      BREAK,
-      CASE,
-      CATCH,
-      CLASS,
-      CONST,
-      CONTINUE,
-      DEFAULT,
-      DO,
-      ELSE,
-      ENUM,
-      EXTENDS,
-      FALSE,
-      FINAL,
-      FINALLY,
-      FOR,
-      IF,
-      IN,
-      IS,
-      NEW,
-      NULL,
-      RETHROW,
-      RETURN,
-      SUPER,
-      SWITCH,
-      THIS,
-      THROW,
-      TRUE,
-      TRY,
-      VAR,
-      VOID,
-      WHILE,
-      WITH,
-      ABSTRACT,
-      AS,
-      DEFERRED,
-      DYNAMIC,
-      EXPORT,
-      EXTERNAL,
-      FACTORY,
-      GET,
-      IMPLEMENTS,
-      IMPORT,
-      LIBRARY,
-      OPERATOR,
-      PART,
-      SET,
-      STATIC,
-      TYPEDEF];
+    ASSERT,
+    BREAK,
+    CASE,
+    CATCH,
+    CLASS,
+    CONST,
+    CONTINUE,
+    DEFAULT,
+    DO,
+    ELSE,
+    ENUM,
+    EXTENDS,
+    FALSE,
+    FINAL,
+    FINALLY,
+    FOR,
+    IF,
+    IN,
+    IS,
+    NEW,
+    NULL,
+    RETHROW,
+    RETURN,
+    SUPER,
+    SWITCH,
+    THIS,
+    THROW,
+    TRUE,
+    TRY,
+    VAR,
+    VOID,
+    WHILE,
+    WITH,
+    ABSTRACT,
+    AS,
+    DEFERRED,
+    DYNAMIC,
+    EXPORT,
+    EXTERNAL,
+    FACTORY,
+    GET,
+    IMPLEMENTS,
+    IMPORT,
+    LIBRARY,
+    OPERATOR,
+    PART,
+    SET,
+    STATIC,
+    TYPEDEF
+  ];
 
   /**
    * A table mapping the lexemes of keywords to the corresponding keyword.
    */
   static final Map<String, Keyword> keywords = _createKeywordMap();
 
   /**
    * The name of the keyword type.
    */
   final String name;
@@ skipping 89 matching lines @@
    * [start] the index of the character in the strings used to transition to a
    * new state
    * [strings] an array containing all of the strings that will be recognized by
    * the state machine
    * [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
    * [length] the number of strings in the array that pass through the state
    * being built
    */
-  static KeywordState _computeKeywordStateTable(int start, List<String> strings,
-      int offset, int length) {
+  static KeywordState _computeKeywordStateTable(
+      int start, List<String> strings, int offset, int length) {
     List<KeywordState> result = new List<KeywordState>(26);
     assert(length != 0);
     int chunk = 0x0;
     int chunkStart = -1;
     bool isLeaf = false;
     for (int i = offset; i < offset + length; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
         int c = strings[i].codeUnitAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
-            result[chunk - 0x61] =
-                _computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart);
+            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 + length - chunkStart);
     } else {
       assert(length == 1);
       return new KeywordState(_EMPTY_TABLE, strings[offset]);
     }
     if (isLeaf) {
       return new KeywordState(result, strings[offset]);
     } else {
       return new KeywordState(result, null);
     }
   }
@@ skipping 67 matching lines @@
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = precedingComments;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 
   @override
-  Token copy() =>
-      new KeywordTokenWithComment(keyword, offset, copyComments(precedingComments));
+  Token copy() => new KeywordTokenWithComment(
+      keyword, offset, copyComments(precedingComments));
 }
 
 /**
  * The class `Scanner` implements a scanner for Dart code.
  *
  * 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
@@ skipping 218 matching lines @@
     if (next == 0x3B) {
       _appendTokenOfType(TokenType.SEMICOLON);
       return _reader.advance();
     }
     if (next == 0x3F) {
       _appendTokenOfType(TokenType.QUESTION);
       return _reader.advance();
     }
     if (next == 0x5D) {
       _appendEndToken(
-          TokenType.CLOSE_SQUARE_BRACKET,
-          TokenType.OPEN_SQUARE_BRACKET);
+          TokenType.CLOSE_SQUARE_BRACKET, TokenType.OPEN_SQUARE_BRACKET);
       return _reader.advance();
     }
     if (next == 0x60) {
       _appendTokenOfType(TokenType.BACKPING);
       return _reader.advance();
     }
     if (next == 0x7B) {
       _appendBeginToken(TokenType.OPEN_CURLY_BRACKET);
       return _reader.advance();
     }
     if (next == 0x7D) {
       _appendEndToken(
-          TokenType.CLOSE_CURLY_BRACKET,
-          TokenType.OPEN_CURLY_BRACKET);
+          TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
       return _reader.advance();
     }
     if (next == 0x2F) {
       return _tokenizeSlashOrComment(next);
     }
     if (next == 0x40) {
       _appendTokenOfType(TokenType.AT);
       return _reader.advance();
     }
     if (next == 0x22 || next == 0x27) {
@@ skipping 111 matching lines @@
         _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);
+      eofToken = new TokenWithComment(
+          TokenType.EOF, _reader.offset + 1, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     // The EOF token points to itself so that there is always infinite
     // look-ahead.
     eofToken.setNext(eofToken);
     _tail = _tail.setNext(eofToken);
     if (_stackEnd >= 0) {
       _hasUnmatchedGroups = true;
       // TODO(brianwilkerson) Fix the ungrouped tokens?
@@ skipping 19 matching lines @@
           new StringTokenWithComment(type, value, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
 
   void _appendStringTokenWithOffset(TokenType type, String value, int offset) {
     if (_firstComment == null) {
       _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 _appendTokenOfType(TokenType type) {
     if (_firstComment == null) {
       _tail = _tail.setNext(new Token(type, _tokenStart));
     } else {
       _tail =
@@ skipping 40 matching lines @@
     return null;
   }
 
   /**
    * Report an error at the current offset.
    *
    * [errorCode] the error code indicating the nature of the error
    * [arguments] any arguments needed to complete the error message
    */
   void _reportError(ScannerErrorCode errorCode, [List<Object> arguments]) {
-    _errorListener.onError(
-        new AnalysisError.con2(source, _reader.offset, 1, errorCode, arguments));
+    _errorListener.onError(new AnalysisError.con2(
+        source, _reader.offset, 1, errorCode, arguments));
   }
 
   int _select(int choice, TokenType yesType, TokenType noType) {
     int next = _reader.advance();
     if (next == choice) {
       _appendTokenOfType(yesType);
       return _reader.advance();
     } else {
       _appendTokenOfType(noType);
       return next;
     }
   }
 
-  int _selectWithOffset(int choice, TokenType yesType, TokenType noType,
-      int offset) {
+  int _selectWithOffset(
+      int choice, TokenType yesType, TokenType noType, int offset) {
     int next = _reader.advance();
     if (next == choice) {
       _appendTokenOfTypeWithOffset(yesType, offset);
       return _reader.advance();
     } else {
       _appendTokenOfTypeWithOffset(noType, offset);
       return next;
     }
   }
 
@@ skipping 30 matching lines @@
   int _tokenizeCaret(int next) =>
       _select(0x3D, TokenType.CARET_EQ, TokenType.CARET);
 
   int _tokenizeDotOrNumber(int next) {
     int start = _reader.offset;
     next = _reader.advance();
     if (0x30 <= next && next <= 0x39) {
       return _tokenizeFractionPart(next, start);
     } else if (0x2E == next) {
       return _select(
-          0x2E,
-          TokenType.PERIOD_PERIOD_PERIOD,
-          TokenType.PERIOD_PERIOD);
+          0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
     } else {
       _appendTokenOfType(TokenType.PERIOD);
       return next;
     }
   }
 
   int _tokenizeEquals(int next) {
     // = == =>
     next = _reader.advance();
     if (next == 0x3D) {
@@ skipping 49 matching lines @@
         continue LOOP;
       } else {
         done = true;
         continue LOOP;
       }
       next = _reader.advance();
     }
     if (!hasDigit) {
       _appendStringToken(TokenType.INT, _reader.getString(start, -2));
       if (0x2E == next) {
-        return _selectWithOffset(
-            0x2E,
-            TokenType.PERIOD_PERIOD_PERIOD,
-            TokenType.PERIOD_PERIOD,
-            _reader.offset - 1);
+        return _selectWithOffset(0x2E, TokenType.PERIOD_PERIOD_PERIOD,
+            TokenType.PERIOD_PERIOD, _reader.offset - 1);
       }
       _appendTokenOfTypeWithOffset(TokenType.PERIOD, _reader.offset - 1);
       return bigSwitch(next);
     }
     _appendStringToken(
-        TokenType.DOUBLE,
-        _reader.getString(start, next < 0 ? 0 : -1));
+        TokenType.DOUBLE, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
 
   int _tokenizeGreaterThan(int next) {
     // > >= >> >>=
     next = _reader.advance();
     if (0x3D == next) {
       _appendTokenOfType(TokenType.GT_EQ);
       return _reader.advance();
     } else if (0x3E == next) {
@@ skipping 18 matching lines @@
       next = _reader.advance();
       if ((0x30 <= next && next <= 0x39) ||
           (0x41 <= next && next <= 0x46) ||
           (0x61 <= next && next <= 0x66)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           _reportError(ScannerErrorCode.MISSING_HEX_DIGIT);
         }
         _appendStringToken(
-            TokenType.HEXADECIMAL,
-            _reader.getString(start, next < 0 ? 0 : -1));
+            TokenType.HEXADECIMAL, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
 
   int _tokenizeHexOrNumber(int next) {
     int x = _reader.peek();
     if (x == 0x78 || x == 0x58) {
       _reader.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)) {
       next = _reader.advance();
     }
     _appendStringToken(
-        TokenType.IDENTIFIER,
-        _reader.getString(start, next < 0 ? 0 : -1));
+        TokenType.IDENTIFIER, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
 
   int _tokenizeInterpolatedExpression(int next, int start) {
     _appendBeginToken(TokenType.STRING_INTERPOLATION_EXPRESSION);
     next = _reader.advance();
     while (next != -1) {
       if (next == 0x7D) {
         BeginToken begin =
             _findTokenMatchingClosingBraceInInterpolationExpression();
         if (begin == null) {
           _beginToken();
           _appendTokenOfType(TokenType.CLOSE_CURLY_BRACKET);
           next = _reader.advance();
           _beginToken();
           return next;
         } else if (begin.type == TokenType.OPEN_CURLY_BRACKET) {
           _beginToken();
           _appendEndToken(
-              TokenType.CLOSE_CURLY_BRACKET,
-              TokenType.OPEN_CURLY_BRACKET);
+              TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
           next = _reader.advance();
           _beginToken();
         } else if (begin.type == TokenType.STRING_INTERPOLATION_EXPRESSION) {
           _beginToken();
-          _appendEndToken(
-              TokenType.CLOSE_CURLY_BRACKET,
+          _appendEndToken(TokenType.CLOSE_CURLY_BRACKET,
               TokenType.STRING_INTERPOLATION_EXPRESSION);
           next = _reader.advance();
           _beginToken();
           return next;
         }
       } else {
         next = bigSwitch(next);
       }
     }
     return next;
   }
 
   int _tokenizeInterpolatedIdentifier(int next, int start) {
     _appendStringTokenWithOffset(
-        TokenType.STRING_INTERPOLATION_IDENTIFIER,
-        "\$",
-        0);
+        TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 0);
     if ((0x41 <= next && next <= 0x5A) ||
         (0x61 <= next && next <= 0x7A) ||
         next == 0x5F) {
       _beginToken();
       next = _tokenizeKeywordOrIdentifier(next, false);
     }
     _beginToken();
     return next;
   }
 
@@ skipping 49 matching lines @@
     }
   }
 
   int _tokenizeMultiLineComment(int next) {
     int nesting = 1;
     next = _reader.advance();
     while (true) {
       if (-1 == next) {
         _reportError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT);
         _appendCommentToken(
-            TokenType.MULTI_LINE_COMMENT,
-            _reader.getString(_tokenStart, 0));
+            TokenType.MULTI_LINE_COMMENT, _reader.getString(_tokenStart, 0));
         return next;
       } else if (0x2A == next) {
         next = _reader.advance();
         if (0x2F == next) {
           --nesting;
           if (0 == nesting) {
-            _appendCommentToken(
-                TokenType.MULTI_LINE_COMMENT,
+            _appendCommentToken(TokenType.MULTI_LINE_COMMENT,
                 _reader.getString(_tokenStart, 0));
             return _reader.advance();
           } else {
             next = _reader.advance();
           }
         }
       } else if (0x2F == next) {
         next = _reader.advance();
         if (0x2A == next) {
           next = _reader.advance();
@@ skipping 117 matching lines @@
     while (true) {
       next = _reader.advance();
       if (0x30 <= next && next <= 0x39) {
         continue;
       } else if (next == 0x2E) {
         return _tokenizeFractionPart(_reader.advance(), start);
       } else if (next == 0x65 || next == 0x45) {
         return _tokenizeFractionPart(next, start);
       } else {
         _appendStringToken(
-            TokenType.INT,
-            _reader.getString(start, next < 0 ? 0 : -1));
+            TokenType.INT, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
 
   int _tokenizeOpenSquareBracket(int next) {
     // [ []  []=
     next = _reader.advance();
     if (next == 0x5D) {
       return _select(0x3D, TokenType.INDEX_EQ, TokenType.INDEX);
@@ skipping 19 matching lines @@
       _appendTokenOfType(TokenType.PLUS);
       return next;
     }
   }
 
   int _tokenizeSingleLineComment(int next) {
     while (true) {
       next = _reader.advance();
       if (-1 == next) {
         _appendCommentToken(
-            TokenType.SINGLE_LINE_COMMENT,
-            _reader.getString(_tokenStart, 0));
+            TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, 0));
         return next;
       } else if (0xA == next || 0xD == next) {
         _appendCommentToken(
-            TokenType.SINGLE_LINE_COMMENT,
-            _reader.getString(_tokenStart, -1));
+            TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, -1));
         return next;
       }
     }
   }
 
   int _tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     next = _reader.advance();
     while (next != -1) {
       if (next == quoteChar) {
         _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
@@ skipping 85 matching lines @@
   }
 
   int _tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (_reader.offset == 0) {
       if (_reader.peek() == 0x21) {
         do {
           next = _reader.advance();
         } while (next != 0xA && next != 0xD && next > 0);
         _appendStringToken(
-            TokenType.SCRIPT_TAG,
-            _reader.getString(_tokenStart, 0));
+            TokenType.SCRIPT_TAG, _reader.getString(_tokenStart, 0));
         return next;
       }
     }
     _appendTokenOfType(TokenType.HASH);
     return _reader.advance();
   }
 
   int _tokenizeTilde(int next) {
     // ~ ~/ ~/=
     next = _reader.advance();
@@ skipping 24 matching lines @@
 
   static const ScannerErrorCode MISSING_DIGIT =
       const ScannerErrorCode('MISSING_DIGIT', "Decimal digit expected");
 
   static const ScannerErrorCode MISSING_HEX_DIGIT =
       const ScannerErrorCode('MISSING_HEX_DIGIT', "Hexidecimal digit expected");
 
   static const ScannerErrorCode MISSING_QUOTE =
       const ScannerErrorCode('MISSING_QUOTE', "Expected quote (' or \")");
 
-  static const ScannerErrorCode UNABLE_GET_CONTENT =
-      const ScannerErrorCode('UNABLE_GET_CONTENT', "Unable to get content: {0}");
+  static const ScannerErrorCode UNABLE_GET_CONTENT = const ScannerErrorCode(
+      'UNABLE_GET_CONTENT', "Unable to get content: {0}");
 
   static const ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT =
       const ScannerErrorCode(
-          'UNTERMINATED_MULTI_LINE_COMMENT',
-          "Unterminated multi-line comment");
+          'UNTERMINATED_MULTI_LINE_COMMENT', "Unterminated multi-line comment");
 
   static const ScannerErrorCode UNTERMINATED_STRING_LITERAL =
       const ScannerErrorCode(
-          'UNTERMINATED_STRING_LITERAL',
-          "Unterminated string literal");
+          'UNTERMINATED_STRING_LITERAL', "Unterminated string literal");
 
   /**
    * Initialize a newly created error code to have the given [name]. The message
    * associated with the error will be created from the given [message]
    * template. The correction associated with the error will be created from the
    * given [correction] template.
    */
   const ScannerErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
@@ skipping 38 matching lines @@
   /**
    * The first comment in the list of comments that precede this token.
    */
   CommentToken _precedingComment;
 
   /**
    * Initialize a newly created token to have the given [type] at the given
    * [offset] and to be preceded by the comments reachable from the given
    * [comment].
    */
-  StringTokenWithComment(TokenType type, String value, int offset,
-      this._precedingComment)
+  StringTokenWithComment(
+      TokenType type, String value, int offset, this._precedingComment)
       : super(type, value, offset) {
     _setCommentParent(_precedingComment);
   }
 
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = precedingComments;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 
   @override
-  Token copy() =>
-      new StringTokenWithComment(
-          type,
-          lexeme,
-          offset,
-          copyComments(precedingComments));
+  Token copy() => new StringTokenWithComment(
+      type, lexeme, offset, copyComments(precedingComments));
 }
 
 /**
  * A `SubSequenceReader` is 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 370 matching lines @@
   static const TokenType SCRIPT_TAG = const TokenType('SCRIPT_TAG');
 
   static const TokenType SINGLE_LINE_COMMENT =
       const TokenType('SINGLE_LINE_COMMENT');
 
   static const TokenType STRING = const TokenType('STRING');
 
   static const TokenType AMPERSAND =
       const TokenType('AMPERSAND', TokenClass.BITWISE_AND_OPERATOR, "&");
 
-  static const TokenType AMPERSAND_AMPERSAND =
-      const TokenType('AMPERSAND_AMPERSAND', TokenClass.LOGICAL_AND_OPERATOR, "&&");
+  static const TokenType AMPERSAND_AMPERSAND = const TokenType(
+      'AMPERSAND_AMPERSAND', TokenClass.LOGICAL_AND_OPERATOR, "&&");
 
   static const TokenType AMPERSAND_EQ =
       const TokenType('AMPERSAND_EQ', TokenClass.ASSIGNMENT_OPERATOR, "&=");
 
   static const TokenType AT = const TokenType('AT', TokenClass.NO_CLASS, "@");
 
   static const TokenType BANG =
       const TokenType('BANG', TokenClass.UNARY_PREFIX_OPERATOR, "!");
 
   static const TokenType BANG_EQ =
@@ skipping 82 matching lines @@
 
   static const TokenType MINUS_MINUS =
       const TokenType('MINUS_MINUS', TokenClass.UNARY_PREFIX_OPERATOR, "--");
 
   static const TokenType OPEN_CURLY_BRACKET =
       const TokenType('OPEN_CURLY_BRACKET', TokenClass.NO_CLASS, "{");
 
   static const TokenType OPEN_PAREN =
       const TokenType('OPEN_PAREN', TokenClass.UNARY_POSTFIX_OPERATOR, "(");
 
-  static const TokenType OPEN_SQUARE_BRACKET =
-      const TokenType('OPEN_SQUARE_BRACKET', TokenClass.UNARY_POSTFIX_OPERATOR, "[");
+  static const TokenType OPEN_SQUARE_BRACKET = const TokenType(
+      'OPEN_SQUARE_BRACKET', TokenClass.UNARY_POSTFIX_OPERATOR, "[");
 
   static const TokenType PERCENT =
       const TokenType('PERCENT', TokenClass.MULTIPLICATIVE_OPERATOR, "%");
 
   static const TokenType PERCENT_EQ =
       const TokenType('PERCENT_EQ', TokenClass.ASSIGNMENT_OPERATOR, "%=");
 
   static const TokenType PERIOD =
       const TokenType('PERIOD', TokenClass.UNARY_POSTFIX_OPERATOR, ".");
 
@@ skipping 20 matching lines @@
 
   static const TokenType SLASH_EQ =
       const TokenType('SLASH_EQ', TokenClass.ASSIGNMENT_OPERATOR, "/=");
 
   static const TokenType STAR =
       const TokenType('STAR', TokenClass.MULTIPLICATIVE_OPERATOR, "*");
 
   static const TokenType STAR_EQ =
       const TokenType('STAR_EQ', TokenClass.ASSIGNMENT_OPERATOR, "*=");
 
-  static const TokenType STRING_INTERPOLATION_EXPRESSION =
-      const TokenType('STRING_INTERPOLATION_EXPRESSION', TokenClass.NO_CLASS, "\${");
+  static const TokenType STRING_INTERPOLATION_EXPRESSION = const TokenType(
+      'STRING_INTERPOLATION_EXPRESSION', TokenClass.NO_CLASS, "\${");
 
-  static const TokenType STRING_INTERPOLATION_IDENTIFIER =
-      const TokenType('STRING_INTERPOLATION_IDENTIFIER', TokenClass.NO_CLASS, "\$");
+  static const TokenType STRING_INTERPOLATION_IDENTIFIER = const TokenType(
+      'STRING_INTERPOLATION_IDENTIFIER', TokenClass.NO_CLASS, "\$");
 
   static const TokenType TILDE =
       const TokenType('TILDE', TokenClass.UNARY_PREFIX_OPERATOR, "~");
 
   static const TokenType TILDE_SLASH =
       const TokenType('TILDE_SLASH', TokenClass.MULTIPLICATIVE_OPERATOR, "~/");
 
   static const TokenType TILDE_SLASH_EQ =
       const TokenType('TILDE_SLASH_EQ', TokenClass.ASSIGNMENT_OPERATOR, "~/=");
 
@@ skipping 15 matching lines @@
    * The name of the token type.
    */
   final String name;
 
   /**
    * The lexeme that defines this type of token, or `null` if there is more than
    * one possible lexeme for this type of token.
    */
   final String lexeme;
 
-  const TokenType(this.name, [this._tokenClass = TokenClass.NO_CLASS,
-      this.lexeme = null]);
+  const TokenType(this.name,
+      [this._tokenClass = TokenClass.NO_CLASS, this.lexeme = null]);
 
   /**
    * Return `true` if this type of token represents an additive operator.
    */
   bool get isAdditiveOperator => _tokenClass == TokenClass.ADDITIVE_OPERATOR;
 
   /**
    * Return `true` if this type of token represents an assignment operator.
    */
   bool get isAssignmentOperator =>
       _tokenClass == TokenClass.ASSIGNMENT_OPERATOR;
 
   /**
    * Return `true` if this type of token represents an associative operator. An
    * associative operator is an operator for which the following equality is
    * true: `(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.
    *
    * 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.
    */
-  bool get isAssociativeOperator =>
-      this == AMPERSAND ||
-          this == AMPERSAND_AMPERSAND ||
-          this == BAR ||
-          this == BAR_BAR ||
-          this == CARET ||
-          this == PLUS ||
-          this == STAR;
+  bool get isAssociativeOperator => this == AMPERSAND ||
+      this == AMPERSAND_AMPERSAND ||
+      this == BAR ||
+      this == BAR_BAR ||
+      this == CARET ||
+      this == PLUS ||
+      this == STAR;
 
   /**
    * Return `true` if this type of token represents an equality operator.
    */
   bool get isEqualityOperator => _tokenClass == TokenClass.EQUALITY_OPERATOR;
 
   /**
    * Return `true` if this type of token represents an increment operator.
    */
   bool get isIncrementOperator =>
       identical(lexeme, "++") || identical(lexeme, "--");
 
   /**
    * Return `true` if this type of token represents a multiplicative operator.
    */
   bool get isMultiplicativeOperator =>
       _tokenClass == TokenClass.MULTIPLICATIVE_OPERATOR;
 
   /**
    * Return `true` if this token type represents an operator.
    */
-  bool get isOperator =>
-      _tokenClass != TokenClass.NO_CLASS &&
-          this != OPEN_PAREN &&
-          this != OPEN_SQUARE_BRACKET &&
-          this != PERIOD;
+  bool get isOperator => _tokenClass != TokenClass.NO_CLASS &&
+      this != OPEN_PAREN &&
+      this != OPEN_SQUARE_BRACKET &&
+      this != PERIOD;
 
   /**
    * Return `true` if this type of token represents a relational operator.
    */
   bool get isRelationalOperator =>
       _tokenClass == TokenClass.RELATIONAL_OPERATOR;
 
   /**
    * Return `true` if this type of token represents a shift operator.
    */
   bool get isShiftOperator => _tokenClass == TokenClass.SHIFT_OPERATOR;
 
   /**
    * Return `true` if this type of token represents a unary postfix operator.
    */
   bool get isUnaryPostfixOperator =>
       _tokenClass == TokenClass.UNARY_POSTFIX_OPERATOR;
 
   /**
    * Return `true` if this type of token represents a unary prefix operator.
    */
   bool get isUnaryPrefixOperator =>
       _tokenClass == TokenClass.UNARY_PREFIX_OPERATOR;
 
   /**
    * 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, "|");
 
   /**
    * Return the precedence of the token, or `0` if the token does not represent
    * an operator.
    */
   int get precedence => _tokenClass.precedence;
 
   @override
   String toString() => name;
 }
@@ skipping 27 matching lines @@
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   Token copy() => new TokenWithComment(type, offset, precedingComments);
 }