Clean patch implementation.

sdk/lib/_internal/compiler/implementation/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 105 matching lines @@
 
 import 'dart:async';
 
 import "tree/tree.dart" as tree;
 import "dart2jslib.dart" as leg;  // CompilerTask, Compiler.
 import "scanner/scannerlib.dart";  // Scanner, Parsers, Listeners
 import "elements/elements.dart";
 import "elements/modelx.dart"
     show LibraryElementX,
          MetadataAnnotationX,
+         ClassElementX,
          FunctionElementX;
 import 'util/util.dart';
 
 class PatchParserTask extends leg.CompilerTask {
   PatchParserTask(leg.Compiler compiler): super(compiler);
   final String name = "Patching Parser";
 
   /**
    * Scans a library patch file, applies the method patches and
    * injections to the library, and returns a list of class
@@ skipping 298 matching lines @@
     listener.reportError(
         origin, leg.MessageKind.PATCH_NON_CLASS, {'className': patch.name});
     listener.reportInfo(
         patch, leg.MessageKind.PATCH_POINT_TO_CLASS, {'className': patch.name});
     return;
   }
   patchClass(listener, origin, patch);
 }
 
 void patchClass(leg.DiagnosticListener listener,
-                 ClassElement origin,
-                 ClassElement patch) {
+                ClassElementX origin,
+                ClassElementX patch) {
   if (origin.isPatched) {
     listener.internalError(origin,
         "Patching the same class more than once.");
   }
-  // TODO(johnniwinther): Change to functions on the ElementX class.
-  origin.patch = patch;
-  patch.origin = origin;
+  origin.applyPatch(patch);
 }
 
 void tryPatchGetter(leg.DiagnosticListener listener,
-                     Element origin,
-                     FunctionElement patch) {
+                    Element origin,
+                    FunctionElement patch) {
   if (!origin.isAbstractField()) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NON_GETTER, {'name': origin.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.getter == null) {
@@ skipping 40 matching lines @@
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
         {'constructorName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void tryPatchFunction(leg.DiagnosticListener listener,
-                       Element origin,
-                       FunctionElement patch) {
+                      Element origin,
+                      FunctionElement patch) {
   if (!origin.isFunction()) {
     listener.reportError(
         origin,
         leg.MessageKind.PATCH_NON_FUNCTION, {'functionName': patch.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void patchFunction(leg.DiagnosticListener listener,
-                    FunctionElementX origin,
-                    FunctionElementX patch) {
+                   FunctionElementX origin,
+                   FunctionElementX patch) {
   if (!origin.modifiers.isExternal()) {
     listener.reportError(origin, leg.MessageKind.PATCH_NON_EXTERNAL);
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   if (origin.isPatched) {
     listener.internalError(origin,
         "Trying to patch a function more than once.");
   }
   if (origin.cachedNode != null) {
     listener.internalError(origin,
         "Trying to patch an already compiled function.");
   }
-  // Don't just assign the patch field. This also updates the cachedNode.
-  // TODO(johnniwinther): Change to functions on the ElementX class.
-  origin.setPatch(patch);
-  patch.origin = origin;
+  origin.applyPatch(patch);
 }
 
 // TODO(johnniwinther): Add unittest when patch is (real) metadata.
 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.
   for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
     if (link.head is PatchMetadataAnnotation) return true;
   }
   return false;
 }