Revert "Allow patch files to add top-level declarations to the patched 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 516 matching lines @@
 
     // Copy imports from patch to original library.
     Map<String, LibraryElement> delayedPatches = <LibraryElement>{};
     Uri patchBase = patch.script.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.script);
+        scanner.importLibrary(original, importedLibrary, tag, patch);
         if (resolved.scheme == "dart") {
           delayedPatches[resolved.path] = importedLibrary;
         }
       }
     }
 
     // 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(ContainerElement original, Link<Element> patches,
                            Element lookup(SourceString name)) {
     while (!patches.isEmpty()) {
       Element patchElement = patches.head;
       Element originalElement = lookup(patchElement.name);
-      assert(patchElement.kind !== ElementKind.ABSTRACT_FIELD);
-      if (originalElement !== null &&
-          originalElement.kind === ElementKind.ABSTRACT_FIELD) {
+      // Getters and setters are kept inside a synthetic field.
+      if (patchElement.kind === ElementKind.ABSTRACT_FIELD) {
+        if (originalElement !== null &&
+            originalElement.kind !== ElementKind.ABSTRACT_FIELD) {
+          internalError("Cannot patch non-getter/setter with getter/setter",
+                        element: originalElement);
+        }
+        AbstractFieldElement patchField = patchElement;
         AbstractFieldElement originalField = originalElement;
-        if (patchElement.kind === ElementKind.GETTER) {
-          originalElement = originalField.getter;
-        } else if (patchElement.kind === ElementKind.SETTER) {
-          originalElement = originalField.setter;
-        } else {
-          internalError("Cannot patch a getter/setter field with a "
-                        "non-getter/setter patch", element: originalElement);
+        if (patchField.getter !== null) {
+          if (originalField === null || originalField.getter === null) {
+            original.addGetterOrSetter(clonePatch(patchField.getter),
+                                       originalField,
+                                       this);
+            if (originalField === null && patchField.setter !== null) {
+              // It exists now, so find it for the setter patching.
+              originalField = lookup(patchElement.name);
+            }
+          } else {
+            patchMember(originalField.getter, patchField.getter);
+          }
         }
-      }
-      if (originalElement === null) {
-        // The original library does not have an element with the same name
-        // as the patch library element.
-        // In this case, the patch library element must not be marked as
-        // "patch", and its name must make it private.
+        if (patchField.setter !== null) {
+          if (originalField === null || originalField.setter === null) {
+            original.addGetterOrSetter(clonePatch(patchField.setter),
+                                       originalField,
+                                       this);
+          } else {
+            patchMember(originalField.setter, patchField.setter);
+          }
+        }
+      } else if (originalElement === null) {
         if (isPatchElement(patchElement)) {
           internalError("Cannot patch non-existing member '"
                         "${patchElement.name.slowToString()}'.");
         }
-        if (!patchElement.name.isPrivate()) {
-          internalError("Cannot add non-private member '"
-                        "${patchElement.name.slowToString()}' from patch.");
-        }
-        Element cloneElement = patchElement.cloneTo(original, this);
-        original.addMember(cloneElement, this);
+        original.addMember(clonePatch(patchElement), this);
       } else {
         patchMember(originalElement, patchElement);
       }
       patches = patches.tail;
     }
   }
 
   bool isPatchElement(Element element) {
     // TODO(lrn): More checks needed if we introduce metadata for real.
     // In that case, it must have the identifier "native" as metadata.
     return !element.metadata.isEmpty();
   }
 
+  Element clonePatch(Element patchElement) {
+    // The original library does not have an element with the same name
+    // as the patch library element.
+    // In this case, the patch library element must not be marked as "patch",
+    // and its name must make it private.
+    if (!patchElement.name.isPrivate()) {
+      internalError("Cannot add non-private member '"
+                    "${patchElement.name.slowToString()}' from patch.");
+    }
+    // TODO(lrn): Create a copy of patchElement that isn't added to any
+    // object/library yet, but which takes its source from patchElement.
+    throw "Adding members from patch is unsupported";
+  }
+
   void patchMember(Element originalElement, Element patchElement) {
     // The original library has an element with the same name as the patch
     // library element.
     // In this case, the patch library element must be a function marked as
     // "patch" and it must have the same signature as the function it patches.
     if (!isPatchElement(patchElement)) {
       internalError("Cannot overwrite existing '"
                     "${originalElement.name.slowToString()}' with non-patch.");
     }
     if (originalElement is PartialClassElement) {
@@ skipping 338 matching lines @@
                                  api.Diagnostic kind);
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin === null || end === null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri === null && currentElement !== null) {
-      uri = currentElement.getScript().uri;
+      uri = currentElement.getCompilationUnit().script.uri;
     }
     return SourceSpan.withCharacterOffsets(begin, end,
       (beginOffset, endOffset) => new SourceSpan(uri, beginOffset, endOffset));
   }
 
   SourceSpan spanFromNode(Node node, [Uri uri]) {
     return spanFromTokens(node.getBeginToken(), node.getEndToken(), uri);
   }
 
   SourceSpan spanFromElement(Element element) {
     if (element.position() === null) {
       // Sometimes, the backend fakes up elements that have no
       // position. So we use the enclosing element instead. It is
       // not a good error location, but cancel really is "internal
       // error" or "not implemented yet", so the vicinity is good
       // enough for now.
       element = element.enclosingElement;
       // TODO(ahe): I plan to overhaul this infrastructure anyways.
     }
     if (element === null) {
       element = currentElement;
     }
     Token position = element.position();
-    Uri uri = element.getScript().uri;
+    Uri uri = element.getCompilationUnit().script.uri;
     return (position === null)
         ? new SourceSpan(uri, 0, 0)
         : spanFromTokens(position, position, uri);
   }
 
   Script readScript(Uri uri, [ScriptTag node]) {
     unimplemented('Compiler.readScript');
   }
 
   String get legDirectory() {
@@ skipping 69 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)';
 }