Move Compiler.libraries to LibraryLoader.

sdk/lib/_internal/compiler/implementation/compiler.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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 490 matching lines @@
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
   static final Uri DART_MIRRORS = new Uri(scheme: 'dart', path: 'mirrors');
   static final Uri DART_NATIVE_TYPED_DATA =
       new Uri(scheme: 'dart', path: '_native_typed_data');
   static final Uri DART_INTERNAL = new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_ASYNC = new Uri(scheme: 'dart', path: 'async');
 
-  // TODO(johnniwinther): Move this to [LibraryLoaderTask] and hange to map from
-  // [Uri] to [LibraryElement].
-  final Map<String, LibraryElement> libraries =
-    new Map<String, LibraryElement>();
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
 
   final CacheStrategy cacheStrategy;
 
   /**
    * Map from token to the first preceeding comment token.
@@ skipping 784 matching lines @@
 
       // In order to see if a library is deferred, we must compute the
       // compile-time constants that are metadata.  This means adding
       // something to the resolution queue.  So we cannot wait with
       // this until after the resolution queue is processed.
       deferredLoadTask.ensureMetadataResolved(this);
     }
 
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
-      libraries.forEach((uri, lib) {
-        log('Enqueuing $uri');
-        fullyEnqueueLibrary(lib, enqueuer.resolution);
+      libraryLoader.libraries.forEach((LibraryElement library) {
+        log('Enqueuing ${library.canonicalUri}');
+        fullyEnqueueLibrary(library, enqueuer.resolution);
       });
     } else if (analyzeMain && mainApp != null) {
       fullyEnqueueLibrary(mainApp, enqueuer.resolution);
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveLibraryMetadata();
     log('Resolving...');
     processQueue(enqueuer.resolution, main);
@@ skipping 49 matching lines @@
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport()) {
       enqueuer.codegen.addToWorkList(
           isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
       enqueuer.codegen.registerGetOfStaticFunction(main);
     }
     if (enabledNoSuchMethod) {
       backend.enableNoSuchMethod(enqueuer.codegen);
     }
     if (compileAll) {
-      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib,
-          enqueuer.codegen));
+      libraryLoader.libraries.forEach((LibraryElement library) {
+        fullyEnqueueLibrary(library, enqueuer.codegen);
+      });
     }
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
     backend.assembleProgram();
 
     if (dumpInfo) {
       dumpInfoTask.dumpInfo();
@@ skipping 21 matching lines @@
       world.registerInstantiatedClass(element, globalDependencies);
     } else {
       world.addToWorkList(element);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
-    for (LibraryElement library in libraries.values) {
+    for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(this);
         }
       }
     }
   }
 
   void processQueue(Enqueuer world, Element main) {
-    world.nativeEnqueuer.processNativeClasses(libraries.values);
+    world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
     if (main != null) {
       FunctionElement mainMethod = main;
       if (mainMethod.computeSignature(this).parameterCount != 0) {
         // TODO(ngeoffray, floitsch): we should also ensure that the
         // class IsolateMessage is instantiated. Currently, just enabling
         // isolate support works.
         world.enableIsolateSupport(main.library);
         world.registerInstantiatedClass(listClass, globalDependencies);
         world.registerInstantiatedClass(stringClass, globalDependencies);
       }
@@ skipping 337 matching lines @@
         } else {
           member.forEachLocalMember(checkLive);
         }
       } else if (member.isTypedef) {
         if (!member.isResolved) {
           reportHint(member, MessageKind.UNUSED_TYPEDEF,
                      {'name': member.name});
         }
       }
     }
-    libraries.forEach((_, library) {
+    libraryLoader.libraries.forEach((LibraryElement library) {
       // TODO(ahe): Implement better heuristics to discover entry points of
       // packages and use that to discover unused implementation details in
       // packages.
       if (library.isPlatformLibrary || library.isPackageLibrary) return;
       library.compilationUnits.forEach((unit) {
         unit.forEachLocalMember(checkLive);
       });
     });
   }
 
@@ skipping 206 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }