Introduce typed selectors for getters and setters also for better tree shaking.

lib/compiler/implementation/enqueue.dart

Index: lib/compiler/implementation/enqueue.dart
===================================================================
--- lib/compiler/implementation/enqueue.dart	(revision 6933)
+++ lib/compiler/implementation/enqueue.dart	(working copy)
@@ -52,9 +52,11 @@
   }
 
   void processInstantiatedClassMember(Element member) {
-    if (compiler.universe.generatedCode.containsKey(member)) return;
+    Universe universe = compiler.universe;
+    if (universe.generatedCode.containsKey(member)) return;
 
     if (!member.isInstanceMember()) return;
+    if (member.isField()) return;
 
     String memberName = member.name.slowToString();
     Link<Element> members = instanceMembersByName.putIfAbsent(
@@ -63,24 +65,20 @@
 
     if (member.kind === ElementKind.GETTER ||
         member.kind === ElementKind.FIELD) {
-      compiler.universe.instantiatedClassInstanceFields.add(member.name);
+      universe.instantiatedClassInstanceFields.add(member.name);
     }
 
+    
     if (member.kind == ElementKind.FUNCTION) {
       if (member.name == Compiler.NO_SUCH_METHOD) {
         compiler.enableNoSuchMethod(member);
       }
-      Set<Selector> selectors = compiler.universe.invokedNames[member.name];
-      if (selectors != null) {
-        for (Selector selector in selectors) {
-          if (selector.applies(member, compiler)) {
-            return compiler.addToWorkList(member);
-          }
-        }
+      if (universe.hasOneInvocation(member, compiler)) {
+        return compiler.addToWorkList(member);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
-      if (compiler.universe.invokedGetters.contains(member.name)) {
+      if (universe.hasOneGetter(member, compiler)) {
         // We will emit a closure, so make sure the closure class is
         // generated.
         compiler.closureClass.ensureResolved(compiler);
@@ -88,21 +86,16 @@
         return compiler.addToWorkList(member);
       }
     } else if (member.kind == ElementKind.GETTER) {
-      if (compiler.universe.invokedGetters.contains(member.name)) {
+      if (universe.hasOneGetter(member, compiler)) {
         return compiler.addToWorkList(member);
       }
-      // A method invocation like in o.foo(x, y) might actually be an
-      // invocation of the getter foo followed by an invocation of the
-      // returned closure.
-      Set<Selector> invokedSelectors =
-        compiler.universe.invokedNames[member.name];
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
-      if (invokedSelectors !== null && !invokedSelectors.isEmpty()) {
+      if (universe.hasOneInvocation(member, compiler)) {
         return compiler.addToWorkList(member);
       }
     } else if (member.kind === ElementKind.SETTER) {
-      if (compiler.universe.invokedSetters.contains(member.name)) {
+      if (universe.hasOneSetter(member, compiler)) {
         return compiler.addToWorkList(member);
       }
     }
@@ -130,25 +123,33 @@
         invokedNames.putIfAbsent(methodName, () => new Set<Selector>());
       if (!selectors.contains(selector)) {
         selectors.add(selector);
-        handleUnseenInvocation(methodName, selector);
+        handleUnseenSelector(methodName, selector);
       }
     });
   }
 
-  void registerGetter(SourceString methodName) {
+  void registerGetter(SourceString methodName, Selector selector) {
     measure(() {
-      if (!compiler.universe.invokedGetters.contains(methodName)) {
-        compiler.universe.invokedGetters.add(methodName);
-        handleUnseenGetter(methodName);
+      Map<SourceString, Set<Selector>> invokedGetters =
+        compiler.universe.invokedGetters;
+      Set<Selector> selectors =
+        invokedGetters.putIfAbsent(methodName, () => new Set<Selector>());
+      if (!selectors.contains(selector)) {
+        selectors.add(selector);
+        handleUnseenSelector(methodName, selector);
       }
     });
   }
 
-  void registerSetter(SourceString methodName) {
+  void registerSetter(SourceString methodName, Selector selector) {
     measure(() {
-      if (!compiler.universe.invokedSetters.contains(methodName)) {
-        compiler.universe.invokedSetters.add(methodName);
-        handleUnseenSetter(methodName);
+      Map<SourceString, Set<Selector>> invokedSetters =
+        compiler.universe.invokedSetters;
+      Set<Selector> selectors =
+        invokedSetters.putIfAbsent(methodName, () => new Set<Selector>());
+      if (!selectors.contains(selector)) {
+        selectors.add(selector);
+        handleUnseenSelector(methodName, selector);
       }
     });
   }
@@ -165,40 +166,13 @@
     }
   }
 
-  void handleUnseenInvocation(SourceString methodName, Selector selector) {
+  void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
-      if (member.isGetter()) {
+      if (selector.applies(member, compiler)) {
         compiler.addToWorkList(member);
         return true;
-      } else if (member.isFunction()) {
-        if (selector.applies(member, compiler)) {
-          compiler.addToWorkList(member);
-          return true;
-        }
       }
       return false;
     });
   }
-
-  void handleUnseenGetter(SourceString methodName) {
-    processInstanceMembers(methodName, (Element member) {
-      if (member.isGetter() || member.isFunction()) {
-        compiler.addToWorkList(member);
-        return true;
-      } else {
-        return false;
-      }
-    });
-  }
-
-  void handleUnseenSetter(SourceString methodName) {
-    processInstanceMembers(methodName, (Element member) {
-      if (member.isSetter()) {
-        compiler.addToWorkList(member);
-        return true;
-      } else {
-        return false;
-      }
-    });
-  }
 }