Don't throw an exception when model is changed.

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 653 matching lines @@
   IncrementalResolver(this._typeProvider, this._definingUnit,
       this._updateOffset, this._updateOldLength, this._updateNewLength) {
     _definingLibrary = _definingUnit.library;
     _source = _definingUnit.source;
   }
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
+   *
+   * Returns `true` if resolution was successful.
    */
-  void resolve(AstNode node) {
+  bool resolve(AstNode node) {
     logger.enter('resolve: $_definingUnit');
     try {
       logger.log(() => 'node: $node');
       AstNode rootNode = _findResolutionRoot(node);
       logger.log(() => 'rootNode: $rootNode');
       // update elements
       _updateElementNameOffsets(
           _definingUnit,
           _updateOffset,
           _updateNewLength - _updateOldLength);
       if (_elementModelChanged(rootNode)) {
-        throw new AnalysisException(
-            "Cannot resolve node: element model changed");
+        return false;
       }
       _updateElements(rootNode);
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
+      // OK
+      return true;
     } finally {
       logger.exit();
     }
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other
    * nodes.
    *
    * *Note*: This method needs to be kept in sync with
@@ skipping 351 matching lines @@
           _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
         CompilationUnitElement oldUnitElement = oldUnit.element;
         IncrementalResolver incrementalResolver = new IncrementalResolver(
             _typeProvider,
             oldUnitElement,
             _updateOffset,
             oldNode.length,
             newNode.length);
-        incrementalResolver.resolve(newNode);
+        bool success = incrementalResolver.resolve(newNode);
+        // check if success
+        if (!success) {
+          logger.log('Failure: element model changed.');
+          return false;
+        }
+        // update DartEntry
         _newResolveErrors = incrementalResolver._resolveErrors;
         _newVerifyErrors = incrementalResolver._verifyErrors;
         _newHints = incrementalResolver._hints;
         _updateEntry();
         logger.log('Success.');
         return true;
       }
     } catch (e, st) {
       logger.log(e);
       logger.log(st);
@@ skipping 569 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }