Fix issue 22525

pkg/analyzer/lib/src/generated/parser.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.
 
 // 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.parser;
 
 import "dart:math" as math;
@@ skipping 4077 matching lines @@
 
   /**
    * Create a synthetic token with the given type.
    *
    * @return the synthetic token that was created
    */
   Token _createSyntheticToken(TokenType type) =>
       _injectToken(new StringToken(type, "", _currentToken.offset));
 
   /**
+   * Create and return a new token with the given [type]. The token will replace
+   * the first portion of the given [token], so it will have the same offset and
+   * will have any comments that might have preceeded the token.
+   */
+  Token _createToken(Token token, TokenType type, {bool isBegin: false}) {
+    CommentToken comments = token.precedingComments;
+    if (comments == null) {
+      if (isBegin) {
+        return new BeginToken(type, token.offset);
+      }
+      return new Token(type, token.offset);
+    } else if (isBegin) {
+      return new BeginTokenWithComment(type, token.offset, comments);
+    }
+    return new TokenWithComment(type, token.offset, comments);
+  }
+
+  /**
    * Check that the given expression is assignable and report an error if it isn't.
    *
    * <pre>
    * assignableExpression ::=
    *     primary (arguments* assignableSelector)+
    *   | 'super' assignableSelector
    *   | identifier
    *
    * assignableSelector ::=
    *     '[' expression ']'
@@ skipping 477 matching lines @@
    * In particular, if the next token is either a '>>' or '>>>', the token stream will be re-written
    * and `true` will be returned.
    *
    * @return `true` if the current token has a type of [TokenType.GT]
    */
   bool _matchesGt() {
     TokenType currentType = _currentToken.type;
     if (currentType == TokenType.GT) {
       return true;
     } else if (currentType == TokenType.GT_GT) {
-      int offset = _currentToken.offset;
-      Token first = new Token(TokenType.GT, offset);
-      Token second = new Token(TokenType.GT, offset + 1);
+      Token first = _createToken(_currentToken, TokenType.GT);
+      Token second = new Token(TokenType.GT, _currentToken.offset + 1);
       second.setNext(_currentToken.next);
       first.setNext(second);
       _currentToken.previous.setNext(first);
       _currentToken = first;
       return true;
     } else if (currentType == TokenType.GT_EQ) {
-      int offset = _currentToken.offset;
-      Token first = new Token(TokenType.GT, offset);
-      Token second = new Token(TokenType.EQ, offset + 1);
+      Token first = _createToken(_currentToken, TokenType.GT);
+      Token second = new Token(TokenType.EQ, _currentToken.offset + 1);
       second.setNext(_currentToken.next);
       first.setNext(second);
       _currentToken.previous.setNext(first);
       _currentToken = first;
       return true;
     } else if (currentType == TokenType.GT_GT_EQ) {
       int offset = _currentToken.offset;
-      Token first = new Token(TokenType.GT, offset);
+      Token first = _createToken(_currentToken, TokenType.GT);
       Token second = new Token(TokenType.GT, offset + 1);
       Token third = new Token(TokenType.EQ, offset + 2);
       third.setNext(_currentToken.next);
       second.setNext(third);
       first.setNext(second);
       _currentToken.previous.setNext(first);
       _currentToken = first;
       return true;
     }
     return false;
@@ skipping 1453 matching lines @@
 
   EnumConstantDeclaration _parseEnumConstantDeclaration() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name;
     if (_matchesIdentifier()) {
       name = parseSimpleIdentifier();
     } else {
       name = _createSyntheticIdentifier();
     }
     if (commentAndMetadata.metadata.isNotEmpty) {
-      _reportErrorForNode(ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT, commentAndMetadata.metadata[0]);
+      _reportErrorForNode(
+          ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT,
+          commentAndMetadata.metadata[0]);
     }
     return new EnumConstantDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         name);
   }
 
   /**
    * Parse an enum declaration.
    *
@@ skipping 950 matching lines @@
    *          no modifier
    * @param typeArguments the type arguments appearing before the literal, or `null` if there
    *          are no type arguments
    * @return the list literal that was parsed
    */
   ListLiteral _parseListLiteral(Token modifier,
       TypeArgumentList typeArguments) {
     // may be empty list literal
     if (_matches(TokenType.INDEX)) {
       BeginToken leftBracket =
-          new BeginToken(TokenType.OPEN_SQUARE_BRACKET, _currentToken.offset);
+          _createToken(_currentToken, TokenType.OPEN_SQUARE_BRACKET, isBegin: true);
       Token rightBracket =
           new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
       leftBracket.endToken = rightBracket;
       rightBracket.setNext(_currentToken.next);
       leftBracket.setNext(rightBracket);
       _currentToken.previous.setNext(leftBracket);
       _currentToken = _currentToken.next;
       return new ListLiteral(
           modifier,
           typeArguments,
@@ skipping 1521 matching lines @@
           return new PrefixExpression(operator, _parseUnaryExpression());
         }
         //
         // Even though it is not valid to use an incrementing operator
         // ('++' or '--') before 'super', we can (and therefore must) interpret
         // "--super" as semantically equivalent to "-(-super)". Unfortunately,
         // we cannot do the same for "++super" because "+super" is also not
         // valid.
         //
         if (operator.type == TokenType.MINUS_MINUS) {
-          int offset = operator.offset;
-          Token firstOperator = new Token(TokenType.MINUS, offset);
-          Token secondOperator = new Token(TokenType.MINUS, offset + 1);
+          Token firstOperator = _createToken(operator, TokenType.MINUS);
+          Token secondOperator =
+              new Token(TokenType.MINUS, operator.offset + 1);
           secondOperator.setNext(_currentToken);
           firstOperator.setNext(secondOperator);
           operator.previous.setNext(firstOperator);
           return new PrefixExpression(
               firstOperator,
               new PrefixExpression(secondOperator, new SuperExpression(getAndAdvance())));
         } else {
           // Invalid operator before 'super'
           _reportErrorForCurrentToken(
               ParserErrorCode.INVALID_OPERATOR_FOR_SUPER,
@@ skipping 1397 matching lines @@
 
   static const ParserErrorCode ABSTRACT_TOP_LEVEL_VARIABLE =
       const ParserErrorCode(
           'ABSTRACT_TOP_LEVEL_VARIABLE',
           "Top-level variables cannot be declared to be 'abstract'");
 
   static const ParserErrorCode ABSTRACT_TYPEDEF = const ParserErrorCode(
       'ABSTRACT_TYPEDEF',
       "Type aliases cannot be declared to be 'abstract'");
 
-  static const ParserErrorCode ANNOTATION_ON_ENUM_CONSTANT = const ParserErrorCode(
-      'ANNOTATION_ON_ENUM_CONSTANT',
-      "Enum constants cannot have annotations");
+  static const ParserErrorCode ANNOTATION_ON_ENUM_CONSTANT =
+      const ParserErrorCode(
+          'ANNOTATION_ON_ENUM_CONSTANT',
+          "Enum constants cannot have annotations");
 
   static const ParserErrorCode ASSERT_DOES_NOT_TAKE_ASSIGNMENT =
       const ParserErrorCode(
           'ASSERT_DOES_NOT_TAKE_ASSIGNMENT',
           "Assert cannot be called on an assignment");
 
   static const ParserErrorCode ASSERT_DOES_NOT_TAKE_CASCADE =
       const ParserErrorCode(
           'ASSERT_DOES_NOT_TAKE_CASCADE',
           "Assert cannot be called on cascade");
@@ skipping 2092 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }