Load patches via callback.

sdk/lib/_internal/compiler/implementation/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 108 matching lines @@
 import "tree/tree.dart" as tree;
 import "dart2jslib.dart" as leg;  // CompilerTask, Compiler.
 import "helpers/helpers.dart";
 import "scanner/scannerlib.dart";  // Scanner, Parsers, Listeners
 import "elements/elements.dart";
 import "elements/modelx.dart"
     show LibraryElementX,
          MetadataAnnotationX,
          ClassElementX,
          FunctionElementX;
+import "library_loader.dart" show LibraryLoaderCallback;
 import 'util/util.dart';
 
 class PatchParserTask extends leg.CompilerTask {
   PatchParserTask(leg.Compiler compiler): super(compiler);
   final String name = "Patching Parser";
 
   /**
    * Scans a library patch file, applies the method patches and
    * injections to the library, and returns a list of class
    * patches.
    */
-  Future patchLibrary(leg.LibraryDependencyHandler handler,
+  Future patchLibrary(LibraryLoaderCallback callback,
                       Uri patchUri, LibraryElement originLibrary) {
     return compiler.readScript(originLibrary, patchUri)
         .then((leg.Script script) {
       var patchLibrary = new LibraryElementX(script, null, originLibrary);
       return compiler.withCurrentElement(patchLibrary, () {
-        handler.registerNewLibrary(patchLibrary);
-        var imports = new LinkBuilder<tree.LibraryTag>();
+        callback.onLibraryCreated(patchLibrary);
         compiler.withCurrentElement(patchLibrary.entryCompilationUnit, () {
           // This patches the elements of the patch library into [library].
           // Injected elements are added directly under the compilation unit.
           // Patch elements are stored on the patched functions or classes.
-          scanLibraryElements(patchLibrary.entryCompilationUnit, imports);
+          scanLibraryElements(patchLibrary.entryCompilationUnit);
         });
-        // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
-        return Future.forEach(imports.toLink().toList(), (tag) {
-          return compiler.withCurrentElement(patchLibrary, () {
-            return compiler.libraryLoader.registerLibraryFromTag(
-                handler, patchLibrary, tag);
-          });
-        });
+        return callback.onLibraryScanned(patchLibrary);
       });
     });
   }
 
-  void scanLibraryElements(
-        CompilationUnitElement compilationUnit,
-        LinkBuilder<tree.LibraryTag> imports) {
+  void scanLibraryElements(CompilationUnitElement compilationUnit) {
     measure(() {
-      // TODO(lrn): Possibly recursively handle 'part' directives in patch.
+      // TODO(johnniwinther): Test that parts and exports are handled correctly.
       leg.Script script = compilationUnit.script;
       Token tokens = new Scanner(script.file).tokenize();
       Function idGenerator = compiler.getNextFreeClassId;
       Listener patchListener = new PatchElementListener(compiler,
                                                         compilationUnit,
-                                                        idGenerator,
-                                                        imports);
+                                                        idGenerator);
       new PartialParser(patchListener).parseUnit(tokens);
     });
   }
 
   void parsePatchClassNode(PartialClassElement element) {
     // Parse [PartialClassElement] using a "patch"-aware parser instead
     // of calling its [parseNode] method.
     if (element.cachedNode != null) return;
 
     measure(() => compiler.withCurrentElement(element, () {
@@ skipping 28 matching lines @@
   PatchClassElementParser(Listener listener) : super(listener);
 
   Token parseClassBody(Token token) => fullParseClassBody(token);
 }
 
 /**
  * Extension of [ElementListener] for parsing patch files.
  */
 class PatchElementListener extends ElementListener implements Listener {
   final leg.Compiler compiler;
-  final LinkBuilder<tree.LibraryTag> imports;
 
   PatchElementListener(leg.Compiler compiler,
                        CompilationUnitElement patchElement,
-                       int idGenerator(),
-                       this.imports)
+                       int idGenerator())
     : this.compiler = compiler,
       super(compiler, patchElement, idGenerator);
 
-  /**
-    * Allow script tags (import only, the parser rejects the rest for now) in
-    * patch files. The import tags will be added to the library.
-    */
-  bool allowLibraryTags() => true;
-
-  void addLibraryTag(tree.LibraryTag tag) {
-    super.addLibraryTag(tag);
-    imports.addLast(tag);
-  }
-
   void pushElement(Element patch) {
     super.pushElement(patch);
     if (isPatchElement(compiler, patch)) {
       LibraryElement originLibrary = compilationUnitElement.library;
       assert(originLibrary.isPatched);
       Element origin = originLibrary.localLookup(patch.name);
       patchElement(listener, origin, patch);
     }
   }
 }
@@ skipping 163 matching lines @@
         annotation.ensureResolved(compiler);
         if (annotation.value != compiler.patchConstant) {
           compiler.internalError(annotation, 'Invalid patch annotation.');
         }
       });
       return true;
     }
   }
   return false;
 }