Fix for incremental resolution in case of inserting a new token into elegant 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/services/lint.dart';
@@ skipping 1152 matching lines @@
   CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
   int _updateEndNew;
 
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
 
-  PoorMansIncrementalResolver(this._typeProvider, this._unitSource,
-      this._entry, this._oldUnit, bool resolveApiChanges) {
+  PoorMansIncrementalResolver(this._typeProvider, this._unitSource, this._entry,
+      this._oldUnit, bool resolveApiChanges) {
     _resolveApiChanges = resolveApiChanges;
   }
 
   /**
    * Attempts to update [_oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [_oldUnit] might be damaged.
    */
   bool resolve(String newCode) {
     logger.enter('diff/resolve $_unitSource');
@@ skipping 234 matching lines @@
    */
   static bool _areCurlyBracketsBalanced(Token token) {
     int numOpen = _getTokenCount(token, TokenType.OPEN_CURLY_BRACKET);
     int numOpen2 =
         _getTokenCount(token, TokenType.STRING_INTERPOLATION_EXPRESSION);
     int numClosed = _getTokenCount(token, TokenType.CLOSE_CURLY_BRACKET);
     return numOpen + numOpen2 == numClosed;
   }
 
   static _TokenDifferenceKind _compareToken(Token oldToken, Token newToken,
-      int delta) {
-    if (oldToken == null && newToken == null) {
-      return null;
-    }
-    if (oldToken == null || newToken == null) {
-      return _TokenDifferenceKind.CONTENT;
-    }
-    if (oldToken.type != newToken.type) {
-      return _TokenDifferenceKind.CONTENT;
-    }
-    if (oldToken.lexeme != newToken.lexeme) {
-      return _TokenDifferenceKind.CONTENT;
-    }
-    if (newToken.offset - oldToken.offset != delta) {
-      return _TokenDifferenceKind.OFFSET;
+      int delta, bool forComment) {
+    while (true) {
+      if (oldToken == null && newToken == null) {
+        return null;
+      }
+      if (oldToken == null || newToken == null) {
+        return _TokenDifferenceKind.CONTENT;
+      }
+      if (oldToken.type != newToken.type) {
+        return _TokenDifferenceKind.CONTENT;
+      }
+      if (oldToken.lexeme != newToken.lexeme) {
+        return _TokenDifferenceKind.CONTENT;
+      }
+      if (newToken.offset - oldToken.offset != delta) {
+        return _TokenDifferenceKind.OFFSET;
+      }
+      // continue if comment tokens are being checked
+      if (!forComment) {
+        break;
+      }
+      oldToken = oldToken.next;
+      newToken = newToken.next;
     }
     return null;
   }
 
   static _TokenPair _findFirstDifferentToken(Token oldToken, Token newToken) {
     while (true) {
       if (oldToken.type == TokenType.EOF && newToken.type == TokenType.EOF) {
         return null;
       }
       if (oldToken.type == TokenType.EOF || newToken.type == TokenType.EOF) {
         return new _TokenPair(_TokenDifferenceKind.CONTENT, oldToken, newToken);
       }
       // compare comments
       {
         Token oldComment = oldToken.precedingComments;
         Token newComment = newToken.precedingComments;
-        if (_compareToken(oldComment, newComment, 0) != null) {
+        if (_compareToken(oldComment, newComment, 0, true) != null) {
           _TokenDifferenceKind diffKind = _TokenDifferenceKind.COMMENT;
           if (oldComment is DocumentationCommentToken ||
               newComment is DocumentationCommentToken) {
             diffKind = _TokenDifferenceKind.COMMENT_DOC;
           }
           return new _TokenPair(diffKind, oldToken, newToken);
         }
       }
       // compare tokens
-      _TokenDifferenceKind diffKind = _compareToken(oldToken, newToken, 0);
+      _TokenDifferenceKind diffKind =
+          _compareToken(oldToken, newToken, 0, false);
       if (diffKind != null) {
         return new _TokenPair(diffKind, oldToken, newToken);
       }
       // next tokens
       oldToken = oldToken.next;
       newToken = newToken.next;
     }
     // no difference
     return null;
   }
 
   static _TokenPair _findLastDifferentToken(Token oldToken, Token newToken) {
     int delta = newToken.offset - oldToken.offset;
     while (oldToken.previous != oldToken && newToken.previous != newToken) {
       // compare tokens
-      _TokenDifferenceKind diffKind = _compareToken(oldToken, newToken, delta);
+      _TokenDifferenceKind diffKind =
+          _compareToken(oldToken, newToken, delta, false);
       if (diffKind != null) {
         return new _TokenPair(diffKind, oldToken.next, newToken.next);
       }
       // compare comments
       {
         Token oldComment = oldToken.precedingComments;
         Token newComment = newToken.precedingComments;
-        if (_compareToken(oldComment, newComment, delta) != null) {
+        if (_compareToken(oldComment, newComment, delta, true) != null) {
           _TokenDifferenceKind diffKind = _TokenDifferenceKind.COMMENT;
           if (oldComment is DocumentationCommentToken ||
               newComment is DocumentationCommentToken) {
             diffKind = _TokenDifferenceKind.COMMENT_DOC;
           }
           return new _TokenPair(diffKind, oldToken, newToken);
         }
       }
       // next tokens
       oldToken = oldToken.previous;
@@ skipping 330 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }