Don't rely on resolution for enqueuing

pkg/fletchc/lib/src/fletch_enqueuer.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 library fletchc.fletch_enqueuer;
 
 import 'dart:collection' show
     Queue;
 
 import 'package:compiler/src/dart2jslib.dart' show
     CodegenEnqueuer,
     Compiler,
     CompilerTask,
     EnqueueTask,
     ItemCompilationContextCreator,
     QueueFilter,
     Registry,
     ResolutionEnqueuer,
     WorkItem,
     WorldImpact;
 
 import 'package:compiler/src/universe/universe.dart' show
     CallStructure,
+    Selector,
     Universe,
     UniverseSelector;
 
 import 'package:compiler/src/dart_types.dart' show
     DartType,
     InterfaceType;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     ConstructorElement,
@@ skipping 38 matching lines @@
   // TODO(ahe): Should be typed [FletchEnqueuer].
   final CodegenEnqueuer codegen;
 
   FletchEnqueueTask(FletchCompilerImplementation compiler)
     : resolution = new ResolutionEnqueuer(
           compiler, compiler.backend.createItemCompilationContext),
       codegen = makeCodegenEnqueuer(compiler),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
-    if (codegen is! TransitionalFletchEnqueuer) {
-      FletchEnqueuer fletchEnqueuer = codegen;
-      fletchEnqueuer.dynamicCallEnqueuer.task = this;
-    }
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
 
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 
   String get name => 'Fletch enqueue';
 
   void forgetElement(Element element) {
     resolution.forgetElement(element);
@@ skipping 54 matching lines @@
     queue.add(workItem);
     return true;
   }
 
   DynamicCallEnqueuer get dynamicCallEnqueuer => notImplemented;
 
   Set<Element> get _enqueuedElements => notImplemented;
 
   Queue<Element> get _pendingEnqueuedElements => notImplemented;
 
-  void _enqueueElement(Element element) => notImplemented;
+  void _enqueueElement(element, selector) => notImplemented;
 }
 
 class FletchEnqueuer extends EnqueuerMixin implements CodegenEnqueuer {
   final ItemCompilationContextCreator itemCompilationContextCreator;
 
   final FletchCompilerImplementation compiler;
 
   final Map generatedCode = new Map();
 
   bool queueIsClosed = false;
@@ skipping 43 matching lines @@
     dynamicCallEnqueuer.forgetElement(element);
   }
 
   void registerInstantiatedType(
       InterfaceType type,
       Registry registry,
       {bool mirrorUsage: false}) {
     dynamicCallEnqueuer.registerInstantiatedType(type);
   }
 
+  // TODO(ahe): Remove this method.
   void registerStaticUse(Element element) {
-    _enqueueElement(element);
+    _enqueueElement(
+        element,
+        new UniverseSelector(new Selector.fromElement(element), null));
   }
 
+  // TODO(ahe): Remove this method.
   void addToWorkList(Element element) {
-    _enqueueElement(element);
+    _enqueueElement(
+        element, new UniverseSelector(new Selector.fromElement(element), null));
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       do {
         while (!queueIsEmpty) {
           Element element = _pendingEnqueuedElements.removeFirst();
           if (element.isField) continue;
           FletchCodegenWorkItem workItem = new FletchCodegenWorkItem(
               compiler, element, itemCompilationContextCreator());
@@ skipping 28 matching lines @@
   }
 
   void registerDynamicGetter(UniverseSelector selector) {
     dynamicCallEnqueuer.enqueueSelector(selector);
   }
 
   void registerDynamicSetter(UniverseSelector selector) {
     dynamicCallEnqueuer.enqueueSelector(selector);
   }
 
-  void _enqueueElement(Element element) {
+  void _enqueueElement(Element element, UniverseSelector selector) {
     if (_enqueuedElements.add(element)) {
       _pendingEnqueuedElements.addLast(element);
       newlyEnqueuedElements.add(element);
       compiler.reportVerboseInfo(element, "enqueued this", forceVerbose: true);
     }
   }
 }