Make patching of classes lazy.

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 363 matching lines @@
     //patchDartLibrary(coreImplLibrary, 'coreimpl');
   }
 
   void patchDartLibrary(LibraryElement library, String dartLibraryPath) {
     if (library.isPatched) return;
     Uri patchUri = resolvePatchUri(dartLibraryPath);
     if (patchUri !== null) {
        patchParser.patchLibrary(patchUri, library);
       // We allow foreign functions in patched libraries.
       addForeignFunctions(library);  // Is safe even if already added.
-      // TODO(lrn): Make this lazy.
-      applyClassPatches(library);
     }
   }
 
-  void applyClassPatches(LibraryElement library) {
-    for (Element element in library.localMembers) {
-      if (element.isClass()) {
-        ClassElement classElement = element;
-        if (classElement.isPatched) {
-          applyClassPatch(classElement, classElement.patch);
-        }
-      }
-    }
-  }
-
   void applyContainerPatch(ScopeContainerElement original,
                            Link<Element> patches) {
     while (!patches.isEmpty()) {
       Element patchElement = patches.head;
       Element originalElement = original.localLookup(patchElement.name);
       if (patchElement.isAccessor()) {
         // TODO(lrn): When we change to always add accessors to members, and
         // not add abstract fields, the logic here should be reversed.
         // For now, access getters through the abstract field and skip
         // any accessors.
@@ skipping 64 matching lines @@
 
   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);
     }
     FunctionElement original = originalElement;
     if (!original.modifiers.isExternal()) {
       internalError("Can only patch external functions.", element: original);
     }
     if (patchElement is! FunctionElement ||
         !patchSignatureMatches(original, patchElement)) {
@@ skipping 16 matching lines @@
                     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].
-    ClassNode node = original.parseNode(this);
-    // Parse patch class with "patch" parser.
-    ClassNode patchNode = patchParser.parsePatchClassNode(patch);
-    Link<Element> patches = patch.localMembers;
-    applyContainerPatch(original, patches);
-  }
-
   /**
    * 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.addToScope(new ForeignElement(
         const SourceString('JS'), library), this);
@@ skipping 383 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)';
 }