Consider adding/editing a method as a resolvable mismatch.

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 10 matching lines @@
 import 'utilities_dart.dart';
 
 
 /**
  * If `true`, an attempt to resolve API-changing modifications is made.
  */
 bool _resolveApiChanges = false;
 
 
 /**
+ * This method is used to enable/disable API-changing modifications resolution.
+ */
+void set test_resolveApiChanges(bool value) {
+  _resolveApiChanges = value;
+}
+
+
+/**
  * Instances of the class [DeclarationMatcher] determine whether the element
  * model defined by a given AST structure matches an existing element model.
  */
 class DeclarationMatcher extends RecursiveAstVisitor {
   /**
    * The libary containing the AST nodes being visited.
    */
   LibraryElement _enclosingLibrary;
 
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not
    * in the scope of a class.
    */
-  ClassElement _enclosingClass;
+  ClassElementImpl _enclosingClass;
 
   /**
    * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   FieldDeclaration _enclosingFieldNode = null;
   bool _inTopLevelVariableDeclaration = false;
 
   /**
    * Is `true` if the current class declaration has a constructor.
    */
   bool _hasConstructor = false;
 
   /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited.
    */
   HashSet<Element> _allElements = new HashSet<Element>();
 
   /**
-   * A set containing all of the elements in the element model that were defined by the old AST node
-   * corresponding to the AST node being visited that have not already been matched to nodes in the
-   * AST structure being visited.
+   * A set containing all of the elements were defined in the old element model,
+   * but are not defined in the new element model.
    */
-  HashSet<Element> _unmatchedElements = new HashSet<Element>();
+  HashSet<Element> _removedElements = new HashSet<Element>();
 
   /**
-   * Return `true` if the declarations within the given AST structure define an element model
-   * that is equivalent to the corresponding elements rooted at the given element.
-   *
-   * @param node the AST structure being compared to the element model
-   * @param element the root of the element model being compared to the AST structure
-   * @return `true` if the AST structure defines the same elements as those in the given
-   *         element model
+   * A set containing all of the elements are defined in the new element model,
+   * but were not defined in the old element model.
    */
-  bool matches(AstNode node, Element element) {
+  HashSet<Element> _addedElements = new HashSet<Element>();
+
+  /**
+   * Determines how elements model corresponding to the given [node] differs
+   * from the [element].
+   */
+  DeclarationMatchKind matches(AstNode node, Element element) {
     logger.enter('match $element @ ${element.nameOffset}');
     try {
       _captureEnclosingElements(element);
       _gatherElements(element);
       node.accept(this);
     } on _DeclarationMismatchException catch (exception) {
-      return false;
+      return DeclarationMatchKind.MISMATCH;
     } finally {
       logger.exit();
     }
-    return _unmatchedElements.isEmpty;
+    // no API changes
+    if (_removedElements.isEmpty && _addedElements.isEmpty) {
+      return DeclarationMatchKind.MATCH;
+    }
+    // simple API change
+    if (_removedElements.length <= 1 && _addedElements.length == 1) {
+      return DeclarationMatchKind.MISMATCH_OK;
+    }
+    // something more complex
+    return DeclarationMatchKind.MISMATCH;
   }
 
   @override
   visitBlockFunctionBody(BlockFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     String name = node.name.name;
@@ skipping 189 matching lines @@
     }
     // prepare element
     Token property = node.propertyKeyword;
     ExecutableElementImpl element;
     if (property == null) {
       element = _findElement(_enclosingClass.methods, name);
     } else {
       element = _findElement(_enclosingClass.accessors, name);
     }
     // process element
-    _processElement(element);
-    _assertEquals(node.isStatic, element.isStatic);
-    _assertSameType(node.returnType, element.returnType);
-    _assertCompatibleParameters(node.parameters, element.parameters);
-    // matches, update the existing element
     ExecutableElement newElement = node.element;
-    node.name.staticElement = element;
-    _setLocalElements(element, newElement);
-    _setParameterElements(node.parameters, element.parameters);
+    try {
+      _assertNotNull(element);
+      _assertEquals(node.isStatic, element.isStatic);
+      _assertSameType(node.returnType, element.returnType);
+      _assertCompatibleParameters(node.parameters, element.parameters);
+      _removedElements.remove(element);
+      // matches, update the existing element
+      node.name.staticElement = element;
+      _setLocalElements(element, newElement);
+      _setParameterElements(node.parameters, element.parameters);
+    } on _DeclarationMismatchException catch (e) {
+      _addedElements.add(newElement);
+      // remove old element
+      if (element is MethodElement) {
+        _enclosingClass.methods.remove(element);
+      } else if (element is PropertyAccessorElement) {
+        _enclosingClass.accessors.remove(element);
+      }
+      // add new element
+      if (newElement is MethodElement) {
+        List<MethodElement> methods = _enclosingClass.methods;
+        methods.add(newElement);
+        _enclosingClass.methods = methods;
+      } else {
+        List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
+        accessors.add(newElement);
+        _enclosingClass.accessors = accessors;
+      }
+    }
   }
 
   @override
   visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       CompilationUnitElement element =
           _findUriReferencedElement(_enclosingLibrary.parts, uri);
       _processElement(element);
     }
@@ skipping 248 matching lines @@
       gatherer.addElements(_enclosingLibrary.exports);
       gatherer.addElements(_enclosingLibrary.parts);
     }
   }
 
   void _processElement(Element element) {
     _assertNotNull(element);
     if (!_allElements.contains(element)) {
       throw new _DeclarationMismatchException();
     }
-    _unmatchedElements.remove(element);
+    _removedElements.remove(element);
   }
 
   /**
    * Return the [Element] in [elements] with the given [name].
    */
   static Element _findElement(List<Element> elements, String name) {
     for (Element element in elements) {
       if (element.name == name) {
         return element;
       }
@@ skipping 43 matching lines @@
         node.identifier.staticElement = element;
         (element as ElementImpl).name = newElement.name;
         (element as ElementImpl).nameOffset = newElement.nameOffset;
       }
     }
   }
 }
 
 
 /**
+ * Describes how declarations match an existing elements model.
+ */
+class DeclarationMatchKind {
+  /**
+   * Complete match, no API changes.
+   */
+  static const MATCH = const DeclarationMatchKind('MATCH');
+
+  /**
+   * Has API changes that we might be able to resolve incrementally.
+   */
+  static const MISMATCH_OK = const DeclarationMatchKind('MISMATCH_OK');
+
+  /**
+   * Has API changes that we cannot resolve incrementally.
+   */
+  static const MISMATCH = const DeclarationMatchKind('MISMATCH');
+
+  final String name;
+
+  const DeclarationMatchKind(this.name);
+
+  @override
+  String toString() => name;
+}
+
+
+/**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The object used to access the types from the core library.
    */
   final TypeProvider _typeProvider;
 
   /**
@@ skipping 129 matching lines @@
     // check the whole enclosing Element.
     if (node is Declaration) {
       node = node.parent;
     }
     Element element = _getElement(node);
     if (element == null) {
       throw new AnalysisException(
           "Cannot resolve node: a ${node.runtimeType} does not define an element");
     }
     DeclarationMatcher matcher = new DeclarationMatcher();
-    return !matcher.matches(node, element);
+    return matcher.matches(node, element) != DeclarationMatchKind.MATCH;
   }
 
   /**
    * Starting at [node], find the smallest AST node that can be resolved
    * independently of any other nodes. Return the node that was found.
    *
    * [node] - the node at which the search is to begin
    *
    * Throws [AnalysisException] if there is no such node.
    */
@@ skipping 771 matching lines @@
     // Don't visit children (such as property accessors).
   }
 
   @override
   visitTypeParameterElement(TypeParameterElement element) {
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
-      matcher._unmatchedElements.add(element);
+      matcher._removedElements.add(element);
     }
   }
 }
 
 
 /**
  * Describes how two [Token]s are different.
  */
 class _TokenDifferenceKind {
   static const COMMENT = const _TokenDifferenceKind('COMMENT');
   static const COMMENT_DOC = const _TokenDifferenceKind('COMMENT_DOC');
   static const CONTENT = const _TokenDifferenceKind('CONTENT');
   static const OFFSET = const _TokenDifferenceKind('OFFSET');
 
   final String name;
 
   const _TokenDifferenceKind(this.name);
 
   @override
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }