A whitespace-only change can be incremental anywhere.

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 652 matching lines @@
       this._updateNewLength);
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
     // update elements
-    _definingUnit.accept(
-        new _ElementNameOffsetUpdater(
-            _updateOffset,
-            _updateNewLength - _updateOldLength));
+    _updateElementNameOffsets(
+        _definingUnit,
+        _updateOffset,
+        _updateNewLength - _updateOldLength);
     if (_elementModelChanged(rootNode)) {
       throw new AnalysisException("Cannot resolve node: element model changed");
     }
     _updateElements(rootNode);
     // resolve
     _resolveReferences(rootNode);
     // verify
     _verify(rootNode);
     _generateHints(rootNode);
   }
@@ skipping 184 matching lines @@
         _definingLibrary,
         _typeProvider,
         new InheritanceManager(_definingLibrary));
     if (_resolutionContext.enclosingClassDeclaration != null) {
       errorVerifier.visitClassDeclarationIncrementally(
           _resolutionContext.enclosingClassDeclaration);
     }
     node.accept(errorVerifier);
     _verifyErrors = errorListener.getErrorsForSource(_source);
   }
+
+  static void _updateElementNameOffsets(Element root, int offset, int delta) {
+    root.accept(new _ElementNameOffsetUpdater(offset, delta));
+  }
 }
 
 
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
   final Source _unitSource;
   final Source _librarySource;
   final DartEntry _entry;
 
   int _updateOffset;
@@ skipping 24 matching lines @@
           _findLastDifferentToken(oldUnit.endToken, newUnit.endToken);
       if (firstPair != null && lastPair != null) {
         int firstOffsetOld = firstPair.oldToken.offset;
         int firstOffsetNew = firstPair.newToken.offset;
         int lastOffsetOld = lastPair.oldToken.end;
         int lastOffsetNew = lastPair.newToken.end;
         int beginOffsetOld = math.min(firstOffsetOld, lastOffsetOld);
         int endOffsetOld = math.max(firstOffsetOld, lastOffsetOld);
         int beginOffsetNew = math.min(firstOffsetNew, lastOffsetNew);
         int endOffsetNew = math.max(firstOffsetNew, lastOffsetNew);
+        // check for a whitespace only change

[Brian Wilkerson, 2014/11/26 23:22:37]

Does this handle changes in dartdoc comments? Changes in dartdoc comments should
not be considered to be whitespace changes because they do get resolved.

/** [A] */
class A {}
class B {}

becomes:

/** [A] and [B] */
class A {}
class B {}

[scheglov, 2014/11/26 23:25:37]

Not yet.
Support for incremental resolving dartdoc comments will follow.

+        if (identical(lastPair.oldToken, firstPair.oldToken) &&
+            identical(lastPair.newToken, firstPair.newToken)) {
+          _updateOffset = beginOffsetOld - 1;
+          _updateEndOld = endOffsetOld;
+          _updateDelta = newUnit.length - oldUnit.length;
+          _shiftTokens(firstPair.oldToken, _updateDelta);
+          IncrementalResolver._updateElementNameOffsets(
+              oldUnit.element,
+              _updateOffset,
+              _updateDelta);
+          _updateEntry();
+          return true;
+        }
 //        print('beginOffsetOld: $beginOffsetOld endOffsetOld: $endOffsetOld');
 //        print('beginOffsetNew: $beginOffsetNew endOffsetNew: $endOffsetNew');
         // 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 55 matching lines @@
             oldNode.length,
             newNode.length);
         incrementalResolver.resolve(newNode);
         _newResolveErrors = incrementalResolver._resolveErrors;
         _newVerifyErrors = incrementalResolver._verifyErrors;
         _newHints = incrementalResolver._hints;
         _updateEntry();
 //        print('Successfully incrementally resolved.');
         return true;
       }
-    } catch (e, st) {
+    } catch (e) {
       // TODO(scheglov) find a way to log these exceptions
-      print(e);
-      print(st);
+//      print(e);
+//      print(st);
     }
     return false;
   }
 
   CompilationUnit _parseUnit(String code) {
     Token token = _scan(code);
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Parser parser = new Parser(_unitSource, errorListener);
     CompilationUnit unit = parser.parseCompilationUnit(token);
     _newParseErrors = errorListener.errors;
@@ skipping 86 matching lines @@
     return null;
   }
 
   static _TokenPair _findLastDifferentToken(Token oldToken, Token newToken) {
 //    print('last ------------');
     int delta = newToken.offset - oldToken.offset;
     while (oldToken.previous != oldToken && newToken.previous != newToken) {
 //      print('old: $oldToken @ ${oldToken.offset}');
 //      print('new: $newToken @ ${newToken.offset}');
       if (!_equalToken(oldToken, newToken, delta)) {
-        return new _TokenPair(oldToken, newToken);
+        return new _TokenPair(oldToken.next, newToken.next);
       }
       oldToken = oldToken.previous;
       newToken = newToken.previous;
     }
     return null;
   }
 
   static AstNode _findNodeCovering(AstNode root, int offset, int end) {
     NodeLocator nodeLocator = new NodeLocator.con2(offset, end);
     return nodeLocator.searchWithin(root);
@@ skipping 316 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }