Make addGetterOrSetter (now: defineAccessor) not add the abstract field as a member.

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 538 matching lines @@
     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);
-      if (patchElement.isAccessor()) {
-        // Skip accessors. An accessor always has an abstract field,
-        // representing the accessor in the lookup scope. We can thus skip the
-        // accessors and just handle the abstract field.
-      } else if (patchElement.kind === ElementKind.ABSTRACT_FIELD) {
-        // Getters and setters are kept inside a synthetic field.
-        if (originalElement !== null &&
-            originalElement.kind !== ElementKind.ABSTRACT_FIELD) {
+      if (patchElement.isAccessor() && originalElement !== null) {

[Anders Johnsen, 2012/08/07 13:02:30]

Maybe move originalElement !== null check out (and enclose this), so we group
patching vs. injecting. This will also make it clear where to check if an
element is patch vs. non-patch(injected).

+        if (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),
-                                       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 (patchElement.isGetter()) {
+          originalElement = originalField.getter;
+        } else {
+          originalElement = originalField.setter;
         }
-        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 (originalElement === null) {
         if (isPatchElement(patchElement)) {
           internalError("Cannot patch non-existing member '"
                         "${patchElement.name.slowToString()}'.");
         }
         original.addMember(clonePatch(patchElement), this);
       } else {
         patchMember(originalElement, patchElement);
       }
       patches = patches.tail;
     }
@@ skipping 490 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)';
 }