Move Compiler.libraries to LibraryLoader.

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 105 matching lines @@
  *     import 'package:foo.dart' as a;
  *     import 'packages/foo.dart' as b;
  *
  * do _not_ resolve to the same library when the package root URI happens to
  * point to the 'packages' folder.
  *
  */
 abstract class LibraryLoaderTask implements CompilerTask {
   factory LibraryLoaderTask(Compiler compiler) = _LibraryLoaderTask;
 
-  /**
-   * Loads the library specified by the [resolvedUri] and returns its
-   * [LibraryElement].
-   *
-   * If the library is not already loaded, the method creates the
-   * [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.
-   */
+  /// Returns all libraries that have been loaded.
+  Iterable<LibraryElement> get libraries;
+
+  /// Looks up the library with the [canonicalUri].
+  LibraryElement lookupLibrary(Uri canonicalUri);
+
+  /// Loads the library specified by the [resolvedUri] and returns its
+  /// [LibraryElement].
+  ///
+  /// If the library is not already loaded, the method creates the
+  /// [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. This is used
-  /// for incremental compilation.
-  void reset();
-
-  /// Reuse [library] from a previous compilation. This is used for incremental
-  /// compilation.
-  void reuseLibrary(LibraryElement library);
+  /// 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)]);

[floitsch, 2014/06/24 13:43:05]

I think it would be easier to read (at use-sites) if it was "bool
filterLibrary(..)" or "bool where(..)" and the function needed to return false
if didn't want to reset the library.

[Johnni Winther, 2014/06/24 14:50:29]

Changed to named parameter.

 }
 
 /// 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 85 matching lines @@
 
 /**
  * Implementation class for [LibraryLoader]. The distinction between
  * [LibraryLoader] and [LibraryLoaderTask] is made to hide internal members from
  * the [LibraryLoader] interface.
  */
 class _LibraryLoaderTask extends CompilerTask implements LibraryLoaderTask {
   _LibraryLoaderTask(Compiler compiler) : super(compiler);
   String get name => 'LibraryLoader';
 
+  final Map<Uri, LibraryElement> libraryCanonicalUriMap =
+      new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
-  void reset() {
+  Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
+
+  LibraryElement lookupLibrary(Uri canonicalUri) {
+    return libraryCanonicalUriMap[canonicalUri];
+  }
+
+  void reset([bool reuseLibrary(LibraryElement library)]) {
     assert(currentHandler == null);
+    Iterable<LibraryElement> libraries =
+        new List.from(libraryCanonicalUriMap.values);
+
+    libraryCanonicalUriMap.clear();
     libraryResourceUriMap.clear();
     libraryNames.clear();
+
+    if (reuseLibrary == null) return;
+
+    libraries.where(reuseLibrary).forEach(mapLibrary);
   }
 
-  void reuseLibrary(LibraryElement library) {
-    String name = library.getLibraryOrScriptName();
+  /// 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;
   }
 
   Future<LibraryElement> loadLibrary(Uri resolvedUri) {
     return measure(() {
       assert(currentHandler == null);
       // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
       // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(this);
       return createLibrary(currentHandler, null, resolvedUri)
@@ skipping 205 matching lines @@
    */
   Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
                                        LibraryElement importingLibrary,
                                        Uri resolvedUri,
                                        [Node node]) {
     // TODO(johnniwinther): Create erroneous library elements for missing
     // libraries.
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
     if (readableUri == null) return new Future.value();
-    LibraryElement library = compiler.libraries[resolvedUri.toString()];
+    LibraryElement library = libraryCanonicalUriMap[resolvedUri];
     if (library != null) {
       return new Future.value(library);
     }
     return compiler.withCurrentElement(importingLibrary, () {
       return compiler.readScript(node, readableUri)
           .then((Script script) {
             if (script == null) return null;
             LibraryElement element = new LibraryElementX(script, resolvedUri);
             compiler.withCurrentElement(element, () {
               handler.registerNewLibrary(element);
               native.maybeEnableNative(compiler, element);
-              compiler.libraries[resolvedUri.toString()] = element;
+              libraryCanonicalUriMap[resolvedUri] = element;
               compiler.scanner.scanLibrary(element);
             });
             return processLibraryTags(handler, element).then((_) {
               compiler.withCurrentElement(element, () {
                 handler.registerLibraryExports(element);
               });
               return element;
             });
           });
     });
@@ skipping 436 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);
   }
 }