Remove Element.users support.

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/services/lint.dart';
 
 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 800 matching lines @@
   int _updateDelta;
 
   RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _lints = 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._units, this._definingUnit, this._updateOffset,
       this._updateEndOld, this._updateEndNew) {
     _updateDelta = _updateEndNew - _updateEndOld;
     _definingLibrary = _definingUnit.library;
     _librarySource = _definingLibrary.source;
     _source = _definingUnit.source;
     _context = _definingUnit.context;
@@ skipping 20 matching lines @@
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
       _generateLints(rootNode);
       // update entry errors
       _updateEntry();
-      // resolve queue in response of API changes
-      _resolveQueue();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
 
   void _buildElements(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
@@ skipping 26 matching lines @@
     // 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 ||
           node is TopLevelVariableDeclaration;
 
-  void _fillResolutionQueue(DeclarationMatcher matcher) {
-    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
-  }
-
   /**
    * 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.
    */
   AstNode _findResolutionRoot(AstNode node) {
     while (node != null) {
@@ skipping 59 matching lines @@
     return null;
   }
 
   void _prepareResolutionContext(AstNode node) {
     if (_resolutionContext == null) {
       _resolutionContext =
           ResolutionContextBuilder.contextFor(node, errorListener);
     }
   }
 
-  /**
-   * 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.
-      logger.enter('resolve $element');
-      try {
-        AstNode node = element.node;
-        CompilationUnitElement unit =
-            element.getAncestor((e) => e is CompilationUnitElement);
-        IncrementalResolver resolver =
-            new IncrementalResolver(_units, unit, node.offset, node.end, node.end);
-        resolver._resolveReferences(node);
-        resolver._verify(node);
-        resolver._generateHints(node);
-        resolver._generateLints(node);
-        resolver._updateEntry();
-      } finally {
-        logger.exit();
-      }
-    }
-  }
-
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       _prepareResolutionContext(node);
       Scope scope = _resolutionContext.scope;
       // resolve types
       {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con3(
             _definingLibrary,
             _source,
@@ skipping 819 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }