Make top-level patch injections be compilation unit under library.

lib/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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 340 matching lines @@
     addForeignFunctions(jsHelperLibrary);
     addForeignFunctions(interceptorsLibrary);
 
     libraries['dart:core'] = coreLibrary;
     libraries['dart:coreimpl'] = coreImplLibrary;
 
     assertMethod = coreLibrary.find(const SourceString('assert'));
 
     initializeSpecialClasses();
 
-    patchDartLibrary(coreLibrary, 'core');
-    patchDartLibrary(coreImplLibrary, 'coreimpl');
+    //patchDartLibrary(coreLibrary, 'core');
+    //patchDartLibrary(coreImplLibrary, 'coreimpl');
   }
 
   void patchDartLibrary(LibraryElement library, String dartLibraryPath) {
+    print("[Patching; $library ($dartLibraryPath)");
     if (library.isPatched) return;
     Uri patchUri = resolvePatchUri(dartLibraryPath);
     if (patchUri !== null) {
-      LibraryElement patchLibrary =
-          patchParser.loadPatchLibrary(patchUri);
+      print("[... loading patch ...]");
+       patchParser.patchLibrary(patchUri, library);
       // We allow foreign functions in patched libraries.
       addForeignFunctions(library);  // Is safe even if already added.
-      applyLibraryPatch(library, patchLibrary);
+      // TODO(lrn): Make this lazy.
+      applyClassPatches(library);
     }
   }
 
-  void applyLibraryPatch(LibraryElement original, LibraryElement patch) {
-    Link<Element> patches = patch.localMembers;
-    applyContainerPatch(original, patches);
-
-    // Copy imports from patch to original library.
-    Map<String, LibraryElement> delayedPatches = <LibraryElement>{};
-    Uri patchBase = patch.uri;
-    for (ScriptTag tag in patch.tags.reverse()) {
-      if (tag.isImport()) {
-        StringNode argument = tag.argument;
-        Uri resolved = patchBase.resolve(argument.dartString.slowToString());
-        LibraryElement importedLibrary =
-            scanner.loadLibrary(resolved, argument);
-        scanner.importLibrary(original, importedLibrary, tag,
-                              patch.entryCompilationUnit);
-        if (resolved.scheme == "dart") {
-          delayedPatches[resolved.path] = importedLibrary;
+  void applyClassPatches(LibraryElement library) {
+    for (Element element in library.localMembers) {
+      if (element.isClass()) {
+        ClassElement classElement = element;
+        if (classElement.isPatched) {
+          applyClassPatch(classElement, classElement.patch);
         }
       }
     }
-
-    // Mark library as already patched.
-    original.patch = patch;
-
-    // We patch imported libraries after marking the current library as
-    // patched, to avoid problems with cyclic dependencies.
-    delayedPatches.forEach((String path, LibraryElement importedLibrary) {
-      patchDartLibrary(importedLibrary, path);
-    });
   }
 
   void applyContainerPatch(ScopeContainerElement original,
                            Link<Element> patches) {
     while (!patches.isEmpty()) {
       Element patchElement = patches.head;
       Element originalElement = original.localLookup(patchElement.name);
       if (patchElement.isAccessor()) {
         // TODO(lrn): When we change to always add accessors to members, and
         // not add abstract fields, the logic here should be reversed.
@@ skipping 148 matching lines @@
     library.addToScope(new ForeignElement(
         const SourceString('JS_CURRENT_ISOLATE'), library), this);
     library.addToScope(new ForeignElement(
         const SourceString('JS_CALL_IN_ISOLATE'), library), this);
     library.addToScope(new ForeignElement(
         const SourceString('DART_CLOSURE_TO_JS'), library), this);
   }
 
   void runCompiler(Uri uri) {
     scanBuiltinLibraries();
-    mainApp = scanner.loadLibrary(uri, null);
+    mainApp = scanner.loadLibrary(uri, null, uri);
     final Element main = mainApp.find(MAIN);
     if (main === null) {
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
       });
@@ skipping 358 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }