Patch methods in classes.

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 503 matching lines @@
       LibraryElement patchLibrary =
           patchParser.loadPatchLibrary(patchUri);
       // We allow foreign functions in patched libraries.
       addForeignFunctions(library);  // Is safe even if already added.
       applyLibraryPatch(library, patchLibrary);
     }
   }
 
   void applyLibraryPatch(LibraryElement original, LibraryElement patch) {
     Link<Element> patches = patch.topLevelElements;
+    applyContainerPatch(original, patches, original.findLocal);
 
-    // Copy/patch top-level elements.
+    // 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);
+        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 = original.elements[patchElement.name];
+      Element originalElement = lookup(patchElement.name);
       // 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 (patchField.getter !== null) {
           if (originalField === null || originalField.getter === null) {
             original.addGetterOrSetter(clonePatch(patchField.getter));
           } else {
             patchMember(originalField.getter, patchField.getter);
           }
         }
         if (patchField.setter !== null) {
           if (originalField === null || originalField.setter === null) {
             original.addGetterOrSetter(clonePatch(patchField.setter));
           } else {
             patchMember(originalField.setter, patchField.setter);
           }
         }
       } else if (originalElement === null) {
+        if (isPatchElement(patchElement)) {
+          /// WHAT IS WRONG HERE? Why isn't _RANDOM in the library?

[floitsch, 2012/07/10 17:53:45]

remove?

[Lasse Reichstein Nielsen, 2012/07/11 07:45:22]

Absolutely. Just a comment to myself, so I could remember over lunch what I was
working on :)

+          internalError("Cannot patch non-existing member '"
+                        "${patchElement.name.slowToString()}'.");
+        }
         original.addMember(clonePatch(patchElement));
       } else {
         patchMember(originalElement, patchElement);
       }
       patches = patches.tail;
     }
-
-    // Copy imports.
-    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);
-        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);
-    });
   }
 
   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 (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.");
     }
-    // TODO(lrn): Create a copy of patchElement that isn't added to anything,
-    // but which takes its source from patchElement.
+    // 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) {
+  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) {
+      // Only happens when patching a library. Dart does not, yet, have nested
+      // classes.
+      if (patchElement is! PartialClassElement) {
+        internalError("Trying to patch class with non-class",
+                      element:originalElement);
+      }
+      applyClassPatch(originalElement, patchElement);
+      return;
+    }
     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.
+    FunctionElement original = originalElement;
+    if (!original.modifiers.isExternal()) {
+      internalError("Can only patch external functions.", element: original);
+    }
     if (patchElement is! FunctionElement ||
-        !patchSignatureMatches(originalElement, patchElement)) {
+        !patchSignatureMatches(original, patchElement)) {
       internalError("Can only patch functions with matching signatures",
-                    element: originalElement);
+                    element: original);
     }
-    applyFunctionPatch(originalElement, patchElement);
+    applyFunctionPatch(original, patchElement);
   }
 
   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) {
-    // Don't just assign the patch field. This also updates the cachedNode.
     if (element.isPatched) {
       internalError("Trying to patch a function more than once.",
                     element: element);
     }
     if (element.cachedNode !== null) {
       internalError("Trying to patch an already compiled function.",
                     element: element);
     }
+    // Don't just assign the patch field. This also updates the cachedNode.
     element.setPatch(patchElement);
   }
 
+  void applyClassPatch(PartialClassElement original,
+                       PartialClassElement patch) {
+    // Eagerly parse the class so we can patch it.
+    // TODO(lrn): Perhaps find a way to delay parsing until the class is needed,
+    // i.e., until [parseNode] is called on [original].

[floitsch, 2012/07/10 17:53:45]

Does parsing a class go into the methods? If not, then it shouldn't matter.

[Lasse Reichstein Nielsen, 2012/07/11 07:45:22]

It doesn't. 
We first diet-parse the structure of a library, where we don't even go into the
classes. Then we parse the classes if they are used, but don't parse the
function bodies yet (which is how the primitive patching works - it needs to be
done before the function body is first parsed, otherwise there might be a Node
out there pointing to the wrong body).
With this change, we immediately scan the bodies of patched classes, even if
they are never used.

+    ClassNode node = original.parseNode(this);
+    // Parse patch class with "patch" parser.
+    ClassNode patchNode = patchParser.parsePatchClassNode(patch);
+    Link<Element> patches = patch.members;
+    Element lookupMemberOrConstructor(SourceString name) {
+      Element result = original.lookupLocalMember(name);
+      if (result !== null) return result;
+      return original.lookupConstructor(name);
+    }
+    applyContainerPatch(original, patches, lookupMemberOrConstructor);
+  }
+
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   abstract Uri resolvePatchUri(String dartLibraryPath);
 
   /** Define the JS helper functions in the given library. */
   void addForeignFunctions(LibraryElement library) {
     library.define(new ForeignElement(
         const SourceString('JS'), library), this);
@@ skipping 378 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);
   }
 }