Load patches via callback.

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;
+library dart2js.library_loader;
+
+import 'dart:async';
+import 'dart2jslib.dart'
+    show Compiler,
+         CompilerTask,
+         MessageKind,
+         Script,
+         invariant;
+import 'elements/elements.dart'
+    show CompilationUnitElement,
+         Element,
+         LibraryElement,
+         PrefixElement;
+import 'elements/modelx.dart'
+    show CompilationUnitElementX,
+         DeferredLoaderGetterElementX,
+         ErroneousElementX,
+         LibraryElementX,
+         PrefixElementX;
+import 'helpers/helpers.dart';
+import 'native_handler.dart' as native;
+import 'tree/tree.dart';
+import 'util/util.dart' show Link, LinkBuilder;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
  * the loading process.
  *
  * ## User URI ##
  *
  * A 'user URI' is a URI provided by the user in code and as the main entry URI
@@ skipping 74 matching lines @@
  * The distinction between readable URI and resource URI is necessary to ensure
  * that these imports
  *
  *     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 LibraryLoader extends CompilerTask {
-  LibraryLoader(Compiler compiler) : super(compiler);
+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.
-   *
-   * This is the main entry point for [LibraryLoader].
    */
   Future<LibraryElement> loadLibrary(Uri resolvedUri);
 
-  // TODO(johnniwinther): Remove this when patches don't need special parsing.
-  Future registerLibraryFromTag(LibraryDependencyHandler handler,
-                                LibraryElement library,
-                                LibraryDependency tag);
+  /// 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
+  /// scanned in order to process the library tags in [library] and thus handle
+  /// imports/exports/parts in the synthesized/patch library.
+  Future processLibraryTags(LibraryElement library);
 }
 
 /**
  * [CombinatorFilter] is a succinct representation of a list of combinators from
  * a library dependency tag.
  */
 class CombinatorFilter {
   const CombinatorFilter();
 
   /**
@@ skipping 68 matching lines @@
   HideFilter(this.excludedNames);
 
   bool exclude(Element element) => excludedNames.contains(element.name);
 }
 
 /**
  * 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);
+class _LibraryLoaderTask extends CompilerTask implements LibraryLoaderTask {
+  _LibraryLoaderTask(Compiler compiler) : super(compiler);
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
+  void reset() {
+    assert(currentHandler == null);
+    libraryResourceUriMap.clear();
+    libraryNames.clear();
+  }
+
+  void reuseLibrary(LibraryElement library) {
+    String name = library.getLibraryOrScriptName();
+    Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
+    libraryResourceUriMap[resourceUri] = library;
+    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(compiler);
+      currentHandler = new LibraryDependencyHandler(this);
       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;
             });
@@ skipping 28 matching lines @@
             MessageKind.GENERIC, {'text': 'Error: Out of order.'});
         return tagState;
       }
       return TagState.NEXT[value];
     }
 
     bool importsDartCore = false;
     var libraryDependencies = new LinkBuilder<LibraryDependency>();
     Uri base = library.entryCompilationUnit.script.readableUri;
 
-    // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
+    // TODO(johnniwinther): Reverse the tag list on access and cache the result.
     return Future.forEach(library.tags.reverse().toList(), (LibraryTag tag) {
       return compiler.withCurrentElement(library, () {
         if (tag.isImport) {
           Import import = tag;
           tagState = checkTag(TagState.IMPORT_OR_EXPORT, import);
           if (import.uri.dartString.slowToString() == 'dart:core') {
             importsDartCore = true;
           }
           libraryDependencies.addLast(import);
         } else if (tag.isExport) {
@@ skipping 10 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.onLibraryScanned(library, handler);
+    }).then((_) {
       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.
         if (!importsDartCore && !isDartCore(library.canonicalUri)) {
           return loadCoreLibrary(handler).then((LibraryElement coreLibrary) {
             handler.registerDependency(library, null, coreLibrary);
           });
         }
       });
     }).then((_) {
-      // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
       return Future.forEach(libraryDependencies.toLink().toList(), (tag) {
         return compiler.withCurrentElement(library, () {
           return registerLibraryFromTag(handler, library, tag);
         });
       });
     });
   }
 
   void checkDuplicatedLibraryName(LibraryElement library) {
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
@@ skipping 45 matching lines @@
       return new Future.value(compiler.coreLibrary);
     }
 
     Uri coreUri = new Uri(scheme: 'dart', path: 'core');
     return createLibrary(handler, null, coreUri).then((LibraryElement library) {
       compiler.coreLibrary = library;
       return library;
     });
   }
 
-  Future patchDartLibrary(LibraryDependencyHandler handler,
-                          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.
    */
   Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
     return compiler.withCurrentElement(library, () {
       return compiler.readScript(part, readableUri).
@@ skipping 49 matching lines @@
     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, () {
-              compiler.onLibraryCreated(element);
               handler.registerNewLibrary(element);
               native.maybeEnableNative(compiler, element);
               compiler.libraries[resolvedUri.toString()] = element;
               compiler.scanner.scanLibrary(element);
             });
             return processLibraryTags(handler, element).then((_) {
               compiler.withCurrentElement(element, () {
                 handler.registerLibraryExports(element);
               });
               return element;
@@ skipping 321 matching lines @@
 }
 
 /**
  * Helper class used for computing the possibly cyclic import/export scopes of
  * a set of libraries.
  *
  * This class is used by [ScannerTask.scanLibrary] to collect all newly loaded
  * libraries and to compute their import/export scopes through a fixed-point
  * algorithm.
  */
-class LibraryDependencyHandler {
-  final Compiler compiler;
+class LibraryDependencyHandler implements LibraryLoader {
+  final _LibraryLoaderTask task;
 
   /**
    * 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>();
 
-  LibraryDependencyHandler(Compiler this.compiler);
+  LibraryDependencyHandler(this.task);
+
+  Compiler get compiler => task.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() {
@@ skipping 68 matching lines @@
           message: "$library has not been registered"));
       importingNode.registerImportDependency(tag, loadedLibrary);
     }
   }
 
   /**
    * Registers [library] for the processing of its import/export scope.
    */
   void registerNewLibrary(LibraryElement library) {
     nodeMap[library] = new LibraryDependencyNode(library);
+    compiler.onLibraryCreated(library);
   }
 
   /**
    * 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();
   }
+
+  Future processLibraryTags(LibraryElement library) {
+    return task.processLibraryTags(this, library);
+  }
 }