Use simple loop tracking instead of size to determine if

lib/compiler/implementation/enqueue.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 EnqueueTask extends CompilerTask {
   final Enqueuer codegen;
   final Enqueuer resolution;
 
   String get name() => 'Enqueue';
 
@@ skipping 130 matching lines @@
         // when resolveType is called.
         compiler.resolveClass(cls);
         cls.members.forEach(processInstantiatedClassMember);
         cls = cls.superclass;
       }
     });
   }
 
   void registerNewSelector(SourceString name,
                            Selector selector,
-                           Map<SourceString, Set<Selector>> selectorsMap) {
+                           Map<SourceString, Set<Selector>> selectorsMap,
+                           [bool inLoop]) {

[ngeoffray, 2012/06/12 09:17:40]

I wouldn't let the enqueuer be aware of such considerations. It's really
something only the backend needs to care.

[Mads Ager (google), 2012/06/12 11:01:56]

Good point. Removed.

     Set<Selector> selectors =
         selectorsMap.putIfAbsent(name, () => new Set<Selector>());
     if (!selectors.contains(selector)) {
       selectors.add(selector);
-      handleUnseenSelector(name, selector);
+      handleUnseenSelector(name, selector, inLoop);
     }
   }
 
-  void registerInvocation(SourceString methodName, Selector selector) {
+  void registerInvocation(SourceString methodName,
+                          Selector selector,
+                          [bool inLoop]) {
     task.measure(() {
-      registerNewSelector(methodName, selector, universe.invokedNames);
+      registerNewSelector(methodName, selector, universe.invokedNames, inLoop);
     });
   }
 
   void registerGetter(SourceString getterName, Selector selector) {
     task.measure(() {
       registerNewSelector(getterName, selector, universe.invokedGetters);
     });
   }
 
   void registerSetter(SourceString setterName, Selector selector) {
     task.measure(() {
       registerNewSelector(setterName, selector, universe.invokedSetters);
     });
   }
 
   processInstanceMembers(SourceString n, bool f(Element e)) {
     String memberName = n.slowToString();
     Link<Element> members = instanceMembersByName[memberName];
     if (members !== null) {
       LinkBuilder<Element> remaining = new LinkBuilder<Element>();
       for (; !members.isEmpty(); members = members.tail) {
         if (!f(members.head)) remaining.addLast(members.head);
       }
       instanceMembersByName[memberName] = remaining.toLink();
     }
   }
 
-  void handleUnseenSelector(SourceString methodName, Selector selector) {
+  void handleUnseenSelector(SourceString methodName,
+                            Selector selector,
+                            [bool inLoop]) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {
+        if (inLoop && member is FunctionElement) member.calledInLoop = true;
         addToWorkList(member);
         return true;
       }
       return false;
     });
   }
 
   void registerStaticUse(Element element) {
     addToWorkList(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
-  void registerDynamicInvocation(SourceString methodName, Selector selector) {
+  void registerDynamicInvocation(SourceString methodName,
+                                 Selector selector,
+                                 [bool inLoop]) {
     assert(selector !== null);
-    registerInvocation(methodName, selector);
+    registerInvocation(methodName, selector, inLoop);
   }
 
   void registerDynamicInvocationOf(Element element) {
     addToWorkList(element);
   }
 
   void registerDynamicGetter(SourceString methodName, Selector selector) {
     registerGetter(methodName, selector);
   }
 
   void registerDynamicSetter(SourceString methodName, Selector selector) {
     registerSetter(methodName, selector);
   }
 
   // TODO(ngeoffray): This should get a type.
   void registerIsCheck(Element element) {
     universe.isChecks.add(element);
   }
 }