Issue 25064. Incrementally resolve comments only if both are documentation.

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 analyzer.src.generated.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 579 matching lines @@
     }
     if (element is PropertyAccessorElement) {
       _assertTrue(node.name is SimpleIdentifier);
       String nodeName = node.name.name;
       String elementName = element.displayName;
       _assertEquals(nodeName, elementName);
     }
   }
 
   void _assertSameAnnotations(AnnotatedNode node, Element element) {
-    List<Annotation> nodeAnnotaitons = node.metadata;
+    List<Annotation> nodeAnnotations = node.metadata;
     List<ElementAnnotation> elementAnnotations = element.metadata;
-    int length = nodeAnnotaitons.length;
+    int length = nodeAnnotations.length;
     _assertEquals(elementAnnotations.length, length);
     for (int i = 0; i < length; i++) {
-      _assertSameAnnotation(nodeAnnotaitons[i], elementAnnotations[i]);
+      _assertSameAnnotation(nodeAnnotations[i], elementAnnotations[i]);
     }
   }
 
   void _assertSameType(TypeName node, DartType type) {
     // no type == dynamic
     if (node == null) {
       return _assertTrue(type == null || type.isDynamic);
     }
     if (type == null) {
       return _assertTrue(false);
@@ skipping 932 matching lines @@
         if (!success) {
           logger.log('Failure: element model changed.');
           return false;
         }
         // update DartEntry
         _updateEntry();
         logger.log('Success.');
         return true;
       }
     } catch (e, st) {
-      logger.log(e);
-      logger.log(st);
+      logger.logException(e, st);
       logger.log('Failure: exception.');

[skybrian, 2016/01/14 02:39:13]

Another suggestion:

+      // The incremental resolver log is usually turned off,
+      // so also log the exception to the instrumentation log.
+      AnalysisEngine.instance.logger.logError(
+          'failure in incremental resolver', new CaughtException(e, st));

     } finally {
       logger.exit();
     }
     return false;
   }
 
   CompilationUnit _parseUnit(String code) {
     LoggingTimer timer = logger.startTimer();
     try {
       Token token = _scan(code);
@@ skipping 17 matching lines @@
     Token oldToken = firstPair.oldToken;
     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);

[skybrian, 2016/01/14 02:33:11]

In addition, I suggest changing these two lines:

var oldComment = _findNodeCovering(_oldUnit, offset, offset) as Comment;
var newComment = _findNodeCovering(newUnit, offset, offset) as Comment;

That way the downcast will be checked in production.

[scheglov, 2016/01/14 03:19:29]

Done.

     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
@@ skipping 117 matching lines @@
       }
       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, true) != null) {
           _TokenDifferenceKind diffKind = _TokenDifferenceKind.COMMENT;
-          if (oldComment is DocumentationCommentToken ||
+          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, false);
       if (diffKind != null) {
@@ skipping 15 matching lines @@
           _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, true) != null) {
           _TokenDifferenceKind diffKind = _TokenDifferenceKind.COMMENT;
-          if (oldComment is DocumentationCommentToken ||
+          if (oldComment is DocumentationCommentToken &&
               newComment is DocumentationCommentToken) {
             diffKind = _TokenDifferenceKind.COMMENT_DOC;
           }
           return new _TokenPair(diffKind, oldToken, newToken);
         }
       }
       // next tokens
       oldToken = oldToken.previous;
       newToken = newToken.previous;
     }
@@ skipping 314 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }