Issue 22644. Fix for removing non-Dartdoc comments before a declaration.

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 1171 matching lines @@
         int endOffsetOld = math.max(firstOffsetOld, lastOffsetOld);
         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;
           _updateEndNew = endOffsetNew;
           _updateDelta = newUnit.length - _oldUnit.length;
+          // A comment change.
+          if (firstPair.kind == _TokenDifferenceKind.COMMENT) {
+            bool success = _resolveComment(newUnit, firstPair);
+            logger.log('Comment change: $success');
+            return success;
+          }
           // A Dart documentation comment change.
           if (firstPair.kind == _TokenDifferenceKind.COMMENT_DOC) {
-            bool success = _resolveComment(_oldUnit, newUnit, firstPair);
+            bool success = _resolveCommentDoc(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, _updateEndNew);
@@ skipping 97 matching lines @@
       Parser parser = new Parser(_unitSource, errorListener);
       CompilationUnit unit = parser.parseCompilationUnit(token);
       _newParseErrors = errorListener.errors;
       return unit;
     } finally {
       timer.stop('parse');
     }
   }
 
   /**
+   * Attempts to resolve a comment change.
+   * Returns `true` if success.
+   */
+  bool _resolveComment(CompilationUnit newUnit, _TokenPair firstPair) {
+    Token oldToken = firstPair.oldToken;
+    Token newToken = firstPair.newToken;
+    CommentToken newComments = newToken.precedingComments;
+    // update token references
+    _updateOffset = oldToken.offset - 1;
+    _shiftTokens(firstPair.oldToken);
+    _setPrecedingComments(oldToken, newComments);
+    // update elements
+    IncrementalResolver incrementalResolver = new IncrementalResolver(
+        _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
+    incrementalResolver._updateElementNameOffsets();
+    incrementalResolver._shiftEntryErrors();
+    _updateEntry();
+    // OK
+    return true;
+  }
+
+  /**
    * Attempts to resolve a documentation comment change.
    * Returns `true` if success.
    */
-  bool _resolveComment(
-      CompilationUnit oldUnit, CompilationUnit newUnit, _TokenPair firstPair) {
+  bool _resolveCommentDoc(CompilationUnit newUnit, _TokenPair firstPair) {
     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);
+    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
@@ skipping 10 matching lines @@
 
   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;
   }
 
+  /**
+   * Set the given [comment] as a "precedingComments" for [token].
+   */
+  void _setPrecedingComments(Token token, CommentToken comment) {
+    if (token is BeginTokenWithComment) {
+      token.precedingComments = comment;
+    } else if (token is KeywordTokenWithComment) {
+      token.precedingComments = comment;
+    } else if (token is KeywordToken) {
+      KeywordTokenWithComment newToken =
+          new KeywordTokenWithComment(token.keyword, token.offset, comment);
+      token.previous.setNext(newToken);
+      newToken.setNext(token.next);
+      if (_oldUnit.beginToken == token) {
+        _oldUnit.beginToken = newToken;
+      }
+    } else if (token is StringTokenWithComment) {
+      token.precedingComments = comment;
+    } else if (token is StringToken) {
+      StringTokenWithComment newToken = new StringTokenWithComment(
+          token.type, token.value(), token.offset, comment);
+      token.previous.setNext(newToken);
+      newToken.setNext(token.next);
+      if (_oldUnit.beginToken == token) {
+        _oldUnit.beginToken = newToken;
+      }
+    } else if (token is TokenWithComment) {
+      token.precedingComments = comment;
+    } else {
+      Type parentType = token != null ? token.runtimeType : null;
+      throw new AnalysisException('Uknown parent token type: $parentType');
+    }
+  }
+
   void _shiftTokens(Token token) {
     while (token != null) {
       if (token.offset > _updateOffset) {
         token.offset += _updateDelta;
       }
       // comments
       _shiftTokens(token.precedingComments);
       if (token is DocumentationCommentToken) {
         for (Token reference in token.references) {
           _shiftTokens(reference);
@@ skipping 143 matching lines @@
   static int _getTokenCount(Token token, TokenType type) {
     int count = 0;
     while (token.type != TokenType.EOF) {
       if (token.type == type) {
         count++;
       }
       token = token.next;
     }
     return count;
   }
-
-  /**
-   * Set the given [comment] as a "precedingComments" for [parent].
-   */
-  static void _setPrecedingComments(Token parent, CommentToken comment) {
-    if (parent is BeginTokenWithComment) {
-      parent.precedingComments = comment;
-    } else if (parent is KeywordTokenWithComment) {
-      parent.precedingComments = comment;
-    } else if (parent is StringTokenWithComment) {
-      parent.precedingComments = comment;
-    } else if (parent is TokenWithComment) {
-      parent.precedingComments = comment;
-    } else {
-      Type parentType = parent != null ? parent.runtimeType : null;
-      throw new AnalysisException('Uknown parent token type: $parentType');
-    }
-  }
 }
 
 /**
  * The context to resolve an [AstNode] in.
  */
 class ResolutionContext {
   CompilationUnitElement enclosingUnit;
   ClassDeclaration enclosingClassDeclaration;
   ClassElement enclosingClass;
   Scope scope;
@@ skipping 250 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }