Integration of the new analysis driver, behind a flag.

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:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 52 matching lines @@
  *      "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 {
+  String name;
   final PerformanceLog _logger;
 
   /**
    * The resource provider for working with files.
    */
   final ResourceProvider _resourceProvider;
 
   /**
    * The byte storage to get and put serialized data.
    *
@@ skipping 134 matching lines @@
    * More than one result might be produced for the same file, even if the
    * client does not change the state of the files.
    *
    * Results might be produced even for files that have never been added
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results async* {
     try {
       PerformanceLogSection analysisSection = null;
       while (true) {
+        await pumpEventQueue(100);

[Paul Berry, 2016/10/31 20:09:39]

Can you add a comment explaining why this is needed, and how the number 100 was
chosen?

[scheglov, 2016/10/31 20:37:11]

Done in https://codereview.chromium.org/2466713002

         await _hasWork.signal;
 
         if (analysisSection == null) {
           analysisSection = _logger.enter('Analyzing');
         }
 
         // Verify all changed files one at a time.
         if (_changedFiles.isNotEmpty) {
           String path = _removeFirst(_changedFiles);
           _verifyApiSignatureOfChangedFile(path);
@@ skipping 463 matching lines @@
   }
 
   /**
    * Remove and return the first item in the given [set].
    */
   static Object/*=T*/ _removeFirst/*<T>*/(LinkedHashSet<Object/*=T*/ > set) {
     Object/*=T*/ element = set.first;
     set.remove(element);
     return element;
   }
+
+  /**
+   * Returns a [Future] that completes after pumping the event queue [times]
+   * times. By default, this should pump the event queue enough times to allow
+   * any code to run, as long as it's not waiting on some external event.
+   */
+  Future pumpEventQueue([int times = 5000]) {

[Paul Berry, 2016/10/31 20:09:38]

Can we make this private?  It seems hacky to use it in non-test code and I don't
want calls to it to proliferate without us thinking really hard about it.

+    if (times == 0) return new Future.value();
+    // We use a delayed future to allow microtask events to finish. The
+    // Future.value or Future() constructors use scheduleMicrotask themselves and
+    // would therefore not wait for microtask callbacks that are scheduled after
+    // invoking this method.
+    return new Future.delayed(Duration.ZERO, () => pumpEventQueue(times - 1));
+  }
 }
 
 /**
  * The result of analyzing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. All referenced elements, even
  * external ones, are also self-consistent. But none of the results is
  * guaranteed to be consistent with the state of the files.
  *
@@ skipping 477 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }