Move registering to the enqueuer.

dart/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 19 matching lines @@
     : instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>();
 
   void addToWorkList(Element element, [TreeElements elements]) {
     if (queueIsClosed) {
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
-      compiler.registerInstantiatedClass(element.enclosingElement);
+      registerInstantiatedClass(element.enclosingElement);
     }
     queue.add(new WorkItem(element, elements));
   }
 
   void registerInstantiatedClass(ClassElement cls) {
     universe.instantiatedClasses.add(cls);
     onRegisterInstantiatedClass(cls);
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
@@ skipping 19 matching lines @@
       // 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) {
-            compiler.registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME,
-                                               selector);
+            registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME, selector);
           }
         }
       }
     });
   }
 
   void processInstantiatedClassMember(Element member) {
     if (universe.generatedCode.containsKey(member)) return;
 
     if (!member.isInstanceMember()) return;
@@ skipping 15 matching lines @@
       }
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasGetter(member, compiler)) {
         // We will emit a closure, so make sure the closure class is
         // generated.
         compiler.closureClass.ensureResolved(compiler);
-        compiler.registerInstantiatedClass(compiler.closureClass);
+        registerInstantiatedClass(compiler.closureClass);
         return addToWorkList(member);
       }
     } else if (member.kind == ElementKind.GETTER) {
       if (universe.hasGetter(member, compiler)) {
         return addToWorkList(member);
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
@@ skipping 62 matching lines @@
 
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {
         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) {
+    assert(selector !== null);
+    registerInvocation(methodName, selector);
+  }
+
+  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);
+  }
 }