Add AnalysisDriver.getFilesDefiningClassMemberName().

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 142 matching lines @@
    */
   final _priorityFiles = new LinkedHashSet<String>();
 
   /**
    * The mapping from the files for which analysis was requested using
    * [getResult] to the [Completer]s to report the result.
    */
   final _requestedFiles = <String, List<Completer<AnalysisResult>>>{};
 
   /**
+   * The list of tasks to compute files defining a class member name.
+   */
+  final _definingClassMemberNameTasks = <_FilesDefiningClassMemberNameTask>[];
+
+  /**
    * The list of tasks to compute files referencing a name.
    */
   final _referencingNameTasks = <_FilesReferencingNameTask>[];
 
   /**
    * The list of tasks to compute top-level declarations of a name.
    */
   final _topLevelNameDeclarationsTasks = <_TopLevelNameDeclarationsTask>[];
 
   /**
@@ skipping 187 matching lines @@
   @visibleForTesting
   AnalysisDriverTestView get test => _testView;
 
   /**
    * Return the priority of work that the driver needs to perform.
    */
   AnalysisDriverPriority get _workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
-    if (_referencingNameTasks.isNotEmpty) {
+    if (_definingClassMemberNameTasks.isNotEmpty ||
+        _referencingNameTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_indexRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_unitElementRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_topLevelNameDeclarationsTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
@@ skipping 117 matching lines @@
     return new ErrorsResult(
         path,
         analysisResult.uri,
         analysisResult.contentHash,
         analysisResult.lineInfo,
         analysisResult.errors);
   }
 
   /**
    * Return a [Future] that completes with the list of added files that
+   * define a class member with the given [name].
+   */
+  Future<List<String>> getFilesDefiningClassMemberName(String name) {
+    var task = new _FilesDefiningClassMemberNameTask(this, name);
+    _definingClassMemberNameTasks.add(task);
+    _scheduler._notify(this);
+    return task.completer.future;
+  }
+
+  /**
+   * Return a [Future] that completes with the list of added files that
    * reference the given external [name].
    */
   Future<List<String>> getFilesReferencingName(String name) {
     var task = new _FilesReferencingNameTask(this, name);
     _referencingNameTasks.add(task);
     _scheduler._notify(this);
     return task.completer.future;
   }
 
   /**
@@ skipping 413 matching lines @@
     // Process a unit request.
     if (_unitElementRequestedFiles.isNotEmpty) {
       String path = _unitElementRequestedFiles.keys.first;
       CompilationUnitElement unitElement = _computeUnitElement(path);
       _unitElementRequestedFiles.remove(path).forEach((completer) {
         completer.complete(unitElement);
       });
       return;
     }
 
+    // Compute files defining a name.
+    if (_definingClassMemberNameTasks.isNotEmpty) {
+      _FilesDefiningClassMemberNameTask task =
+          _definingClassMemberNameTasks.first;
+      bool isDone = await task.perform();
+      if (isDone) {
+        _definingClassMemberNameTasks.remove(task);
+      }
+      return;
+    }
+
     // Compute files referencing a name.
     if (_referencingNameTasks.isNotEmpty) {
       _FilesReferencingNameTask task = _referencingNameTasks.first;
       bool isDone = await task.perform();
       if (isDone) {
         _referencingNameTasks.remove(task);
       }
       return;
     }
 
@@ skipping 644 matching lines @@
   final String contextKey;
 
   _ExceptionState(this.exception, this.stackTrace, this.contextKey);
 
   @override
   String toString() => '$exception\n$stackTrace';
 }
 
 /**
  * Task that computes the list of files that were added to the driver and
+ * declare a class member with the given [name].
+ */
+class _FilesDefiningClassMemberNameTask {
+  static const int _MS_WORK_INTERVAL = 5;
+
+  final AnalysisDriver driver;
+  final String name;
+  final Completer<List<String>> completer = new Completer<List<String>>();
+
+  final List<String> definingFiles = <String>[];
+  final Set<String> checkedFiles = new Set<String>();
+  final List<String> filesToCheck = <String>[];
+
+  _FilesDefiningClassMemberNameTask(this.driver, this.name);
+
+  /**
+   * Perform work for a fixed length of time, and complete the [completer] to
+   * either return `true` to indicate that the task is done, or return `false`
+   * to indicate that the task should continue to be run.
+   *
+   * Each invocation of an asynchronous method has overhead, which looks as
+   * `_SyncCompleter.complete` invocation, we see as much as 62% in some
+   * scenarios. Instead we use a fixed length of time, so we can spend less time
+   * overall and keep quick enough response time.
+   */
+  Future<bool> perform() async {
+    Stopwatch timer = new Stopwatch()..start();
+    while (timer.elapsedMilliseconds < _MS_WORK_INTERVAL) {
+      // Prepare files to check.
+      if (filesToCheck.isEmpty) {
+        Set<String> newFiles = driver.addedFiles.difference(checkedFiles);
+        filesToCheck.addAll(newFiles);
+      }
+
+      // If no more files to check, complete and done.
+      if (filesToCheck.isEmpty) {
+        completer.complete(definingFiles);
+        return true;
+      }
+
+      // Check the next file.
+      String path = filesToCheck.removeLast();
+      FileState file = driver._fsState.getFileForPath(path);
+      if (file.definedClassMemberNames.contains(name)) {
+        definingFiles.add(path);
+      }
+      checkedFiles.add(path);
+    }
+
+    // We're not done yet.
+    return false;
+  }
+}
+
+/**
+ * Task that computes the list of files that were added to the driver and
  * have at least one reference to an identifier [name] defined outside of the
  * file.
  */
 class _FilesReferencingNameTask {
   static const int _MS_WORK_INTERVAL = 5;
 
   final AnalysisDriver driver;
   final String name;
   final Completer<List<String>> completer = new Completer<List<String>>();
 
@@ skipping 95 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }