Incrementally resolve only update to dartdocs, fail if add/remove.

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 'ast.dart';
@@ skipping 1194 matching lines @@
         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;
           _updateEndNew = endOffsetNew;
           _updateDelta = newUnit.length - oldUnit.length;
           // A Dart documentation comment change.
           if (firstPair.kind == _TokenDifferenceKind.COMMENT_DOC) {
-            _resolveComment(oldUnit, newUnit, firstPair);
-            logger.log('Success.');
-            return true;
+            bool success = _resolveComment(oldUnit, newUnit, firstPair);
+            logger.log('Documentation comment resolved: $success');
+            return success;
           }
           // A pure whitespace change.
           if (firstPair.kind == _TokenDifferenceKind.OFFSET) {
             logger.log('Whitespace change.');
             _shiftTokens(firstPair.oldToken);
             {
               IncrementalResolver incrementalResolver = new IncrementalResolver(
                   _unitElement,
                   _updateOffset,
                   _updateEndOld,
@@ skipping 98 matching lines @@
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(_unitSource, errorListener);
       CompilationUnit unit = parser.parseCompilationUnit(token);
       _newParseErrors = errorListener.errors;
       return unit;
     } finally {
       timer.stop('parse');
     }
   }
 
-  void _resolveComment(CompilationUnit oldUnit, CompilationUnit newUnit,
+  /**
+   * Attempts to resolve a documentation comment change.
+   * Returns `true` if success.
+   */
+  bool _resolveComment(CompilationUnit oldUnit, CompilationUnit newUnit,
       _TokenPair firstPair) {
     Token oldToken = firstPair.oldToken;
-    CommentToken precedingComments = oldToken.precedingComments;
-    int offset = precedingComments.offset;
+    Token newToken = firstPair.newToken;
+    CommentToken oldComments = oldToken.precedingComments;
+    CommentToken newComments = newToken.precedingComments;
+    if (oldComments == null || newComments == null) {
+      return false;
+    }
+    // find nodes
+    int offset = oldComments.offset;
     logger.log('offset: $offset');
     Comment oldComment = _findNodeCovering(oldUnit, offset, offset);
     Comment newComment = _findNodeCovering(newUnit, offset, offset);
     logger.log('oldComment.beginToken: ${oldComment.beginToken}');
     logger.log('newComment.beginToken: ${newComment.beginToken}');
     _updateOffset = oldToken.offset - 1;
     // update token references
     _shiftTokens(firstPair.oldToken);
     _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
     // update elements
     IncrementalResolver incrementalResolver = new IncrementalResolver(
         _unitElement,
         _updateOffset,
         _updateEndOld,
         _updateEndNew);
     incrementalResolver._updateElementNameOffsets();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
+    // OK
+    return true;
   }
 
   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;
   }
@@ skipping 419 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }