Implement more of the behavior of a plugin; refactor some API

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/context_root.dart';
 import 'package:analyzer/context/declared_variables.dart';
@@ skipping 302 matching lines @@
   /**
    * Return the stream that produces [ExceptionResult]s.
    */
   Stream<ExceptionResult> get exceptions => _exceptionController.stream;
 
   /**
    * The current file system state.
    */
   FileSystemState get fsState => _fsState;
 
-  /**
-   * Return `true` if the driver has a file to analyze.
-   */
+  @override
   bool get hasFilesToAnalyze {
     return _fileTracker.hasChangedFiles ||
         _requestedFiles.isNotEmpty ||
         _requestedParts.isNotEmpty ||
         _fileTracker.hasPendingFiles ||
         _partsToAnalyze.isNotEmpty;
   }
 
   /**
    * Return the set of files that are known at this moment. This set does not
@@ skipping 10 matching lines @@
   /**
    * Return the number of files scheduled for analysis.
    */
   int get numberOfFilesToAnalyze => _fileTracker.numberOfPendingFiles;
 
   /**
    * Return the list of files that the driver should try to analyze sooner.
    */
   List<String> get priorityFiles => _priorityFiles.toList(growable: false);
 
-  /**
-   * Set the list of files that the driver should try to analyze sooner.
-   *
-   * Every path in the list must be absolute and normalized.
-   *
-   * The driver will produce the results through the [results] stream. The
-   * exact order in which results are produced is not defined, neither
-   * between priority files, nor between priority and non-priority files.
-   */
+  @override
   void set priorityFiles(List<String> priorityPaths) {
     _priorityResults.keys
         .toSet()
         .difference(priorityPaths.toSet())
         .forEach(_priorityResults.remove);
     _priorityFiles.clear();
     _priorityFiles.addAll(priorityPaths);
     _scheduler.notify(this);
   }
 
@@ skipping 28 matching lines @@
 
   /**
    * Return the source factory used to resolve URIs to paths and restore URIs
    * from file paths.
    */
   SourceFactory get sourceFactory => _sourceFactory;
 
   @visibleForTesting
   AnalysisDriverTestView get test => _testView;
 
-  /**
-   * Return the priority of work that the driver needs to perform.
-   */
+  @override
   AnalysisDriverPriority get workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_definingClassMemberNameTasks.isNotEmpty ||
         _referencingNameTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_indexRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
@@ skipping 88 matching lines @@
       _analysisOptions = analysisOptions;
     }
     if (sourceFactory != null) {
       _sourceFactory = sourceFactory;
     }
     Iterable<String> addedFiles = _fileTracker.addedFiles;
     _createFileTracker();
     _fileTracker.addFiles(addedFiles);
   }
 
-  /**
-   * Notify the driver that the client is going to stop using it.
-   */
+  @override
   void dispose() {
-    _scheduler._remove(this);
+    _scheduler.remove(this);
   }
 
   /**
    * Return a [Future] that completes with the [ErrorsResult] for the Dart
    * file with the given [path]. If the file is not a Dart file or cannot
    * be analyzed, the [Future] completes with `null`.
    *
    * The [path] must be absolute and normalized.
    *
    * This method does not use analysis priorities, and must not be used in
@@ skipping 207 matching lines @@
    * resolved unit).
    */
   Future<ParseResult> parseFile(String path) async {
     FileState file = _fileTracker.verifyApiSignature(path);
     RecordingErrorListener listener = new RecordingErrorListener();
     CompilationUnit unit = file.parse(listener);
     return new ParseResult(file.path, file.uri, file.content, file.contentHash,
         unit.lineInfo, unit, listener.errors);
   }
 
-  /**
-   * Perform a single chunk of work and produce [results].
-   */
+  @override
   Future<Null> performWork() async {
     if (_fileTracker.verifyChangedFilesIfNeeded()) {
       return;
     }
 
     // Analyze a requested file.
     if (_requestedFiles.isNotEmpty) {
       String path = _requestedFiles.keys.first;
       try {
         AnalysisResult result = _computeAnalysisResult(path, withUnit: true);
@@ skipping 572 matching lines @@
  * a temporary measure until the official plugin API is ready (and a different
  * scheduler is used)
  */
 abstract class AnalysisDriverGeneric {
   /**
    * Return `true` if the driver has a file to analyze.
    */
   bool get hasFilesToAnalyze;
 
   /**
+   * Set the list of files that the driver should try to analyze sooner.
+   *
+   * Every path in the list must be absolute and normalized.
+   *
+   * The driver will produce the results through the [results] stream. The
+   * exact order in which results are produced is not defined, neither
+   * between priority files, nor between priority and non-priority files.
+   */
+  void set priorityFiles(List<String> priorityPaths);
+
+  /**
    * Return the priority of work that the driver needs to perform.
    */
   AnalysisDriverPriority get workPriority;
 
   /**
+   * Notify the driver that the client is going to stop using it.
+   */
+  void dispose();
+
+  /**
    * Perform a single chunk of work and produce [results].
    */
   Future<Null> performWork();
 }
 
 /**
  * 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.
  */
@@ skipping 85 matching lines @@
   /**
    * Notify that there is a change to the [driver], it it might need to
    * perform some work.
    */
   void notify(AnalysisDriverGeneric driver) {
     _hasWork.notify();
     _statusSupport.preTransitionToAnalyzing();
   }
 
   /**
+   * Remove the given [driver] from the scheduler, so that it will not be
+   * asked to perform any new work.
+   */
+  void remove(AnalysisDriverGeneric driver) {
+    if (driver is AnalysisDriver) {
+      driverWatcher?.removedDriver(driver);
+    }
+    _drivers.remove(driver);
+    _hasWork.notify();
+  }
+
+  /**
    * Start the scheduler, so that any [AnalysisDriver] created before or
    * after will be asked to perform work.
    */
   void start() {
     if (_started) {
       throw new StateError('The scheduler has already been started.');
     }
     _started = true;
     _run();
   }
 
   /**
    * Return a future that will be completed the next time the status is idle.
    *
    * If the status is currently idle, the returned future will be signaled
    * immediately.
    */
   Future<Null> waitForIdle() => _statusSupport.waitForIdle();
 
   /**
-   * Remove the given [driver] from the scheduler, so that it will not be
-   * asked to perform any new work.
-   */
-  void _remove(AnalysisDriverGeneric driver) {
-    if (driver is AnalysisDriver) {
-      driverWatcher?.removedDriver(driver);
-    }
-
-    _drivers.remove(driver);
-    _hasWork.notify();
-  }
-
-  /**
    * Run infinitely analysis cycle, selecting the drivers with the highest
    * priority first.
    */
   Future<Null> _run() async {
     Stopwatch timer = new Stopwatch()..start();
     PerformanceLogSection analysisSection;
     while (true) {
       // Pump the event queue.
       if (timer.elapsedMilliseconds > _MS_BEFORE_PUMPING_EVENT_QUEUE) {
         await _pumpEventQueue(_NUMBER_OF_EVENT_QUEUE_PUMPINGS);
@@ skipping 597 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }