Add LibraryLoader.resetAsync.

dart/sdk/lib/_internal/compiler/implementation/library_loader.dart

 // Copyright (c) 2012, 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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 import 'dart2jslib.dart'
     show Compiler,
          CompilerTask,
@@ skipping 125 matching lines @@
   /// [LibraryElement] for the library and computes the import/export scope,
   /// loading and computing the import/export scopes of all required libraries
   /// in the process. The method handles cyclic dependency between libraries.
   Future<LibraryElement> loadLibrary(Uri resolvedUri);
 
   /// Reset the library loader task to prepare for compilation. If provided,
   /// libraries matching [reuseLibrary] are reused.
   ///
   /// This method is used for incremental compilation.
   void reset({bool reuseLibrary(LibraryElement library)});
+
+  /// Asynchronous version of [reset].
+  Future resetAsync(Future<bool> reuseLibrary(LibraryElement library));
 }
 
 /// Handle for creating synthesized/patch libraries during library loading.
 abstract class LibraryLoader {
   /// This method must be called when a new synthesized/patch library has been
   /// created to ensure that [library] will part of library dependency graph
   /// used for computing import/export scopes.
   void registerNewLibrary(LibraryElement library);
 
   /// This method must be called when a new synthesized/patch library has been
@@ skipping 103 matching lines @@
 
   Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
 
   LibraryElement lookupLibrary(Uri canonicalUri) {
     return libraryCanonicalUriMap[canonicalUri];
   }
 
   void reset({bool reuseLibrary(LibraryElement library)}) {
     measure(() {
       assert(currentHandler == null);
-      Iterable<LibraryElement> libraries =
-          new List.from(libraryCanonicalUriMap.values);
 
+      Iterable<LibraryElement> reusedLibraries = null;
+      if (reuseLibrary != null) {
+        reusedLibraries = compiler.reuseLibraryTask.measure(() {
+          // Call [toList] to force eager calls to [reuseLibrary].
+          return libraryCanonicalUriMap.values.where(reuseLibrary).toList();
+        });
+      }
+
+      resetImplementation(reusedLibraries);
+    });
+  }
+
+  void resetImplementation(Iterable<LibraryElement> reusedLibraries) {
+    measure(() {
       libraryCanonicalUriMap.clear();
       libraryResourceUriMap.clear();
       libraryNames.clear();
 
-      if (reuseLibrary == null) return;
-
-      compiler.reuseLibraryTask.measure(
-          () => libraries.where(reuseLibrary).toList()).forEach(mapLibrary);
+      if (reusedLibraries != null) {
+        reusedLibraries.forEach(mapLibrary);
+      }
     });
   }
 
+  Future resetAsync(Future<bool> reuseLibrary(LibraryElement library)) {
+    return measure(() {
+      assert(currentHandler == null);
+
+      Future<LibraryElement> wrapper(LibraryElement library) {
+        try {
+          return reuseLibrary(library).then(
+              (bool reuse) => reuse ? library : null);
+        } catch (exception, trace) {
+          compiler.diagnoseCrashInUserCode(
+              'Uncaught exception in reuseLibrary', exception, trace);
+          rethrow;
+        }
+      }
+
+      List<Future<LibraryElement>> reusedLibrariesFuture =
+          compiler.reuseLibraryTask.measure(
+              () => libraryCanonicalUriMap.values.map(wrapper).toList());
+
+      return Future.wait(reusedLibrariesFuture).then(
+          (List<LibraryElement> reusedLibraries) {
+            resetImplementation(reusedLibraries.where((e) => e != null));
+          });
+    });
+  }
+
   /// Insert [library] in the internal maps. Used for compiler reuse.
   void mapLibrary(LibraryElement library) {
     libraryCanonicalUriMap[library.canonicalUri] = library;
 
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     libraryResourceUriMap[resourceUri] = library;
 
     String name = library.getLibraryOrScriptName();
     libraryNames[name] = library;
   }
@@ skipping 692 matching lines @@
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 
   Future processLibraryTags(LibraryElement library) {
     return task.processLibraryTags(this, library);
   }
 }