Port the remaining of dart:core to the unified corelib.

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 553 matching lines @@
         // Getters and setters are kept inside a synthetic 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 (patchField.getter !== null) {
           if (originalField === null || originalField.getter === null) {
-            original.addGetterOrSetter(clonePatch(patchField.getter),
+            original.addGetterOrSetter(clonePatch(patchField.getter, original),
                                        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 (patchField.setter !== null) {
           if (originalField === null || originalField.setter === null) {
-            original.addGetterOrSetter(clonePatch(patchField.setter),
+            original.addGetterOrSetter(clonePatch(patchField.setter, original),
                                        originalField,
                                        this);
           } else {
             patchMember(originalField.setter, patchField.setter);
           }
         }
       } else if (originalElement === null) {
         if (isPatchElement(patchElement)) {
           internalError("Cannot patch non-existing member '"
                         "${patchElement.name.slowToString()}'.");
         }
-        original.addMember(clonePatch(patchElement), this);
+        original.addMember(clonePatch(patchElement, original), 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) {
+  Element clonePatch(Element patchElement, Element enclosing) {
     // 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.");
     }
+    if (patchElement.isFunction()) {
+      var function = new FunctionElement.from(patchElement.name,
+                                              patchElement,
+                                              enclosing);
+      // Give the cloned function a patch reference, so it gets the correct
+      // compilation unit for reporting diagnostics.
+      function.setPatch(patchElement);
+      return function;
+    } else if (patchElement.isField()) {
+      // TODO(ajohnsen): Decide if a VariableElement should have a patch field.
+      return new VariableElement.from(patchElement.name,
+                                      patchElement,
+                                      enclosing);
+    }
     // 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";
+    throw "Adding ${patchElement.kind} 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.");
@@ skipping 460 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)';
 }