Migrate DDC to the new analysis driver.

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';
-import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
+import 'package:analyzer/dart/element/element.dart'
+    show CompilationUnitElement, LibraryElement;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.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/file_tracker.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/library_analyzer.dart';
 import 'package:analyzer/src/dart/analysis/library_context.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;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/services/lint.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/package_bundle_reader.dart';
 import 'package:meta/meta.dart';
 
 /**
  * This class computes [AnalysisResult]s for Dart files.
  *
  * Let the set of "explicitly analyzed files" denote the set of paths that have
  * been passed to [addFile] but not subsequently passed to [removeFile]. Let
  * the "current analysis results" denote the map from the set of explicitly
  * analyzed files to the most recent [AnalysisResult] delivered to [results]
  * for each file. Let the "current file state" represent a map from file path
@@ skipping 60 matching lines @@
   final ResourceProvider _resourceProvider;
 
   /**
    * The byte storage to get and put serialized data.
    *
    * It can be shared with other [AnalysisDriver]s.
    */
   final ByteStore _byteStore;
 
   /**
+   * TODO(scheglov) document
+   */
+  final SummaryDataStore externalSummaries;
+
+  /**
    * This [ContentCache] is consulted for a file content before reading
    * the content from the file.
    */
   final FileContentOverlay _contentOverlay;
 
   /**
    * The analysis options to analyze with.
    */
   AnalysisOptions _analysisOptions;
 
@@ skipping 107 matching lines @@
    */
   Search _search;
 
   AnalysisDriverTestView _testView;
 
   /**
    * The [FileTracker] used by this driver.
    */
   FileTracker _fileTracker;
 
