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

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 352 matching lines @@
     : super(name, kind, enclosingElement),
       localScope = new Map<SourceString, Element>();
 
   void addMember(Element element, DiagnosticListener listener) {
     super.addMember(element, listener);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     if (element.isAccessor()) {
-      addGetterOrSetter(element, localScope[element.name], listener);
+      addAccessorToScope(element, localScope[element.name], listener);
     } else {
       Element existing = localScope.putIfAbsent(element.name, () => element);
       if (existing !== element) {
         // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
         listener.cancel('duplicate definition', token: element.position());
         listener.cancel('existing definition', token: existing.position());
       }
     }
   }
 
   Element localLookup(SourceString elementName) {
     return localScope[elementName];
   }
 
-  void addGetterOrSetter(FunctionElement element,
-                         Element existing,
-                         DiagnosticListener listener) {
+  /**
+   * Adds a definition for an [accessor] (getter or setter) to a container.
+   * The definition binds to an abstract field that can hold both a getter
+   * and a setter.
+   *
+   * The abstract field is added once, for the first getter or setter, and
+   * reused if the other one is also added.
+   * The abstract field should not be treated as a proper member of the
+   * container, it's simply a way to return two results for one lookup.
+   * That is, the getter or setter does not have the abstract field as enclosing
+   * element, they are enclosed by the class or compilation unit, as is the
+   * abstract field.
+   */
+  void addAccessorToScope(Element accessor,
+                          Element existing,
+                          DiagnosticListener listener) {
     void reportError(Element other) {
       // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
-      listener.cancel('duplicate definition of ${element.name.slowToString()}',
-                      element: element);
+      listener.cancel('duplicate definition of ${accessor.name.slowToString()}',
+                      element: accessor);
       listener.cancel('existing definition', element: other);
     }
 
     if (existing != null) {
       if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
         reportError(existing);
       } else {
         AbstractFieldElement field = existing;
-        if (element.kind == ElementKind.GETTER) {
-          if (field.getter != null && field.getter != element) {
+        if (accessor.isGetter()) {
+          if (field.getter != null && field.getter != accessor) {
             reportError(field.getter);
           }
-          field.getter = element;
+          field.getter = accessor;
         } else {
-          if (field.setter != null && field.setter != element) {
+          assert(accessor.isSetter());
+          if (field.setter != null && field.setter != accessor) {
             reportError(field.setter);
           }
-          field.setter = element;
+          field.setter = accessor;
         }
       }
     } else {
-      Element container = element.getEnclosingClassOrCompilationUnit();
+      Element container = accessor.getEnclosingClassOrCompilationUnit();
       AbstractFieldElement field =
-          new AbstractFieldElement(element.name, container);
-      if (element.kind == ElementKind.GETTER) {
-        field.getter = element;
+          new AbstractFieldElement(accessor.name, container);
+      if (accessor.isGetter()) {
+        field.getter = accessor;
       } else {
-        field.setter = element;
+        field.setter = accessor;
       }
-      addMember(field, listener);
+      addToScope(field, listener);
     }
   }
 }
 
 class CompilationUnitElement extends ContainerElement {
   final Script script;
 
   CompilationUnitElement(Script script, Element enclosing)
     : this.script = script,
       super(new SourceString(script.name),
@@ skipping 1124 matching lines @@
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   Token position() => cachedNode.getBeginToken();
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, cachedNode, type, bound);
     return result;
   }
 }