Clone and link all tokens in AstCloner.

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 analyzer.src.generated.scanner;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 247 matching lines @@
   final List<Token> references = <Token>[];
 
   /**
    * Initialize a newly created token to represent a token of the given [type]
    * with the given [value] at the given [offset].
    */
   DocumentationCommentToken(TokenType type, String value, int offset)
       : super(type, value, offset);
 
   @override
-  CommentToken copy() => new DocumentationCommentToken(type, _value, offset);
+  CommentToken copy() {
+    DocumentationCommentToken copy =
+        new DocumentationCommentToken(type, _value, offset);
+    references.forEach((ref) => copy.references.add(ref.copy()));
+    return copy;
+  }
 }
 
 /**
  * The keywords in the Dart programming language.
  */
 class Keyword {
   static const Keyword ASSERT = const Keyword('ASSERT', "assert");
 
   static const Keyword BREAK = const Keyword('BREAK', "break");
 
@@ skipping 2294 matching lines @@
    * 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 ||
+  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 &&
+  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;
 
@@ skipping 11 matching lines @@
   /**
    * 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, "==") ||
+  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, "<<") ||
@@ skipping 45 matching lines @@
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   Token copy() => new TokenWithComment(type, offset, precedingComments);
 }