+  final _cachedResults = {};
+
   /**
    * Create a new instance of [AnalysisDriver].
    *
    * The given [SourceFactory] is cloned to ensure that it does not contain a
    * reference to a [AnalysisContext] in which it could have been used.
    */
   AnalysisDriver(
       this._scheduler,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.name,
       SourceFactory sourceFactory,
       this._analysisOptions,
       {PackageBundle sdkBundle,
-      this.analyzeWithoutTasks: true})
+      this.analyzeWithoutTasks: true,
+      SummaryDataStore externalSummaries})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
-        _sdkBundle = sdkBundle {
+        _sdkBundle = sdkBundle,
+        externalSummaries = externalSummaries {
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
     _scheduler.add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
   Set<String> get addedFiles => _fileTracker.addedFiles;
@@ skipping 268 matching lines @@
       return new Future.value();
     }
     var completer = new Completer<AnalysisDriverUnitIndex>();
     _indexRequestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisDriverUnitIndex>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
+  ApiSignature getResolvedUnitKeyByPath(String path) {
+    ApiSignature signature = getUnitKeyByPath(path);
+    var file = fsState.getFileForPath(path);
+    signature.addString(file.contentHash);
+    return signature;
+  }
+
   /**
    * Return a [Future] that completes with a [AnalysisResult] 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.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * If the driver has the cached analysis result for the file, it is returned.
@@ skipping 83 matching lines @@
       return new Future.value();
     }
     var completer = new Completer<String>();
     _unitElementSignatureRequests
         .putIfAbsent(path, () => <Completer<String>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
+  ApiSignature getUnitKeyByPath(String path) {
+    var file = fsState.getFileForPath(path);
+    ApiSignature signature = new ApiSignature();
+    signature.addUint32List(_salt);
+    signature.addString(file.transitiveSignature);
+    return signature;
+  }
+
   /**
    * Return a [Future] that completes with a [ParseResult] for the file
    * with the given [path].
    *
    * The [path] must be absolute and normalized.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * The parsing is performed in the method itself, and the result is not
    * produced through the [results] stream (just because it is not a fully
    * 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].
+   */
+  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.
+        if (result == null) {
+          _requestedParts
+              .putIfAbsent(path, () => [])
+              .addAll(_requestedFiles.remove(path));
+          return;
+        }
+        // Notify the completers.
+        _requestedFiles.remove(path).forEach((completer) {
+          completer.complete(result);
+        });
+        // Remove from to be analyzed and produce it now.
+        _fileTracker.fileWasAnalyzed(path);
+        _resultController.add(result);
+      } catch (exception, stackTrace) {
+        _fileTracker.fileWasAnalyzed(path);
+        _requestedFiles.remove(path).forEach((completer) {
+          completer.completeError(exception, stackTrace);
+        });
+      }
+      return;
+    }
+
+    // Process an index request.
+    if (_indexRequestedFiles.isNotEmpty) {
+      String path = _indexRequestedFiles.keys.first;
+      AnalysisDriverUnitIndex index = _computeIndex(path);
+      _indexRequestedFiles.remove(path).forEach((completer) {
+        completer.complete(index);
+      });
+      return;
+    }
+
+    // Process a unit element key request.
+    if (_unitElementSignatureRequests.isNotEmpty) {
+      String path = _unitElementSignatureRequests.keys.first;
+      String signature = _computeUnitElementSignature(path);
+      _unitElementSignatureRequests.remove(path).forEach((completer) {
+        completer.complete(signature);
+      });
+      return;
+    }
+
+    // Process a unit element request.
+    if (_unitElementRequestedFiles.isNotEmpty) {
+      String path = _unitElementRequestedFiles.keys.first;
+      UnitElementResult result = _computeUnitElement(path);
+      _unitElementRequestedFiles.remove(path).forEach((completer) {
+        completer.complete(result);
+      });
+      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;
+    }
+
+    // Compute top-level declarations.
+    if (_topLevelNameDeclarationsTasks.isNotEmpty) {
+      _TopLevelNameDeclarationsTask task = _topLevelNameDeclarationsTasks.first;
+      bool isDone = await task.perform();
+      if (isDone) {
+        _topLevelNameDeclarationsTasks.remove(task);
+      }
+      return;
+    }
+
+    // Analyze a priority file.
+    if (_priorityFiles.isNotEmpty) {
+      for (String path in _priorityFiles) {
+        if (_fileTracker.isFilePending(path)) {
+          try {
+            AnalysisResult result =
+                _computeAnalysisResult(path, withUnit: true);
+            if (result == null) {
+              _partsToAnalyze.add(path);
+            } else {
+              _resultController.add(result);
+            }
+          } catch (exception, stackTrace) {
+            _reportException(path, exception, stackTrace);
+          } finally {
+            _fileTracker.fileWasAnalyzed(path);
+          }
+          return;
+        }
+      }
+    }
+
+    // Analyze a general file.
+    if (_fileTracker.hasPendingFiles) {
+      String path = _fileTracker.anyPendingFile;
+      try {
+        AnalysisResult result = _computeAnalysisResult(path,
+            withUnit: false, skipIfSameSignature: true);
+        if (result == null) {
+          _partsToAnalyze.add(path);
+        } else if (result == AnalysisResult._UNCHANGED) {
+          // We found that the set of errors is the same as we produced the
+          // last time, so we don't need to produce it again now.
+        } else {
+          _resultController.add(result);
+          _lastProducedSignatures[result.path] = result._signature;
+        }
+      } catch (exception, stackTrace) {
+        _reportException(path, exception, stackTrace);
+      } finally {
+        _fileTracker.fileWasAnalyzed(path);
+      }
+      return;
+    }
+
+    // Analyze a requested part file.
+    if (_requestedParts.isNotEmpty) {
+      String path = _requestedParts.keys.first;
+      try {
+        AnalysisResult result = _computeAnalysisResult(path,
+            withUnit: true, asIsIfPartWithoutLibrary: true);
+        // Notify the completers.
+        _requestedParts.remove(path).forEach((completer) {
+          completer.complete(result);
+        });
+        // Remove from to be analyzed and produce it now.
+        _partsToAnalyze.remove(path);
+        _resultController.add(result);
+      } catch (exception, stackTrace) {
+        _partsToAnalyze.remove(path);
+        _requestedParts.remove(path).forEach((completer) {
+          completer.completeError(exception, stackTrace);
+        });
+      }
+      return;
+    }
+
+    // Analyze a general part.
+    if (_partsToAnalyze.isNotEmpty) {
+      String path = _partsToAnalyze.first;
+      _partsToAnalyze.remove(path);
+      try {
+        AnalysisResult result = _computeAnalysisResult(path,
+            withUnit: _priorityFiles.contains(path),
+            asIsIfPartWithoutLibrary: true);
+        _resultController.add(result);
+      } catch (exception, stackTrace) {
+        _reportException(path, exception, stackTrace);
+      }
+      return;
+    }
+  }
+
+  /**
    * Remove the file with the given [path] from the list of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
     _fileTracker.removeFile(path);
     _priorityResults.clear();
   }
 
   /**
+   * TODO(scheglov) document
+   */
+  Future<LibraryElement> resynthesizeLibrary(String uri) async {
+    if (externalSummaries.hasUnlinkedUnit(uri)) {
+      return LibraryContext.resynthesizeLibrary(analysisOptions,
+          declaredVariables, sourceFactory, externalSummaries, uri);
+    }
+    Source source = sourceFactory.resolveUri(null, uri);
+    var unitResult = await getUnitElement(source.fullName);
+    return unitResult.element.library;
+  }
+
+  /**
    * Handles a notification from the [FileTracker] that there has been a change
    * of state.
    */
   void _changeHook() {
     _priorityResults.clear();
     _scheduler.notify(this);
   }
 
   /**
    * Return the cached or newly computed analysis result of the file with the
    * given [path].
    *
    * The result will have the fully resolved unit and will always be newly
    * compute only if [withUnit] is `true`.
    *
    * Return `null` if the file is a part of an unknown library, so cannot be
    * analyzed yet. But [asIsIfPartWithoutLibrary] is `true`, then the file is
    * analyzed anyway, even without a library.
    *
    * Return [AnalysisResult._UNCHANGED] if [skipIfSameSignature] is `true` and
    * the resolved signature of the file in its library is the same as the one
    * that was the most recently produced to the client.
    */
   AnalysisResult _computeAnalysisResult(String path,
       {bool withUnit: false,
       bool asIsIfPartWithoutLibrary: false,
       bool skipIfSameSignature: false}) {
     FileState file = _fileTracker.fsState.getFileForPath(path);
 
+    {
+      UnitAnalysisResult unitResult = _cachedResults[file];
+      if (unitResult != null) {
+        return new AnalysisResult(
+            this,
+            sourceFactory,
+            path,
+            file.uri,
+            file.exists,
+            file.content,
+            file.contentHash,
+            file.lineInfo,
+            null,
+            unitResult.unit,
+            unitResult.errors,
+            null);
+      }
+    }
+
     // Prepare the library - the file itself, or the known library.
     FileState library = file.isPart ? file.library : file;
     if (library == null) {
       if (asIsIfPartWithoutLibrary) {
         library = file;
       } else {
         return null;
       }
     }
 
@@ skipping 26 matching lines @@
           List<int> bytes;
           if (analyzeWithoutTasks) {
             LibraryAnalyzer analyzer = new LibraryAnalyzer(
                 analysisOptions,
                 declaredVariables,
                 sourceFactory,
                 _fileTracker.fsState,
                 libraryContext.store,
                 library);
             Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
+            _cachedResults.addAll(results);
             for (FileState unitFile in results.keys) {
               UnitAnalysisResult unitResult = results[unitFile];
               List<int> unitBytes =
                   _serializeResolvedUnit(unitResult.unit, unitResult.errors);
               String unitSignature =
                   _getResolvedUnitSignature(library, unitFile);
               String unitKey = _getResolvedUnitKey(unitSignature);
               _byteStore.put(unitKey, unitBytes);
               if (unitFile == file) {
                 bytes = unitBytes;
@@ skipping 33 matching lines @@
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
   }
 
   UnitElementResult _computeUnitElement(String path) {
     FileState file = _fileTracker.fsState.getFileForPath(path);
+    if (path.startsWith('dart:')) {
+      file = _fileTracker.fsState.getFileForUri(Uri.parse(path));
+    }
     FileState library = file.library ?? file;
 
     // Create the AnalysisContext to resynthesize elements in.
     LibraryContext libraryContext = _createLibraryContext(library);
 
     // Resynthesize the CompilationUnitElement in the context.
     try {
       CompilationUnitElement element =
           libraryContext.computeUnitElement(library.source, file.source);
       String signature = library.transitiveSignature;
@@ skipping 10 matching lines @@
   }
 
   /**
    * Creates a new [FileTracker] object and stores it in [_fileTracker].
    *
    * This is used both on initial construction and whenever the configuration
    * changes.
    */
   void _createFileTracker(PerformanceLog logger) {
     _fillSalt();
-    _fileTracker = new FileTracker(logger, _byteStore, _contentOverlay,
-        _resourceProvider, sourceFactory, _analysisOptions, _salt, _changeHook);
+    _fileTracker = new FileTracker(
+        logger,
+        _byteStore,
+        _contentOverlay,
+        _resourceProvider,
+        sourceFactory,
+        _analysisOptions,
+        _salt,
+        externalSummaries,
+        _changeHook);
   }
 
   /**
    * Return the context in which the [library] should be analyzed.
    */
   LibraryContext _createLibraryContext(FileState library) =>
       new LibraryContext.forSingleLibrary(
           library,
           _logger,
           _sdkBundle,
           _byteStore,
           _analysisOptions,
           declaredVariables,
           _sourceFactory,
+          externalSummaries,
           _fileTracker);
 
   /**
    * Fill [_salt] with data.
    */
   void _fillSalt() {
     _salt[0] = DATA_VERSION;
     List<int> crossContextOptions = _analysisOptions.signature;
     assert(crossContextOptions.length == AnalysisOptions.signatureLength);
     for (int i = 0; i < crossContextOptions.length; i++) {
@@ skipping 57 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 {
-    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.
-        if (result == null) {
-          _requestedParts
-              .putIfAbsent(path, () => [])
-              .addAll(_requestedFiles.remove(path));
-          return;
-        }
-        // Notify the completers.
-        _requestedFiles.remove(path).forEach((completer) {
-          completer.complete(result);
-        });
-        // Remove from to be analyzed and produce it now.
-        _fileTracker.fileWasAnalyzed(path);
-        _resultController.add(result);
-      } catch (exception, stackTrace) {
-        _fileTracker.fileWasAnalyzed(path);
-        _requestedFiles.remove(path).forEach((completer) {
-          completer.completeError(exception, stackTrace);
-        });
-      }
-      return;
-    }
-
-    // Process an index request.
-    if (_indexRequestedFiles.isNotEmpty) {
-      String path = _indexRequestedFiles.keys.first;
-      AnalysisDriverUnitIndex index = _computeIndex(path);
-      _indexRequestedFiles.remove(path).forEach((completer) {
-        completer.complete(index);
-      });
-      return;
-    }
-
-    // Process a unit element key request.
-    if (_unitElementSignatureRequests.isNotEmpty) {
-      String path = _unitElementSignatureRequests.keys.first;
-      String signature = _computeUnitElementSignature(path);
-      _unitElementSignatureRequests.remove(path).forEach((completer) {
-        completer.complete(signature);
-      });
-      return;
-    }
-
-    // Process a unit element request.
-    if (_unitElementRequestedFiles.isNotEmpty) {
-      String path = _unitElementRequestedFiles.keys.first;
-      UnitElementResult result = _computeUnitElement(path);
-      _unitElementRequestedFiles.remove(path).forEach((completer) {
-        completer.complete(result);
-      });
-      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;
-    }
-
-    // Compute top-level declarations.
-    if (_topLevelNameDeclarationsTasks.isNotEmpty) {
-      _TopLevelNameDeclarationsTask task = _topLevelNameDeclarationsTasks.first;
-      bool isDone = await task.perform();
-      if (isDone) {
-        _topLevelNameDeclarationsTasks.remove(task);
-      }
-      return;
-    }
-
-    // Analyze a priority file.
-    if (_priorityFiles.isNotEmpty) {
-      for (String path in _priorityFiles) {
-        if (_fileTracker.isFilePending(path)) {
-          try {
-            AnalysisResult result =
-                _computeAnalysisResult(path, withUnit: true);
-            if (result == null) {
-              _partsToAnalyze.add(path);
-            } else {
-              _resultController.add(result);
-            }
-          } catch (exception, stackTrace) {
-            _reportException(path, exception, stackTrace);
-          } finally {
-            _fileTracker.fileWasAnalyzed(path);
-          }
-          return;
-        }
-      }
-    }
-
-    // Analyze a general file.
-    if (_fileTracker.hasPendingFiles) {
-      String path = _fileTracker.anyPendingFile;
-      try {
-        AnalysisResult result = _computeAnalysisResult(path,
-            withUnit: false, skipIfSameSignature: true);
-        if (result == null) {
-          _partsToAnalyze.add(path);
-        } else if (result == AnalysisResult._UNCHANGED) {
-          // We found that the set of errors is the same as we produced the
-          // last time, so we don't need to produce it again now.
-        } else {
-          _resultController.add(result);
-          _lastProducedSignatures[result.path] = result._signature;
-        }
-      } catch (exception, stackTrace) {
-        _reportException(path, exception, stackTrace);
-      } finally {
-        _fileTracker.fileWasAnalyzed(path);
-      }
-      return;
-    }
-
-    // Analyze a requested part file.
-    if (_requestedParts.isNotEmpty) {
-      String path = _requestedParts.keys.first;
-      try {
-        AnalysisResult result = _computeAnalysisResult(path,
-            withUnit: true, asIsIfPartWithoutLibrary: true);
-        // Notify the completers.
-        _requestedParts.remove(path).forEach((completer) {
-          completer.complete(result);
-        });
-        // Remove from to be analyzed and produce it now.
-        _partsToAnalyze.remove(path);
-        _resultController.add(result);
-      } catch (exception, stackTrace) {
-        _partsToAnalyze.remove(path);
-        _requestedParts.remove(path).forEach((completer) {
-          completer.completeError(exception, stackTrace);
-        });
-      }
-      return;
-    }
-
-    // Analyze a general part.
-    if (_partsToAnalyze.isNotEmpty) {
-      String path = _partsToAnalyze.first;
-      _partsToAnalyze.remove(path);
-      try {
-        AnalysisResult result = _computeAnalysisResult(path,
-            withUnit: _priorityFiles.contains(path),
-            asIsIfPartWithoutLibrary: true);
-        _resultController.add(result);
-      } catch (exception, stackTrace) {
-        _reportException(path, exception, stackTrace);
-      }
-      return;
-    }
-  }
-
   void _reportException(String path, exception, StackTrace stackTrace) {
     String contextKey = null;
     if (exception is _ExceptionState) {
       var state = exception as _ExceptionState;
       exception = state.exception;
       stackTrace = state.stackTrace;
       contextKey = state.contextKey;
     }
     CaughtException caught = new CaughtException(exception, stackTrace);
     _exceptionController.add(new ExceptionResult(path, caught, contextKey));
@@ skipping 138 matching lines @@
   bool get _hasFilesToAnalyze {
     for (AnalysisDriverGeneric driver in _drivers) {
       if (driver.hasFilesToAnalyze) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Add the given [driver] and schedule it to perform its work.
+   */
+  void add(AnalysisDriverGeneric driver) {
+    _drivers.add(driver);
+    _hasWork.notify();
+  }
+
+  /**
    * 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();
   }
 
   /**
    * 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(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(AnalysisDriverGeneric driver) {
     _drivers.remove(driver);
     _hasWork.notify();
   }
 
   /**
    * Run infinitely analysis cycle, selecting the drivers with the highest
@@ skipping 574 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }