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 89 matching lines @@
    * [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);
+/// Callback for creating synthesized/patch libraries during library loading.
+abstract class LibraryLoaderCallback {

[floitsch, 2014/06/23 19:12:33]

Don't call this "callback". It took me some time to realize that the
LibraryLoaderCallback is not just a function typedef.

[Johnni Winther, 2014/06/24 08:11:20]

Done.

+  /// Call this when a new synthesized/patch library has been created.

[floitsch, 2014/06/23 19:12:33]

This is ambiguous.
Who needs to call this method? The implementer of the interface? The user of it?
The framework (in this file)?

"Must be called when a ..."


Why not "registerLibrary" and "processTags" ?
This should make it clearer what the purpose of these methods are.

[Johnni Winther, 2014/06/24 08:11:20]

Done.

+  ///
+  /// This call ensures that [library] will part of library dependency graph
+  /// used for computing import/export scopes.
+  void onLibraryCreated(LibraryElement library);
+
+  /// Call this when a new synthesized/patch library has been scanned.
+  ///
+  /// On this call library tags in [library] will be processed, allowing for
+  /// imports/exports/parts in the synthesized/patch library.
+  Future onLibraryScanned(LibraryElement library);
 }
 
 /**
  * [CombinatorFilter] is a succinct representation of a list of combinators from
  * a library dependency tag.
  */
 class CombinatorFilter {
   const CombinatorFilter();
 
   /**
@@ skipping 84 matching lines @@
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
   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.

[floitsch, 2014/06/23 19:12:33]

11523 has been closed with 'asDesigned'.
It should be safe to remove the 'toList()', but I don't think it costs much to
keep it.

[Johnni Winther, 2014/06/24 08:11:20]

Removed the comment. Still need the `toList()` call sine `Link` is not
`Iterable`.

     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) {
@@ skipping 54 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);
+              handler.onLibraryCreated(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 320 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 LibraryLoaderCallback {
+  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(LibraryLoaderTask 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 77 matching lines @@
     nodeMap[library] = new LibraryDependencyNode(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();
   }
+
+  void onLibraryCreated(LibraryElement library) {
+    compiler.onLibraryCreated(library);
+    registerNewLibrary(library);
+  }
+
+  Future onLibraryScanned(LibraryElement library) {
+    return task.processLibraryTags(this, library);
+  }
 }