Incrementally resolve users of a changed method.

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 97 matching lines @@
     } on _DeclarationMismatchException catch (exception) {
       return DeclarationMatchKind.MISMATCH;
     } finally {
       logger.exit();
     }
     // no API changes
     if (_removedElements.isEmpty && _addedElements.isEmpty) {
       return DeclarationMatchKind.MATCH;
     }
     // simple API change
+    logger.log('_removedElements: $_removedElements');
+    logger.log('_addedElements: $_addedElements');
+    _removedElements.forEach(_removeElement);
     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 47 matching lines @@
     _hasConstructor = true;
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element = constructorName == null ?
         _enclosingClass.unnamedConstructor :
         _enclosingClass.getNamedConstructor(constructorName.name);
     _processElement(element);
     _assertCompatibleParameters(node.parameters, element.parameters);
     // TODO(scheglov) debug null Location
     if (element != null) {
       if (element.context == null || element.source == null) {
-        logger.log('Bad constructor element $element for $node in ${node.parent}');
+        logger.log(
+            'Bad constructor element $element for $node in ${node.parent}');
       }
     }
     // matches, update the existing element
     ExecutableElement newElement = node.element;
     node.element = element;
     _setLocalElements(element, newElement);
   }
 
   @override
   visitEnumConstantDeclaration(EnumConstantDeclaration node) {
@@ skipping 136 matching lines @@
       _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);
     } 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);
-      }
+      _removeElement(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;
       }
@@ skipping 262 matching lines @@
   }
 
   void _processElement(Element element) {
     _assertNotNull(element);
     if (!_allElements.contains(element)) {
       throw new _DeclarationMismatchException();
     }
     _removedElements.remove(element);
   }
 
+  void _removeElement(Element element) {
+    if (element != null) {
+      Element enclosingElement = element.enclosingElement;
+      if (element is MethodElement) {
+        ClassElement classElement = enclosingElement;
+        classElement.methods.removeWhere((e) => identical(e, element));

[Brian Wilkerson, 2014/12/19 15:03:29]

Do we really need to iterate over all of the elements?

[scheglov, 2014/12/19 17:43:04]

No, we don't.
But we cannot use just List.remove(), because it uses == instead of identical.
I created a helper method to stop iterating after the first identical element.

+      } else if (element is PropertyAccessorElement) {
+        if (enclosingElement is ClassElement) {
+          enclosingElement.accessors.removeWhere((e) => identical(e, element));
+        }
+        if (enclosingElement is CompilationUnitElement) {
+          enclosingElement.accessors.removeWhere((e) => identical(e, 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;
       }
     }
     return null;
@@ skipping 61 matching lines @@
   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;
-
-  /**
    * The element of the compilation unit being resolved.
    */
   final CompilationUnitElement _definingUnit;
 
   /**
+   * The context the compilation unit being resolved in.
+   */
+  AnalysisContextImpl _context;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider _typeProvider;
+
+  /**
    * The element for the library containing the compilation unit being resolved.
    */
   LibraryElement _definingLibrary;
 
   /**
+   * The [DartEntry] corresponding to the source being resolved.
+   */
+  DartEntry entry;
+
+  /**
    * The source representing the compilation unit being visited.
    */
   Source _source;
 
   /**
    * The offset of the changed contents.
    */
   final int _updateOffset;
 
   /**
-   * The number of characters in the original contents that were replaced.
+   * The end of the changed contents in the old unit.
    */
-  final int _updateOldLength;
+  final int _updateEndOld;
 
   /**
-   * The number of characters in the replacement text.
+   * The end of the changed contents in the new unit.
    */
-  final int _updateNewLength;
+  final int _updateEndNew;
+
+  int _updateDelta;
 
   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>();
 
   /**
    * 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) {
+  IncrementalResolver(this._definingUnit, this._updateOffset,
+      this._updateEndOld, this._updateEndNew) {
+    _updateDelta = _updateEndNew - _updateEndOld;
     _definingLibrary = _definingUnit.library;
     _source = _definingUnit.source;
+    _context = _definingUnit.context;
+    _typeProvider = _context.typeProvider;
+    entry = _context.getReadableSourceEntryOrNull(_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);
+      _updateElementNameOffsets();
       _buildElements(rootNode);
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
+      // update entry errors
+      _updateEntry();
       // resolve queue in response of API changes
       _resolveQueue();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
 
   void _buildElements(AstNode node) {
@@ skipping 56 matching lines @@
   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;
 
   void _fillResolutionQueue(DeclarationMatcher matcher) {
-    for (Element removedElement in matcher._removedElements) {
+    HashSet<Element> removedElements = matcher._removedElements;
+    logger.log('${removedElements.length} elements removed');
+    for (Element removedElement in removedElements) {
       AnalysisContextImpl context = removedElement.context;
       IntSet users = removedElement.users;
       while (!users.isEmpty) {
         int id = users.remove();
         Element removedElementUser = context.findElementById(id);
         _resolutionQueue.add(removedElementUser);
       }
     }
     // TODO(scheglov) a method change might also require its class, and
     // subclasses resolution
@@ skipping 53 matching lines @@
   }
 
   /**
    * Resolves elements [_resolutionQueue].
    *
    * TODO(scheglov) work in progress
   *
   * TODO(scheglov) revisit later. Each task duration should be kept short.
    */
   void _resolveQueue() {
+    logger.log('${_resolutionQueue.length} elements in the resolution queue');
     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);
+      logger.enter('resolve $element');
+      try {
+        AstNode node = element.node;
+        CompilationUnitElement unit =
+            element.getAncestor((e) => e is CompilationUnitElement);
+        IncrementalResolver resolver =
+            new IncrementalResolver(unit, node.offset, node.end, node.end);
+        resolver._resolveReferences(node);
+        resolver._verify(node);
+        resolver._generateHints(node);
+        resolver._updateEntry();
+      } finally {
+        logger.exit();
+      }
     }
   }
 
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       _prepareResolutionContext(node);
       Scope scope = _resolutionContext.scope;
       // resolve types
       {
@@ skipping 34 matching lines @@
         visitor.initForIncrementalResolution();
         node.accept(visitor);
       }
       // remember errors
       _resolveErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('resolve references');
     }
   }
 
+  void _shiftEntryErrors() {
+    Source librarySource = _definingLibrary.source;
+    {
+      List<AnalysisError> errors =
+          entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource);

[Brian Wilkerson, 2014/12/19 15:03:29]

FWIW the error access could also be moved into _shiftErrors.

[scheglov, 2014/12/19 17:43:04]

Done.

+      _shiftErrors(errors);
+    }
+    {
+      List<AnalysisError> errors =
+          entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
+      _shiftErrors(errors);
+    }
+    {
+      List<AnalysisError> errors =
+          entry.getValueInLibrary(DartEntry.HINTS, librarySource);
+      _shiftErrors(errors);
+    }
+  }
+
+  void _shiftErrors(List<AnalysisError> errors) {
+    for (AnalysisError error in errors) {
+      int errorOffset = error.offset;
+      if (errorOffset > _updateOffset) {
+        error.offset += _updateDelta;
+      }
+    }
+  }
+
+  void _updateElementNameOffsets() {
+    LoggingTimer timer = logger.startTimer();
+    try {
+      _definingUnit.accept(
+          new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
+    } finally {
+      timer.stop('update element offsets');
+    }
+  }
+
+  void _updateEntry() {
+    Source librarySource = _definingLibrary.source;
+    {
+      List<AnalysisError> oldErrors =
+          entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource);
+      List<AnalysisError> errors = _updateErrors(oldErrors, _resolveErrors);
+      entry.setValueInLibrary(
+          DartEntry.RESOLUTION_ERRORS,
+          librarySource,
+          errors);
+    }
+    {
+      List<AnalysisError> oldErrors =
+          entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
+      List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
+      entry.setValueInLibrary(
+          DartEntry.VERIFICATION_ERRORS,
+          librarySource,
+          errors);
+    }
+    entry.setValueInLibrary(DartEntry.HINTS, librarySource, _hints);
+  }
+
+  List<AnalysisError> _updateErrors(List<AnalysisError> oldErrors,
+      List<AnalysisError> newErrors) {
+    List<AnalysisError> errors = new List<AnalysisError>();
+    // add updated old errors
+    for (AnalysisError error in oldErrors) {
+      int errorOffset = error.offset;
+      if (errorOffset < _updateOffset) {
+        errors.add(error);
+      } else if (errorOffset > _updateEndOld) {
+        error.offset += _updateDelta;
+        errors.add(error);
+      }
+    }
+    // add new errors
+    for (AnalysisError error in newErrors) {
+      int errorOffset = error.offset;
+      if (errorOffset > _updateOffset && errorOffset < _updateEndNew) {
+        errors.add(error);
+      }
+    }
+    // done
+    return errors;
+  }
+
   void _verify(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           _definingLibrary,
           _typeProvider,
           new InheritanceManager(_definingLibrary));
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
             _resolutionContext.enclosingClassDeclaration);
       }
       node.accept(errorVerifier);
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
     }
   }
-
-  static void _updateElementNameOffsets(Element root, int offset, int delta) {
-    LoggingTimer timer = logger.startTimer();
-    try {
-      root.accept(new _ElementNameOffsetUpdater(offset, delta));
-    } finally {
-      timer.stop('update element offsets');
-    }
-  }
 }
 
 
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
   final Source _unitSource;
-  final Source _librarySource;
   final DartEntry _entry;
+  CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
   int _updateEndNew;
 
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
-  List<AnalysisError> _newResolveErrors = <AnalysisError>[];
-  List<AnalysisError> _newVerifyErrors = <AnalysisError>[];
-  List<AnalysisError> _newHints = <AnalysisError>[];
 
-  PoorMansIncrementalResolver(this._typeProvider, this._unitSource,
-      this._librarySource, this._entry, bool resolveApiChanges) {
+  PoorMansIncrementalResolver(this._typeProvider, this._unitSource, this._entry,
+      bool resolveApiChanges) {
     _resolveApiChanges = resolveApiChanges;
   }
 
   /**
    * Attempts to update [oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [oldUnit] might be damaged.
    */
   bool resolve(CompilationUnit oldUnit, String newCode) {
     logger.enter('diff/resolve $_unitSource');
     logger.log(oldUnit != null ? 'has oldUnit' : 'oldUnit is null');
     try {
+      _unitElement = oldUnit.element;
       CompilationUnit newUnit = _parseUnit(newCode);
       _TokenPair firstPair =
           _findFirstDifferentToken(oldUnit.beginToken, newUnit.beginToken);
       _TokenPair lastPair =
           _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
         if (identical(lastPair.oldToken, firstPair.oldToken) &&
             identical(lastPair.newToken, firstPair.newToken)) {
           _updateOffset = beginOffsetOld - 1;
           _updateEndOld = endOffsetOld;
+          _updateEndNew = endOffsetNew;
           _updateDelta = newUnit.length - oldUnit.length;
           // A Dart documentation comment change.
           if (firstPair.kind == _TokenDifferenceKind.COMMENT_DOC) {
             _resolveComment(oldUnit, newUnit, firstPair);
             logger.log('Success.');
             return true;
           }
           // A pure whitespace change.
           if (firstPair.kind == _TokenDifferenceKind.OFFSET) {
             logger.log('Whitespace change.');
             _shiftTokens(firstPair.oldToken);
-            IncrementalResolver._updateElementNameOffsets(
-                oldUnit.element,
-                _updateOffset,
-                _updateDelta);
+            {
+              IncrementalResolver incrementalResolver = new IncrementalResolver(
+                  _unitElement,
+                  _updateOffset,
+                  _updateEndOld,
+                  _updateEndNew);
+              incrementalResolver._updateElementNameOffsets();
+              incrementalResolver._shiftEntryErrors();
+            }
             _updateEntry();
             logger.log('Success.');
             return true;
           }
           // fall-through, end-of-line comment
         }
         // Find nodes covering the "old" and "new" token ranges.
         AstNode oldNode =
             _findNodeCovering(oldUnit, beginOffsetOld, endOffsetOld);
         AstNode newNode =
@@ skipping 44 matching lines @@
           Token newBeginToken = _getBeginTokenNotComment(newNode);
           if (oldBeginToken.previous.type == TokenType.EOF) {
             oldUnit.beginToken = newBeginToken;
           } else {
             oldBeginToken.previous.setNext(newBeginToken);
           }
           newNode.endToken.setNext(oldNode.endToken.next);
           _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
-        CompilationUnitElement oldUnitElement = oldUnit.element;
         IncrementalResolver incrementalResolver = new IncrementalResolver(
-            _typeProvider,
-            oldUnitElement,
+            _unitElement,
             _updateOffset,
             oldNode.length,
             newNode.length);
         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);
       logger.log('Failure: exception.');
     } finally {
       logger.exit();
@@ skipping 25 matching lines @@
     Comment newComment = _findNodeCovering(newUnit, offset, offset);
     logger.log('oldComment.beginToken: ${oldComment.beginToken}');
     logger.log('newComment.beginToken: ${newComment.beginToken}');
     _updateOffset = oldToken.offset - 1;
     // update token references
     _shiftTokens(firstPair.oldToken);
     _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
     // update elements
-    IncrementalResolver._updateElementNameOffsets(
-        oldUnit.element,
+    IncrementalResolver incrementalResolver = new IncrementalResolver(
+        _unitElement,
         _updateOffset,
-        _updateDelta);
+        _updateEndOld,
+        _updateEndNew);
+    incrementalResolver._updateElementNameOffsets();
     _updateEntry();
     // resolve references in the comment
-    CompilationUnitElement oldUnitElement = oldUnit.element;
-    IncrementalResolver incrementalResolver =
-        new IncrementalResolver(_typeProvider, oldUnitElement, _updateOffset, 0, 0);
     incrementalResolver._resolveReferences(newComment);
   }
 
   Token _scan(String code) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     CharSequenceReader reader = new CharSequenceReader(code);
     Scanner scanner = new Scanner(_unitSource, reader, errorListener);
     Token token = scanner.tokenize();
     _newScanErrors = errorListener.errors;
     return token;
@@ skipping 15 matching lines @@
       if (token.type == TokenType.EOF) {
         break;
       }
       token = token.next;
     }
   }
 
   void _updateEntry() {
     _entry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
     _entry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
-    {
-      List<AnalysisError> oldErrors =
-          _entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, _librarySource);
-      List<AnalysisError> errors = _updateErrors(oldErrors, _newResolveErrors);
-      _entry.setValueInLibrary(
-          DartEntry.RESOLUTION_ERRORS,
-          _librarySource,
-          errors);
-    }
-    {
-      List<AnalysisError> oldErrors =
-          _entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, _librarySource);
-      List<AnalysisError> errors = _updateErrors(oldErrors, _newVerifyErrors);
-      _entry.setValueInLibrary(
-          DartEntry.VERIFICATION_ERRORS,
-          _librarySource,
-          errors);
-    }
-    _entry.setValueInLibrary(DartEntry.HINTS, _librarySource, _newHints);
-  }
-
-  List<AnalysisError> _updateErrors(List<AnalysisError> oldErrors,
-      List<AnalysisError> newErrors) {
-    List<AnalysisError> errors = new List<AnalysisError>();
-    // add updated old errors
-    for (AnalysisError error in oldErrors) {
-      int errorOffset = error.offset;
-      if (errorOffset < _updateOffset) {
-        errors.add(error);
-      } else if (errorOffset > _updateEndOld) {
-        error.offset += _updateDelta;
-        errors.add(error);
-      }
-    }
-    // add new errors
-    for (AnalysisError error in newErrors) {
-      int errorOffset = error.offset;
-      if (errorOffset > _updateOffset && errorOffset < _updateEndNew) {
-        errors.add(error);
-      }
-    }
-    // done
-    return errors;
   }
 
   static _TokenDifferenceKind _compareToken(Token oldToken, Token newToken,
       int delta) {
     if (oldToken == null && newToken == null) {
       return null;
     }
     if (oldToken == null || newToken == null) {
       return _TokenDifferenceKind.CONTENT;
     }
@@ skipping 385 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }