First step to resolving simple API changes.

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';
 import 'element.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
+import 'utilities_collection.dart';
 import 'utilities_dart.dart';
 
 
 /**
  * If `true`, an attempt to resolve API-changing modifications is made.
  */
 bool _resolveApiChanges = false;
 
 
 /**
@@ skipping 80 matching lines @@
     }
     // 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
+    logger.log('_removedElements: $_removedElements');
+    logger.log('_addedElements: $_addedElements');
     return DeclarationMatchKind.MISMATCH;
   }
 
   @override
   visitBlockFunctionBody(BlockFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
@@ skipping 383 matching lines @@
     if (type == null) {
       return _assertTrue(false);
     }
     // prepare name
     Identifier nameIdentifier = node.name;
     if (nameIdentifier is PrefixedIdentifier) {
       nameIdentifier = (nameIdentifier as PrefixedIdentifier).identifier;
     }
     String nodeName = nameIdentifier.name;
     // check specific type kinds
-    if (type is InterfaceType) {
+    if (type is ParameterizedType) {
       _assertEquals(nodeName, type.name);
       // check arguments
       TypeArgumentList nodeArgumentList = node.typeArguments;
       List<DartType> typeArguments = type.typeArguments;
       if (nodeArgumentList == null) {
         // Node doesn't have type arguments, so all type arguments of the
         // element must be "dynamic".
         for (DartType typeArgument in typeArguments) {
           _assertTrue(typeArgument.isDynamic);
         }
       } else {
         List<TypeName> nodeArguments = nodeArgumentList.arguments;
         _assertSameTypes(nodeArguments, typeArguments);
       }
     } else if (type is TypeParameterType) {
       _assertEquals(nodeName, type.name);
       // TODO(scheglov) it should be possible to rename type parameters
     } else if (type.isVoid) {
       _assertEquals(nodeName, 'void');
     } else if (type.isDynamic) {
       _assertEquals(nodeName, 'dynamic');
     } else {
       // TODO(scheglov) support other types
-//      print('node: $node type: $type  type.type: ${type.runtimeType}');
+      logger.log('node: $node type: $type  type.type: ${type.runtimeType}');
       _assertTrue(false);
     }
   }
 
   void _assertSameTypeParameter(TypeParameter node,
       TypeParameterElement element) {
     _assertSameType(node.bound, element.bound);
   }
 
   void _assertSameTypeParameters(TypeParameterList nodesList,
@@ skipping 199 matching lines @@
   final int _updateNewLength;
 
   RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
+   * The elements that should be resolved because of API changes.
+   */
+  HashSet<Element> _resolutionQueue = new HashSet<Element>();

[Brian Wilkerson, 2014/12/05 23:05:57]

I have some concerns about how long the incremental resolution task can take
once we go down this road. We have to be careful to keep the task durations
relatively short. It would be good to at least add a comment to remind us to
revisit this issue.

[scheglov, 2014/12/05 23:49:05]

Done.

+
+  /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
   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.
    */
   bool resolve(AstNode node) {
     logger.enter('resolve: $_definingUnit');
     try {
       logger.log(() => 'node: $node');
       AstNode rootNode = _findResolutionRoot(node);
       logger.log(() => 'rootNode: $rootNode');
       _prepareResolutionContext(rootNode);
       // update elements
       _updateElementNameOffsets(
           _definingUnit,
           _updateOffset,
           _updateNewLength - _updateOldLength);
       _buildElements(rootNode);
-      if (_elementModelChanged(rootNode)) {
+      if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
+      // resolve queue in response of API changes
+      _resolveQueue();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
 
   void _buildElements(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       node.accept(builder);
     } finally {
       timer.stop('build elements');
     }
   }
 
   /**
+   * Return `true` if [node] does not have element model changes, or these
+   * changes can be incrementally propagated.
+   */
+  bool _canBeIncrementallyResolved(AstNode node) {
+    // If we are replacing the whole declaration, this means that its signature
+    // is changed. It might be an API change, or not.
+    //
+    // If, for example, a required parameter is changed, it is not an API
+    // change, but we want to find the existing corresponding Element in the
+    // enclosing one, set it for the node and update as needed.
+    //
+    // If, for example, the name of a method is changed, it is an API change,
+    // we need to know the old Element and the new Element. Again, we need to
+    // check the whole enclosing Element.
+    if (node is Declaration) {
+      node = node.parent;
+    }
+    Element element = _getElement(node);
+    DeclarationMatcher matcher = new DeclarationMatcher();
+    DeclarationMatchKind matchKind = matcher.matches(node, element);
+    if (matchKind == DeclarationMatchKind.MATCH) {
+      return true;
+    }
+    // try to resolve a simple API change
+    if (_resolveApiChanges && matchKind == DeclarationMatchKind.MISMATCH_OK) {
+      _fillResolutionQueue(matcher);
+      return true;
+    }
+    // mismatch that cannot be incrementally fixed
+    return false;
+  }
+
+  /**
    * Return `true` if the given node can be resolved independently of any other
    * nodes.
    *
    * *Note*: This method needs to be kept in sync with
    * [ScopeBuilder.ContextBuilder].
    *
    * [node] - the node being tested.
    */
   bool _canBeResolved(AstNode node) =>
       node is ClassDeclaration ||
           node is ClassTypeAlias ||
           node is CompilationUnit ||
           node is ConstructorDeclaration ||
           node is FunctionDeclaration ||
           node is FunctionTypeAlias ||
           node is MethodDeclaration;
 
-  /**
-   * Return `true` if the portion of the element model defined by the given node
-   * has changed.
-   *
-   * [node] - the node defining the portion of the element model being tested.
-   *
-   * Throws [AnalysisException] if the correctness of the element model cannot
-   * be determined.
-   */
-  bool _elementModelChanged(AstNode node) {
-    // If we are replacing the whole declaration, this means that its signature
-    // is changed. It might be an API change, or not.
-    //
-    // If, for example, a required parameter is changed, it is not an API
-    // change, but we want to find the existing corresponding Element in the
-    // enclosing one, set it for the node and update as needed.
-    //
-    // If, for example, the name of a method is changed, it is an API change,
-    // we need to know the old Element and the new Element. Again, we need to
-    // check the whole enclosing Element.
-    if (node is Declaration) {
-      node = node.parent;
+  void _fillResolutionQueue(DeclarationMatcher matcher) {
+    for (Element removedElement in matcher._removedElements) {
+      AnalysisContextImpl context = removedElement.context;
+      IntSet users = removedElement.users;
+      while (!users.isEmpty) {
+        int id = users.remove();
+        Element removedElementUser = context.findElementById(id);
+        _resolutionQueue.add(removedElementUser);
+      }
     }
-    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) != DeclarationMatchKind.MATCH;
+    // TODO(scheglov) a method change might also require its class, and
+    // subclasses resolution
   }
 
   /**
    * 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 35 matching lines @@
     return null;
   }
 
   void _prepareResolutionContext(AstNode node) {
     if (_resolutionContext == null) {
       _resolutionContext =
           ResolutionContextBuilder.contextFor(node, errorListener);
     }
   }
 
+  /**
+   * Resolves elements [_resolutionQueue].
+   *
+   * TODO(scheglov) work in progress
+   */
+  void _resolveQueue() {
+    for (Element element in _resolutionQueue) {
+      // TODO(scheglov) in general, we should not call Element.node, it
+      // might perform complete unit resolution.
+      AstNode node = element.node;
+      CompilationUnitElement unit =
+          element.getAncestor((e) => e is CompilationUnitElement);
+      IncrementalResolver resolver =
+          new IncrementalResolver(_typeProvider, unit, 0, 0, 0);
+      resolver._resolveReferences(node);
+    }
+  }
+
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       _prepareResolutionContext(node);
       Scope scope = _resolutionContext.scope;
       // resolve types
       {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con3(
             _definingLibrary,
             _source,
@@ skipping 746 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }