Try to resolve incrementally whole functions, constructors or methods.

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 877 matching lines @@
 //        print('newNode: $newNode');
         // Try to find the smallest common node, a FunctionBody currently.
         {
           List<AstNode> oldParents = _getParents(oldNode);
           List<AstNode> newParents = _getParents(newNode);
           int length = math.min(oldParents.length, newParents.length);
           bool found = false;
           for (int i = 0; i < length; i++) {
             AstNode oldParent = oldParents[i];
             AstNode newParent = newParents[i];
+            if (oldParent is FunctionDeclaration &&
+                newParent is FunctionDeclaration ||
+                oldParent is MethodDeclaration && newParent is MethodDeclaration ||
+                oldParent is ConstructorDeclaration && newParent is ConstructorDeclaration) {
+              oldNode = oldParent;
+              newNode = newParent;
+              found = true;
+            }
             if (oldParent is FunctionBody && newParent is FunctionBody) {
               oldNode = oldParent;
               newNode = newParent;
               found = true;
               break;
             }
           }
           if (!found) {
             return false;
           }
         }
         // prepare update range
         _updateOffset = oldNode.offset;
         _updateEndOld = oldNode.end;
         _updateEndNew = newNode.end;
         _updateDelta = _updateEndNew - _updateEndOld;
-//        _updateDelta = lastPair.delta;
         // replace node
         NodeReplacer.replace(oldNode, newNode);
         // update token references
-        oldNode.beginToken.previous.setNext(newNode.beginToken);
-        newNode.endToken.setNext(oldNode.endToken.next);
-        _shiftTokens(oldNode.endToken.next, _updateDelta);
+        {
+          Token oldBeginToken = oldNode.beginToken;
+          if (oldBeginToken.previous.type == TokenType.EOF) {
+            oldUnit.beginToken = newNode.beginToken;
+          } else {
+            oldBeginToken.previous.setNext(newNode.beginToken);
+          }
+          newNode.endToken.setNext(oldNode.endToken.next);
+          _shiftTokens(oldNode.endToken.next, _updateDelta);
+        }
         // perform incremental resolution
         CompilationUnitElement oldUnitElement = oldUnit.element;
         IncrementalResolver incrementalResolver = new IncrementalResolver(
             _typeProvider,
             oldUnitElement.library,
             oldUnitElement,
             oldUnitElement.source,
             _updateOffset,
             oldNode.length,
             newNode.length);
@@ skipping 323 matching lines @@
 
 class _ElementNameOffsetUpdater extends GeneralizingElementVisitor {
   final int updateOffset;
   final int updateDelta;
 
   _ElementNameOffsetUpdater(this.updateOffset, this.updateDelta);
 
   @override
   visitElement(Element element) {
     int nameOffset = element.nameOffset;
-    if (nameOffset >= updateOffset) {
+    if (nameOffset > updateOffset) {
       (element as ElementImpl).nameOffset = nameOffset + updateDelta;
     }
     super.visitElement(element);
   }
 }
 
 
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
@@ skipping 100 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }