Remove scanBuiltinLibraries.

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.
 
 part of dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 93 matching lines @@
    * 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.
    *
    * This is the main entry point for [LibraryLoader].
    */
-  // TODO(johnniwinther): Remove [canonicalUri] together with
-  // [Compiler.scanBuiltinLibrary].
-  Future<LibraryElement> loadLibrary(Uri resolvedUri, Node node,
-                                     Uri canonicalUri);
+  Future<LibraryElement> loadLibrary(Uri resolvedUri);
 
   // TODO(johnniwinther): Remove this when patches don't need special parsing.
   Future registerLibraryFromTag(LibraryDependencyHandler handler,
                                 LibraryElement library,
                                 LibraryDependency tag);
-
-  /**
-   * Adds the elements in the export scope of [importedLibrary] to the import
-   * scope of [importingLibrary].
-   */
-  // TODO(johnniwinther): Move handling of 'js_helper' to the library loader
-  // to remove this method from the [LibraryLoader] interface.
-  void importLibrary(LibraryElement importingLibrary,
-                     LibraryElement importedLibrary,
-                     Import tag);
 }
 
 /**
  * [CombinatorFilter] is a succinct representation of a list of combinators from
  * a library dependency tag.
  */
 class CombinatorFilter {
   const CombinatorFilter();
 
   /**
@@ skipping 71 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 LibraryLoader {
   LibraryLoaderTask(Compiler compiler) : super(compiler);
   String get name => 'LibraryLoader';
-  List onLibraryLoadedCallbacks = [];
 
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
-  Future<LibraryElement> loadLibrary(Uri resolvedUri, Node node,
-      Uri canonicalUri) {
+  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(compiler);
-      return createLibrary(currentHandler, null, resolvedUri, node,
-          canonicalUri).then((LibraryElement library) {
+      return createLibrary(currentHandler, null, resolvedUri)
+          .then((LibraryElement library) {
         return compiler.withCurrentElement(library, () {
           return measure(() {
             currentHandler.computeExports();
+            Map<Uri, LibraryElement> loadedLibraries = <Uri, LibraryElement>{};
+            currentHandler.loadedLibraries.forEach(
+                (LibraryElement loadedLibrary) {
+              loadedLibraries[loadedLibrary.canonicalUri] = loadedLibrary;
+            });
             currentHandler = null;
-            var workList = onLibraryLoadedCallbacks;
-            onLibraryLoadedCallbacks = [];
-            return Future.forEach(workList, (f) => f()).then((_) => library);
+            return compiler.onLibrariesLoaded(loadedLibraries)
+                .then((_) => library);
           });
         });
       });
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
@@ skipping 46 matching lines @@
           Part part = tag;
           StringNode uri = part.uri;
           Uri resolvedUri = base.resolve(uri.dartString.slowToString());
           tagState = checkTag(TagState.SOURCE, part);
           return scanPart(part, resolvedUri, library);
         } else {
           compiler.internalError(tag, "Unhandled library tag.");
         }
       });
     }).then((_) {
+      // TODO(johnniwinther): Move callback to after patching.
+      compiler.onLibraryScanned(library);
       return compiler.withCurrentElement(library, () {
         checkDuplicatedLibraryName(library);
         // Apply patch, if any.
         if (library.isPlatformLibrary) {
           return patchDartLibrary(handler, library, library.canonicalUri.path);
         }
       });
     }).then((_) {
       return compiler.withCurrentElement(library, () {
         // Import dart:core if not already imported.
@@ skipping 57 matching lines @@
 
   /**
    * Lazily loads and returns the [LibraryElement] for the dart:core library.
    */
   Future<LibraryElement> loadCoreLibrary(LibraryDependencyHandler handler) {
     if (compiler.coreLibrary != null) {
       return new Future.value(compiler.coreLibrary);
     }
 
     Uri coreUri = new Uri(scheme: 'dart', path: 'core');
-    return createLibrary(handler, null, coreUri, null, coreUri)
-        .then((LibraryElement library) {
+    return createLibrary(handler, null, coreUri).then((LibraryElement library) {
       compiler.coreLibrary = library;
       return library;
     });
   }
 
   Future patchDartLibrary(LibraryDependencyHandler handler,
-                        LibraryElement library, String dartLibraryPath) {
+                          LibraryElement library,
+                          String dartLibraryPath) {
     if (library.isPatched) return new Future.value();
     Uri patchUri = compiler.resolvePatchUri(dartLibraryPath);
     if (patchUri == null) return new Future.value();
 
     return compiler.patchParser.patchLibrary(handler, patchUri, library);
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
@@ skipping 22 matching lines @@
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope.
    */
   Future registerLibraryFromTag(LibraryDependencyHandler handler,
                                 LibraryElement library,
                                 LibraryDependency tag) {
     Uri base = library.entryCompilationUnit.script.readableUri;
     Uri resolvedUri = base.resolve(tag.uri.dartString.slowToString());
-    return createLibrary(handler, library, resolvedUri, tag.uri, resolvedUri)
+    return createLibrary(handler, library, resolvedUri, tag.uri)
         .then((LibraryElement loadedLibrary) {
           if (loadedLibrary == null) return;
           compiler.withCurrentElement(library, () {
             handler.registerDependency(library, tag, loadedLibrary);
           });
         });
   }
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
-  // TODO(johnniwinther): Remove [canonicalUri] and make [resolvedUri] the
-  // canonical uri when [Compiler.scanBuiltinLibrary] is removed.
   Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
                                        LibraryElement importingLibrary,
                                        Uri resolvedUri,
-                                       Node node,
-                                       Uri canonicalUri) {
+                                       [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;
-    if (canonicalUri != null) {
-      library = compiler.libraries[canonicalUri.toString()];
-    }
+    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, canonicalUri);
+            LibraryElement element = new LibraryElementX(script, resolvedUri);
             compiler.withCurrentElement(element, () {
+              compiler.onLibraryCreated(element);
               handler.registerNewLibrary(element);
               native.maybeEnableNative(compiler, element);
-              if (canonicalUri != null) {
-                compiler.libraries[canonicalUri.toString()] = element;
-              }
+              compiler.libraries[resolvedUri.toString()] = element;
               compiler.scanner.scanLibrary(element);
             });
             return processLibraryTags(handler, element).then((_) {
               compiler.withCurrentElement(element, () {
                 handler.registerLibraryExports(element);
-                onLibraryLoadedCallbacks.add(
-                    () => compiler.onLibraryLoaded(element, resolvedUri));
               });
               return element;
             });
           });
     });
   }
