Make selector registration in the resolver and code generator more explicit.

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 125 matching lines @@
         }
       }
     });
     return true;
   }
 
   void processInstantiatedClass(ClassElement cls) {
     cls.localMembers.forEach(processInstantiatedClassMember);
   }
 
-  void registerFieldClosureInvocations() {
-    task.measure(() {
-      // Make sure that the closure understands a call with the given
-      // selector. For a method-invocation of the form o.foo(a: 499), we
-      // need to make sure that closures can handle the optional argument if
-      // there exists a field or getter 'foo'.
-      var names = universe.instantiatedClassInstanceFields;
-      // TODO(ahe): Might be enough to use invokedGetters.
-      for (SourceString name in names) {
-        Set<Selector> invokedSelectors = universe.invokedNames[name];
-        if (invokedSelectors != null) {
-          for (Selector selector in invokedSelectors) {
-            Selector call = new Selector.call(
-                compiler.namer.CLOSURE_INVOCATION_NAME,
-                selector.library,  // TODO(kasperl): Use "default" library?
-                selector.argumentCount,
-                selector.namedArguments);
-            registerDynamicInvocation(compiler.namer.CLOSURE_INVOCATION_NAME,
-                                      call);
-          }
-        }
-      }
-    });
-  }
-
   void processInstantiatedClassMember(Element member) {
     if (universe.generatedCode.containsKey(member)) return;
     if (resolvedElements[member] !== null) return;
 
     if (!member.isInstanceMember()) return;
     if (member.isField()) return;
 
     String memberName = member.name.slowToString();
     Link<Element> members = instanceMembersByName.putIfAbsent(
         memberName, () => const EmptyLink<Element>());
@@ skipping 107 matching lines @@
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {
         addToWorkList(member);
         return true;
       }
       return false;
     });
   }
 
   void registerStaticUse(Element element) {
-    addToWorkList(element);
+    if (element !== null) addToWorkList(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(SourceString methodName, Selector selector) {
     assert(selector !== null);
     registerInvocation(methodName, selector);
@@ skipping 33 matching lines @@
     });
   }
 
   // TODO(ngeoffray): This should get a type.
   void registerIsCheck(Element element) {
     universe.isChecks.add(element);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
-      do {
-        f(queue.removeLast());
-      } while (!queue.isEmpty());
-      // TODO(ahe): we shouldn't register the field closure invocations here.
-      registerFieldClosureInvocations();
+      f(queue.removeLast()); // TODO(kasperl): Why isn't this removeFirst?

[ahe, 2012/08/16 12:09:54]

Main is added last and we want to process it first. LIFO (stack) behavior makes
the tests complete faster, and the user gets error messages faster for his code
(rather than waiting fo system classes).

     }
   }
 }