Formalizing the hacks letting the angular analyzer plugin run for now.

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 50 matching lines @@
  *      and [removeFile], the analysis state will eventually transition back to
  *      "idle" after a finite amount of processing.
  *
  * As a result of these guarantees, a client may ensure that the analysis
  * results are "eventually consistent" with the file system by simply calling
  * [changeFile] any time the contents of a file on the file system have changed.
  *
  *
  * TODO(scheglov) Clean up the list of implicitly analyzed files.
  */
-class AnalysisDriver {
+class AnalysisDriver implements AnalysisDriverGeneric {
   /**
    * The version of data format, should be incremented on every format change.
    */
   static const int DATA_VERSION = 25;
 
   /**
    * The number of exception contexts allowed to write. Once this field is
    * zero, we stop writing any new exception contexts in this process.
    */
   static int allowedNumberOfContextsToWrite = 10;
@@ skipping 169 matching lines @@
       this.name,
       SourceFactory sourceFactory,
       this._analysisOptions,
       {PackageBundle sdkBundle,
       this.analyzeWithoutTasks: true})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle {
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
-    _scheduler._add(this);
+    _scheduler.add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
   Set<String> get addedFiles => _fileTracker.addedFiles;
 
   /**
    * Return the analysis options used to control analysis.
@@ skipping 91 matching lines @@
    * from file paths.
    */
   SourceFactory get sourceFactory => _sourceFactory;
 
   @visibleForTesting
   AnalysisDriverTestView get test => _testView;
 
   /**
    * Return the priority of work that the driver needs to perform.
    */
-  AnalysisDriverPriority get _workPriority {
+  AnalysisDriverPriority get workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_definingClassMemberNameTasks.isNotEmpty ||
         _referencingNameTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_indexRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
@@ skipping 542 matching lines @@
    * in the [library], e.g. element model, errors, index, etc.
    */
   String _getResolvedUnitSignature(FileState library, FileState file) {
     ApiSignature signature = new ApiSignature();
     signature.addUint32List(_salt);
     signature.addString(library.transitiveSignature);
     signature.addString(file.contentHash);
     return signature.toHex();
   }
 
+  ApiSignature getUnitKeyByPath(String path) {
+    var file = fsState.getFileForPath(path);
+    ApiSignature signature = new ApiSignature();
+    signature.addUint32List(_salt);
+    signature.addString(file.transitiveSignature);
+    return signature;
+  }
+
+  ApiSignature getResolvedUnitKeyByPath(String path) {
+    ApiSignature signature = getUnitKeyByPath(path);
+    var file = fsState.getFileForPath(path);
+    signature.addString(file.contentHash);
+    return signature;
+  }
+
   /**
    * Return the lint code with the given [errorName], or `null` if there is no
    * lint registered with that name or the lint is not enabled in the analysis
    * options.
    */
   ErrorCode _lintCodeByUniqueName(String errorName) {
     if (errorName.startsWith('_LintCode.')) {
       String lintName = errorName.substring(10);
       List<Linter> lintRules = _analysisOptions.lintRules;
       for (Linter linter in lintRules) {
         if (linter.name == lintName) {
           return linter.lintCode;
         }
       }
     }
     return null;
   }
 
   /**
    * Perform a single chunk of work and produce [results].
    */
-  Future<Null> _performWork() async {
+  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);
         // If a part without a library, delay its analysis.
@@ skipping 238 matching lines @@
 
       _byteStore.put(key, bytes);
       return key;
     } catch (_) {
       return null;
     }
   }
 }
 
 /**
+ * A generic schedulable interface via the AnalysisDriverScheduler. Currently
+ * only implemented by [AnalysisDriver] and the angular plugin, at least as
+ * a temporary measure until the official plugin API is ready (and a different
+ * scheduler is used)
+ */
+abstract class AnalysisDriverGeneric {
+  bool get hasFilesToAnalyze;
+  AnalysisDriverPriority get workPriority;
+  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.
  */
 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.
  */
@@ skipping 13 matching lines @@
    * be able to process `updateContent` or `setPriorityFiles` requests while
    * background analysis is in progress.
    *
    * The number of pumpings is arbitrary, might be changed if we see that
    * analysis or other data processing tasks are starving. Ideally we would
    * need to run all asynchronous operations using a single global scheduler.
    */
   static const int _NUMBER_OF_EVENT_QUEUE_PUMPINGS = 128;
 
   final PerformanceLog _logger;
-  final List<AnalysisDriver> _drivers = [];
+  final List<AnalysisDriverGeneric> _drivers = [];
   final Monitor _hasWork = new Monitor();
   final StatusSupport _statusSupport = new StatusSupport();
 
   bool _started = false;
 
   AnalysisDriverScheduler(this._logger);
 
   /**
    * Return `true` if we are currently analyzing code.
    */
   bool get isAnalyzing => _hasFilesToAnalyze;
 
   /**
    * Return the stream that produces [AnalysisStatus] events.
    */
   Stream<AnalysisStatus> get status => _statusSupport.stream;
 
   /**
    * Return `true` if there is a driver with a file to analyze.
    */
   bool get _hasFilesToAnalyze {
-    for (AnalysisDriver driver in _drivers) {
+    for (AnalysisDriverGeneric driver in _drivers) {
       if (driver.hasFilesToAnalyze) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Notify that there is a change to the [driver], it it might need to
    * perform some work.
    */
-  void notify(AnalysisDriver driver) {
+  void notify(AnalysisDriverGeneric driver) {
     _hasWork.notify();
     _statusSupport.preTransitionToAnalyzing();
   }
 
   /**
    * 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();
 
   /**
    * Add the given [driver] and schedule it to perform its work.
    */
-  void _add(AnalysisDriver driver) {
+  void add(AnalysisDriverGeneric driver) {
     _drivers.add(driver);
     _hasWork.notify();
   }
 
   /**
    * Remove the given [driver] from the scheduler, so that it will not be
    * asked to perform any new work.
    */
-  void _remove(AnalysisDriver driver) {
+  void _remove(AnalysisDriverGeneric 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);
         timer.reset();
       }
 
       await _hasWork.signal;
 
       // Transition to analyzing if there are files to analyze.
       if (_hasFilesToAnalyze) {
         _statusSupport.transitionToAnalyzing();
         analysisSection ??= _logger.enter('Analyzing');
       }
 
       // Find the driver with the highest priority.
-      AnalysisDriver bestDriver;
+      AnalysisDriverGeneric bestDriver;
       AnalysisDriverPriority bestPriority = AnalysisDriverPriority.nothing;
       for (AnalysisDriver driver in _drivers) {
-        AnalysisDriverPriority priority = driver._workPriority;
+        AnalysisDriverPriority priority = driver.workPriority;
         if (priority.index > bestPriority.index) {
           bestDriver = driver;
           bestPriority = priority;
         }
       }
 
       // Transition to idle if no files to analyze.
       if (!_hasFilesToAnalyze) {
         _statusSupport.transitionToIdle();
         analysisSection?.exit();
         analysisSection = null;
       }
 
       // Continue to sleep if no work to do.
       if (bestPriority == AnalysisDriverPriority.nothing) {
         continue;
       }
 
       // Ask the driver to perform a chunk of work.
-      await bestDriver._performWork();
+      await bestDriver.performWork();
 
       // Schedule one more cycle.
       _hasWork.notify();
     }
   }
 
   /**
    * Returns a [Future] that completes after performing [times] pumpings of
    * the event queue.
    */
@@ skipping 519 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }