Implement 'topLevelLibraryDeclarations' getter to return all libraries with exported top-level decl…

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
+import 'package:analyzer/src/dart/analysis/top_level_declaration.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/task/dart.dart' show COMPILATION_UNIT_ELEMENT;
 import 'package:analyzer/task/dart.dart' show LibrarySpecificUnit;
@@ skipping 120 matching lines @@
    * [getResult] to the [Completer]s to report the result.
    */
   final _requestedFiles = <String, List<Completer<AnalysisResult>>>{};
 
   /**
    * The list of tasks to compute files referencing a name.
    */
   final _referencingNameTasks = <_FilesReferencingNameTask>[];
 
   /**
+   * The list of tasks to compute top-level declarations.
+   */
+  final _topLevelDeclarationsTasks = <_TopLevelLibraryDeclarationsTask>[];
+
+  /**
    * The mapping from the files for which the index was requested using
    * [getIndex] to the [Completer]s to report the result.
    */
   final _indexRequestedFiles = <String, List<Completer<IndexResult>>>{};
 
   /**
    * The set of files were reported as changed through [changeFile] and not
    * checked for actual changes yet.
    */
   final _changedFiles = new LinkedHashSet<String>();
@@ skipping 119 matching lines @@
    * Return the search support for the driver.
    */
   Search get search => _search;
 
   /**
    * Return the stream that produces [AnalysisStatus] events.
    */
   Stream<AnalysisStatus> get status => _statusSupport.stream;
 
   /**
+   * Return a [Future] that completes with top-level declaration in all known
+   * libraries.
+   */
+  Future<List<TopLevelLibraryDeclarations>> get topLevelLibraryDeclarations {

[Paul Berry, 2016/12/01 22:28:15]

I'm concerned that this API forces the driver to compute a lot more information
than the caller really needs.  As far as I understand, the caller just needs to
know which libraries contain a top level declaration matching a certain string.

Under the current design, the only way to get that information is to compute all
top-level duclarations in all known libraries.  Which I think is fine for now. 
But in the future we might find a way to do this more efficiently.  I'd prefer
to have an API that would allow us to make that improvement without it being a
breaking change.

How about something like this instead:

Future<List<Source>> getTopLevelLibrariesExportingName(String name);

[scheglov, 2016/12/02 17:19:12]

That's a good idea.
Thank you.

We need to know kinds of declarations, for example to filter out variables where
a type is expected.
So, I went with Future<List<TopLevelDeclarationInSource>>
getTopLevelNameDeclarations(String name).

+    var task = new _TopLevelLibraryDeclarationsTask(this);
+    _topLevelDeclarationsTasks.add(task);
+    _statusSupport.transitionToAnalyzing();
+    _scheduler._notify(this);
+    return task.completer.future;
+  }
+
+  /**
    * Return the priority of work that the driver needs to perform.
    */
   AnalysisDriverPriority get _workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_referencingNameTasks.isNotEmpty) {
-      return AnalysisDriverPriority.referencingName;
+      return AnalysisDriverPriority.interactive;
     }
     if (_indexRequestedFiles.isNotEmpty) {
-      return AnalysisDriverPriority.getIndex;
+      return AnalysisDriverPriority.interactive;
+    }
+    if (_topLevelDeclarationsTasks.isNotEmpty) {
+      return AnalysisDriverPriority.interactive;
     }
     if (_priorityFiles.isNotEmpty) {
       for (String path in _priorityFiles) {
         if (_filesToAnalyze.contains(path)) {
           return AnalysisDriverPriority.priority;
         }
       }
     }
     if (_filesToAnalyze.isNotEmpty) {
       return AnalysisDriverPriority.general;
@@ skipping 486 matching lines @@
     // Compute files referencing a name.
     if (_referencingNameTasks.isNotEmpty) {
       _FilesReferencingNameTask task = _referencingNameTasks.first;
       bool isDone = await task.perform();
       if (isDone) {
         _referencingNameTasks.remove(task);
       }
       return;
     }
 
+    // Compute top-level declarations.
+    if (_topLevelDeclarationsTasks.isNotEmpty) {
+      _TopLevelLibraryDeclarationsTask task = _topLevelDeclarationsTasks.first;
+      bool isDone = await task.perform();
+      if (isDone) {
+        _topLevelDeclarationsTasks.remove(task);
+      }
+      return;
+    }
+
     // Analyze a priority file.
     if (_priorityFiles.isNotEmpty) {
       for (String path in _priorityFiles) {
         if (_filesToAnalyze.remove(path)) {
           AnalysisResult result = _computeAnalysisResult(path, withUnit: true);
           if (result == null) {
             _partsToAnalyze.add(path);
           } else {
             _resultController.add(result);
           }
@@ skipping 71 matching lines @@
     set.remove(element);
     return element;
   }
 }
 
 /**
  * Priorities of [AnalysisDriver] work. The farther a priority to the beginning
  * of the list, the earlier the corresponding [AnalysisDriver] should be asked
  * to perform work.
  */
-enum AnalysisDriverPriority {
-  nothing,
-  general,
-  priority,
-  referencingName,
-  getIndex,
-  interactive
-}
+enum AnalysisDriverPriority { nothing, general, priority, interactive }
 
 /**
  * Instances of this class schedule work in multiple [AnalysisDriver]s so that
  * work with the highest priority is performed first.
  */
 class AnalysisDriverScheduler {
   /**
    * Time interval in milliseconds before pumping the event queue.
    *
    * Relinquishing execution flow and running the event loop after every task
@@ skipping 389 matching lines @@
 }
 
 /**
  * TODO(scheglov) document
  */
 class _LibraryContext {
   final FileState file;
   final SummaryDataStore store;
   _LibraryContext(this.file, this.store);
 }
+
+/**
+ * Task that computes top-level declarations in all known libraries.
+ */
+class _TopLevelLibraryDeclarationsTask {
+  final AnalysisDriver driver;
+  final Completer<List<TopLevelLibraryDeclarations>> completer =
+      new Completer<List<TopLevelLibraryDeclarations>>();
+
+  final List<TopLevelLibraryDeclarations> libraryDeclarations =
+      <TopLevelLibraryDeclarations>[];
+  final Set<String> checkedFiles = new Set<String>();
+  final List<String> filesToCheck = <String>[];
+
+  _TopLevelLibraryDeclarationsTask(this.driver);
+
+  /**
+   * Perform a single piece of work, and either complete the [completer] and
+   * return `true` to indicate that the task is done, return `false` to indicate
+   * that the task should continue to be run.
+   */
+  Future<bool> perform() async {
+    // Prepare files to check.
+    if (filesToCheck.isEmpty) {
+      filesToCheck.addAll(driver.addedFiles.difference(checkedFiles));
+      filesToCheck.addAll(driver.knownFiles.difference(checkedFiles));
+    }
+
+    // If no more files to check, complete and done.
+    if (filesToCheck.isEmpty) {
+      completer.complete(libraryDeclarations);
+      return true;
+    }
+
+    // Check the next file.
+    String path = filesToCheck.removeLast();
+    FileState file = driver._fsState.getFileForPath(path);
+    if (!file.isPart) {
+      libraryDeclarations.add(new TopLevelLibraryDeclarations(
+          file.source, file.exportedTopLevelDeclarations));
+    }
+    checkedFiles.add(path);
+
+    // We're not done yet.
+    return false;
+  }
+}