Make patch file import declarations apply to the patched library too.

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 251 matching lines @@
     _currentElement = element;
     try {
       return f();
     } catch (CompilerCancelledException ex) {
       throw;
     } catch (StackOverflowException ex) {
       // We cannot report anything useful in this case, because we
       // do not have enough stack space.
       throw;
     } catch (var ex) {
-      unhandledExceptionOnElement(element);
+      try {
+        unhandledExceptionOnElement(element);
+      } catch (var doubleFault) {}

[Johnni Winther, 2012/07/03 11:04:29]

Move the ending } to a new line and insert a comment like 
// Ignore double faults.
in the catch block.

[Lasse Reichstein Nielsen, 2012/07/03 13:01:03]

Done.

       throw;
     } finally {
       _currentElement = old;
     }
   }
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
@@ skipping 235 matching lines @@
     if (patchUri !== null) {
       // TODO(lrn): Use a different parser to allow for "patch" annotations.
       // For now just assume everything in the patch library is a patch
       // function.
       LibraryElement patchLibrary = scanner.loadLibrary(patchUri, null);
       applyLibraryPatch(library, patchLibrary);
     }
   }
 
   void applyLibraryPatch(LibraryElement library, LibraryElement patch) {
+    // We allow foreign functions in patched libraries.
+    addForeignFunctions(library);  // Is safe even if already added.
+
+    // Copy/patch top-level elements.
     Link<Element> patches = patch.topLevelElements;
     while (!patches.isEmpty()) {
       Element patchElement = patches.head;
       Element originalElement = library.elements[patchElement.name];
       if (originalElement !== null) {
         // Assume that we are patching if the original exists.
         if (originalElement is! FunctionElement) {
           // TODO(lrn): Handle class declarations too.
           internalError("Can only patch functions", element: originalElement);
         }
         // TODO(lrn): Abort if the original isn't marked external, when
         // that is added to the language.
         if (patchElement is! FunctionElement ||
             !patchSignatureMatches(originalElement, patchElement)) {
           internalError("Can only patch functions with matching signatures",
                         element: originalElement);
         }
         applyFunctionPatch(originalElement, patchElement);
       } else {
         // TODO(lrn): Allow adding private elements to the original library.
       }
       patches = patches.tail;
     }
+
+    // Copy imports.
+    Map<String, LibraryElement> delayedPatches = <LibraryElement>{};
+    Uri base = patch.script.uri;
+    for (ScriptTag tag in patch.tags.reverse()) {
+      if (tag.isImport()) {
+        StringNode argument = tag.argument;
+        Uri resolved = base.resolve(argument.dartString.slowToString());
+        LibraryElement importedLibrary =
+            scanner.loadLibrary(resolved, argument);
+        scanner.importLibrary(library, importedLibrary, tag, patch);
+        if (resolved.scheme == "dart") {

[floitsch, 2012/07/03 12:06:55]

I would prefer this check in 'patchDartLibrary'. This seems to be the wrong
moment to make sure that we don't patch non-core libraries.

[Lasse Reichstein Nielsen, 2012/07/03 12:55:04]

This is not a check to avoid patching non-dart libraries as such. It's a check
to make sure that resolved.path is the name of a dart library, so we can use it
as the second argument to patchDartLibrary. We can't call patchDartLibrary at
all if this isn't the case.

+          delayedPatches[resolved.path] = importedLibrary;
+        }
+      }
+    }
+    // Mark library as already patched.
     library.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);
+    });
   }
 
   bool patchSignatureMatches(FunctionElement original, FunctionElement patch) {
     // TODO(lrn): Check that patches actually match the signature of
     // the function it's patching.
     return true;
   }
 
   void applyFunctionPatch(FunctionElement element,
                           FunctionElement patchElement) {
@@ skipping 400 matching lines @@
                      f(int beginOffset, int endOffset)) {
     final beginOffset = begin.charOffset;
     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);
   }
 }