Revert "Move Compiler.libraries to LibraryLoder."

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;
 
-  /// 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.
+  /**
+   * 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. If provided,
-  /// libraries matching [reuseLibrary] are reused.
-  ///
-  /// This method is used for incremental compilation.
-  void reset({bool reuseLibrary(LibraryElement library)});
+  /// 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);
 }
 
 /// 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;
 
-  Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
-
-  LibraryElement lookupLibrary(Uri canonicalUri) {
-    return libraryCanonicalUriMap[canonicalUri];
+  void reset() {
+    assert(currentHandler == null);
+    libraryResourceUriMap.clear();
+    libraryNames.clear();
   }
 
-  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);
-  }
-
-  /// Insert [library] in the internal maps. Used for compiler reuse.
-  void mapLibrary(LibraryElement library) {
-    libraryCanonicalUriMap[library.canonicalUri] = library;
-
+  void reuseLibrary(LibraryElement library) {
+    String name = library.getLibraryOrScriptName();
     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 = libraryCanonicalUriMap[resolvedUri];
+    LibraryElement library = compiler.libraries[resolvedUri.toString()];
     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);
-              libraryCanonicalUriMap[resolvedUri] = element;
+              compiler.libraries[resolvedUri.toString()] = 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);
   }
 }