Start creating a MemberSet abstraction, and use it to fold getters/setters into field accesses.

lib/compiler/implementation/universe.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.
 
 class Universe {
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
   final Map<SourceString, Set<Selector>> invokedNames;
   final Map<SourceString, Set<Selector>> invokedGetters;
   final Map<SourceString, Set<Selector>> invokedSetters;
   final Map<String, LibraryElement> libraries;
   // TODO(ngeoffray): This should be a Set<Type>.
   final Set<Element> isChecks;
   final RuntimeTypeInformation rti;
+  final Map<ClassElement, Set<ClassElement>> subtypes;
 
   Universe() : generatedCode = new Map<Element, String>(),
                generatedBailoutCode = new Map<Element, String>(),
                libraries = new Map<String, LibraryElement>(),
                instantiatedClasses = new Set<ClassElement>(),
                instantiatedClassInstanceFields = new Set<SourceString>(),
                staticFunctionsNeedingGetter = new Set<FunctionElement>(),
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
                invokedSetters = new Map<SourceString, Set<Selector>>(),
                isChecks = new Set<Element>(),
+               subtypes = new Map<ClassElement, Set<ClassElement>>(),
                rti = new RuntimeTypeInformation();
 
   void addGeneratedCode(WorkItem work, String code) {
     generatedCode[work.element] = code;
   }
 
   void addBailoutCode(WorkItem work, String code) {
     generatedBailoutCode[work.element] = code;
   }
 
@@ skipping 13 matching lines @@
   }
 
   bool hasGetter(Element member, Compiler compiler) {
     return hasMatchingSelector(
         compiler.universe.invokedGetters[member.name], member, compiler);
   }
 
   bool hasSetter(Element member, Compiler compiler) {
     return hasMatchingSelector(
         compiler.universe.invokedSetters[member.name], member, compiler);
-  }  
+  }
+
+  /**
+   * Returns a [MemberSet] that contains the possible targets of a
+   * selector named [member] on a receiver whose type is [type].

[kasperl, 2012/05/09 08:04:23]

Wouldn't it be more logical to let this be parameterized by a selector (possibly
a typed one?).

[ngeoffray, 2012/05/09 10:07:58]

Yes, that's what I started with. But right now, the typed selector would be
created only to call this method. So I'd rather wait on starting having multiple
users of the API before settling on it.

+   */
+  MemberSet memberSetFor(Type type, SourceString member) {
+    ClassElement cls = type.element;
+    MemberSet result = new MemberSet(member);
+    Element element = cls.lookupMember(member);
+    if (element !== null) result.add(element);
+
+    Set<ClassElement> subtypes = subtypes[cls];
+    if (subtypes !== null) {
+      for (ClassElement sub in subtypes) {
+        element = sub.lookupLocalMember(member);
+        if (element !== null) result.add(element);
+      }
+    }
+    return result;
+  }
+}
+
+/**
+ * A [MemberSet] contains all the possible targets for a selector.
+ */
+class MemberSet {
+  final Set<Element> elements;
+  final SourceString name;
+
+  MemberSet(SourceString this.name) : elements = new Set<Element>();
+
+  void add(Element element) {
+    elements.add(element);
+  }
+
+  bool isEmpty() => elements.isEmpty();
+
+  bool hasJustFields() {
+    return elements.every((Element element) => element.isField());
+  }
 }
 
 class SelectorKind {
   final String name;
   const SelectorKind(this.name);
 
   static final SelectorKind GETTER = const SelectorKind('getter');
   static final SelectorKind SETTER = const SelectorKind('setter');
   static final SelectorKind INVOCATION = const SelectorKind('invocation');
   static final SelectorKind OPERATOR = const SelectorKind('operator');
@@ skipping 265 matching lines @@
 
     return false;
   }
 
   bool operator ==(other) {
     if (other is !TypedSelector) return false;
     if (other.receiverType !== receiverType) return false;
     return super == other;
   }
 }