Updated detached tokens of references in documentation comments.

pkg/analyzer/lib/src/generated/incremental_resolver.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.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/error_verifier.dart';
@@ skipping 923 matching lines @@
         int beginOffsetNew = math.min(firstOffsetNew, lastOffsetNew);
         int endOffsetNew = math.max(firstOffsetNew, lastOffsetNew);
         // check for a whitespace only change
         if (identical(lastPair.oldToken, firstPair.oldToken) &&
             identical(lastPair.newToken, firstPair.newToken)) {
           _updateOffset = beginOffsetOld - 1;
           _updateEndOld = endOffsetOld;
           _updateDelta = newUnit.length - oldUnit.length;
           if (firstPair.atComment && lastPair.atComment) {
             _resolveComment(oldUnit, newUnit, firstPair);
+          } else {
+            _shiftTokens(firstPair.oldToken);
+            IncrementalResolver._updateElementNameOffsets(
+                oldUnit.element,
+                _updateOffset,
+                _updateDelta);
+            _updateEntry();
           }
-          _shiftTokens(firstPair.oldToken, _updateDelta);
-          IncrementalResolver._updateElementNameOffsets(
-              oldUnit.element,
-              _updateOffset,
-              _updateDelta);
-          _updateEntry();
           return true;
         }
         // Find nodes covering the "old" and "new" token ranges.
         AstNode oldNode =
             _findNodeCovering(oldUnit, beginOffsetOld, endOffsetOld);
         AstNode newNode =
             _findNodeCovering(newUnit, beginOffsetNew, endOffsetNew);
 //        print('oldNode: $oldNode');
 //        print('newNode: $newNode');
         // Try to find the smallest common node, a FunctionBody currently.
@@ skipping 36 matching lines @@
         // update token references
         {
           Token oldBeginToken = _getBeginTokenNotComment(oldNode);
           Token newBeginToken = _getBeginTokenNotComment(newNode);
           if (oldBeginToken.previous.type == TokenType.EOF) {
             oldUnit.beginToken = newBeginToken;
           } else {
             oldBeginToken.previous.setNext(newBeginToken);
           }
           newNode.endToken.setNext(oldNode.endToken.next);
-          _shiftTokens(oldNode.endToken.next, _updateDelta);
+          _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
         CompilationUnitElement oldUnitElement = oldUnit.element;
         IncrementalResolver incrementalResolver = new IncrementalResolver(
             _typeProvider,
             oldUnitElement,
             _updateOffset,
             oldNode.length,
             newNode.length);
         incrementalResolver.resolve(newNode);
@@ skipping 20 matching lines @@
     _newParseErrors = errorListener.errors;
     return unit;
   }
 
   void _resolveComment(CompilationUnit oldUnit, CompilationUnit newUnit,
       _TokenPair firstPair) {
     Token oldToken = firstPair.oldToken;
     int offset = oldToken.precedingComments.offset;
     Comment oldComment = _findNodeCovering(oldUnit, offset, offset);
     Comment newComment = _findNodeCovering(newUnit, offset, offset);
-    _updateOffset = offset + 1;
+    _updateOffset = oldToken.offset - 1;
+    // update token references
+    _shiftTokens(firstPair.oldToken);
+    _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
-    // update token references
-    _setPrecedingComments(oldToken, newComment.tokens.first);
+    // update elements
+    IncrementalResolver._updateElementNameOffsets(
+        oldUnit.element,
+        _updateOffset,
+        _updateDelta);
+    _updateEntry();
     // resolve references in the comment
     CompilationUnitElement oldUnitElement = oldUnit.element;
     IncrementalResolver incrementalResolver =
         new IncrementalResolver(_typeProvider, oldUnitElement, _updateOffset, 0, 0);
     incrementalResolver._resolveReferences(newComment);
   }
 
   Token _scan(String code) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     CharSequenceReader reader = new CharSequenceReader(code);
     Scanner scanner = new Scanner(_unitSource, reader, errorListener);
     Token token = scanner.tokenize();
     _newScanErrors = errorListener.errors;
     return token;
   }
 
-  void _shiftTokens(Token token, int delta) {
+  void _shiftTokens(Token token) {
     while (token != null) {
       if (token.offset > _updateOffset) {
-        token.offset += delta;
+        token.offset += _updateDelta;
       }
-      _shiftTokens(token.precedingComments, delta);
+      // comments
+      _shiftTokens(token.precedingComments);
+      if (token is CommentToken) {
+        for (Token reference in token.references) {
+          _shiftTokens(reference);
+        }
+      }
+      // next
       if (token.type == TokenType.EOF) {
         break;
       }
       token = token.next;
     }
   }
 
   void _updateEntry() {
     _entry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
     _entry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
@@ skipping 444 matching lines @@
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   final bool atComment;
   _TokenPair(this.oldToken, this.newToken, [this.atComment = false]);
 }