-
-  // TODO(johnniwinther): Remove this method when 'js_helper' is handled by
-  // [LibraryLoaderTask].
-  void importLibrary(LibraryElement importingLibrary,
-                     LibraryElement importedLibrary,
-                     Import tag) {
-    new ImportLink(tag, importedLibrary).importLibrary(compiler,
-                                                       importingLibrary);
-  }
 }
 
 
 /**
  * The fields of this class models a state machine for checking script
  * tags come in the correct order.
  */
 class TagState {
   static const int NO_TAG_SEEN = 0;
   static const int LIBRARY = 1;
@@ skipping 316 matching lines @@
  */
 class LibraryDependencyHandler {
   final Compiler compiler;
 
   /**
    * Newly loaded libraries and their corresponding node in the library
    * dependency graph. Libraries that have already been fully loaded are not
    * part of the dependency graph of this handler since their export scopes have
    * already been computed.
    */
-  Map<LibraryElement,LibraryDependencyNode> nodeMap =
-      new Map<LibraryElement,LibraryDependencyNode>();
+  Map<LibraryElement, LibraryDependencyNode> nodeMap =
+      new Map<LibraryElement, LibraryDependencyNode>();
 
   LibraryDependencyHandler(Compiler this.compiler);
 
+  /// The libraries loaded with this handler.
+  Iterable<LibraryElement> get loadedLibraries => nodeMap.keys;
+
   /**
    * Performs a fixed-point computation on the export scopes of all registered
    * libraries and creates the import/export of the libraries based on the
    * fixed-point.
    */
   void computeExports() {
     bool changed = true;
     while (changed) {
       changed = false;
       Map<LibraryDependencyNode, Map<Element, Link<Export>>> tasks =
@@ skipping 74 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }