Revert "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) {
-      try {
-        unhandledExceptionOnElement(element);
-      } catch (var doubleFault) {
-        // Ignoring exceptions in exception handling.
-      }
+      unhandledExceptionOnElement(element);
       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") {
-          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);
   }
 }