Refactor enqueuers

pkg/compiler/lib/src/js_backend/backend.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.
 
 library js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 56 matching lines @@
 import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_serialization.dart' show JavaScriptBackendSerialization;
 import 'checked_mode_helpers.dart';
 import 'constant_handler_javascript.dart';
 import 'custom_elements_analysis.dart';
 import 'enqueuer.dart';
 import 'js_interop_analysis.dart' show JsInteropAnalysis;
 import '../kernel/task.dart';
 import 'lookup_map_analysis.dart' show LookupMapAnalysis;
+import 'mirrors_analysis.dart';
 import 'namer.dart';
 import 'native_data.dart' show NativeData;
 import 'no_such_method_registry.dart';
 import 'patch_resolver.dart';
 import 'type_variable_handler.dart';
 
 part 'runtime_types.dart';
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
@@ skipping 478 matching lines @@
 
   /// Codegen support for tree-shaking entries of `LookupMap`.
   LookupMapAnalysis lookupMapAnalysis;
 
   /// Codegen support for typed JavaScript interop.
   JsInteropAnalysis jsInteropAnalysis;
 
   /// Support for classifying `noSuchMethod` implementations.
   NoSuchMethodRegistry noSuchMethodRegistry;
 
+  /// Resolution and codegen support for computing reflectable elements.
+  MirrorsAnalysis mirrorsAnalysis;
+
   /// Builds kernel representation for the program.
   KernelTask kernelTask;
 
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptImpactTransformer impactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
@@ skipping 36 matching lines @@
         helpers = new BackendHelpers(compiler),
         impacts = new BackendImpacts(compiler),
         frontend = new JSFrontendAccess(compiler),
         super(compiler) {
     emitter = new CodeEmitterTask(
         compiler, namer, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     jsInteropAnalysis = new JsInteropAnalysis(this);
+    mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(this);
     backendClasses = new JavaScriptBackendClasses(helpers);
@@ skipping 405 matching lines @@
       // Walk superclass chain to find mixins.
       for (; cls != null; cls = cls.superclass) {
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classesMixedIntoInterceptedClasses.add(mixinApplication.mixin);
         }
       }
     }
   }
 
-  void addInterceptors(ClassElement cls, Enqueuer enqueuer, Registry registry) {
+  void addInterceptors(ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       _interceptedClasses.add(helpers.jsInterceptorClass);
       _interceptedClasses.add(cls);
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == coreClasses.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
       }, includeSuperAndInjectedMembers: true);
     }
-    enqueueClass(enqueuer, cls, registry);
+    enqueueClass(enqueuer, cls);
   }
 
   Set<ClassElement> get interceptedClasses {
     assert(compiler.enqueuer.resolution.queueIsClosed);
     return _interceptedClasses;
   }
 
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     jsAst.Name name = namer.nameForGetInterceptor(classes);
     if (classes.contains(helpers.jsInterceptorClass)) {
@@ skipping 72 matching lines @@
         // constant emitter will generate a call to the createRuntimeType
         // helper so we register a use of that.
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             helpers.createRuntimeType,
             null));
       }
     }
   }
 
-  void registerInstantiatedClass(
-      ClassElement cls, Enqueuer enqueuer, Registry registry) {
-    _processClass(cls, enqueuer, registry);
+  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
+    _processClass(cls, enqueuer);
   }
 
-  void registerImplementedClass(
-      ClassElement cls, Enqueuer enqueuer, Registry registry) {
-    _processClass(cls, enqueuer, registry);
+  void registerImplementedClass(ClassElement cls, Enqueuer enqueuer) {
+    _processClass(cls, enqueuer);
   }
 
-  void _processClass(ClassElement cls, Enqueuer enqueuer, Registry registry) {
+  void _processClass(ClassElement cls, Enqueuer enqueuer) {
     if (!cls.typeVariables.isEmpty) {
-      typeVariableHandler.registerClassWithTypeVariables(
-          cls, enqueuer, registry);
+      typeVariableHandler.registerClassWithTypeVariables(cls, enqueuer);
     }
 
     // Register any helper that will be needed by the backend.
     if (enqueuer.isResolutionQueue) {
       if (cls == coreClasses.intClass ||
           cls == coreClasses.doubleClass ||
           cls == coreClasses.numClass) {
         // The backend will try to optimize number operations and use the
         // `iae` helper directly.
-        enqueue(enqueuer, helpers.throwIllegalArgumentException, registry);
+        enqueue(enqueuer, helpers.throwIllegalArgumentException);
       } else if (cls == coreClasses.listClass ||
           cls == coreClasses.stringClass) {
         // The backend will try to optimize array and string access and use the
         // `ioore` and `iae` helpers directly.
-        enqueue(enqueuer, helpers.throwIndexOutOfRangeException, registry);
-        enqueue(enqueuer, helpers.throwIllegalArgumentException, registry);
+        enqueue(enqueuer, helpers.throwIndexOutOfRangeException);
+        enqueue(enqueuer, helpers.throwIllegalArgumentException);
       } else if (cls == coreClasses.functionClass) {
-        enqueueClass(enqueuer, helpers.closureClass, registry);
+        enqueueClass(enqueuer, helpers.closureClass);
       } else if (cls == coreClasses.mapClass) {
         // The backend will use a literal list to initialize the entries
         // of the map.
-        enqueueClass(enqueuer, coreClasses.listClass, registry);
-        enqueueClass(enqueuer, helpers.mapLiteralClass, registry);
+        enqueueClass(enqueuer, coreClasses.listClass);
+        enqueueClass(enqueuer, helpers.mapLiteralClass);
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(helpers.mapLiteralClass, cls);
       } else if (cls == helpers.boundClosureClass) {
         // TODO(johnniwinther): Is this a noop?
-        enqueueClass(enqueuer, helpers.boundClosureClass, registry);
+        enqueueClass(enqueuer, helpers.boundClosureClass);
       } else if (isNativeOrExtendsNative(cls)) {
-        enqueue(enqueuer, helpers.getNativeInterceptorMethod, registry);
-        enqueueClass(
-            enqueuer, helpers.jsInterceptorClass, compiler.globalDependencies);
-        enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass, registry);
-        enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass, registry);
-        enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass, registry);
+        enqueue(enqueuer, helpers.getNativeInterceptorMethod);
+        enqueueClass(enqueuer, helpers.jsInterceptorClass);
+        enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass);
+        enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass);
+        enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass);
       } else if (cls == helpers.mapLiteralClass) {
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         Element getFactory(String name, int arity) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
           ClassElement implementation = cls.implementation;
           ConstructorElement ctor = implementation.lookupConstructor(name);
           if (ctor == null ||
               (Name.isPrivateName(name) &&
@@ skipping 16 matching lines @@
             reporter.internalError(
                 helpers.mapLiteralClass,
                 "Map literal class ${helpers.mapLiteralClass} missing "
                 "'$name' static member function");
           }
           return element;
         }
 
         helpers.mapLiteralConstructor = getFactory('_literal', 1);
         helpers.mapLiteralConstructorEmpty = getFactory('_empty', 0);
-        enqueueInResolution(helpers.mapLiteralConstructor, registry);
-        enqueueInResolution(helpers.mapLiteralConstructorEmpty, registry);
+        enqueue(enqueuer, helpers.mapLiteralConstructor);
+        enqueue(enqueuer, helpers.mapLiteralConstructorEmpty);
 
         helpers.mapLiteralUntypedMaker = getMember('_makeLiteral');
         helpers.mapLiteralUntypedEmptyMaker = getMember('_makeEmpty');
-        enqueueInResolution(helpers.mapLiteralUntypedMaker, registry);
-        enqueueInResolution(helpers.mapLiteralUntypedEmptyMaker, registry);
+        enqueue(enqueuer, helpers.mapLiteralUntypedMaker);
+        enqueue(enqueuer, helpers.mapLiteralUntypedEmptyMaker);
       }
     }
     if (cls == helpers.closureClass) {
-      enqueue(enqueuer, helpers.closureFromTearOff, registry);
+      enqueue(enqueuer, helpers.closureFromTearOff);
     }
     if (cls == coreClasses.stringClass || cls == helpers.jsStringClass) {
-      addInterceptors(helpers.jsStringClass, enqueuer, registry);
+      addInterceptors(helpers.jsStringClass, enqueuer);
     } else if (cls == coreClasses.listClass ||
         cls == helpers.jsArrayClass ||
         cls == helpers.jsFixedArrayClass ||
         cls == helpers.jsExtendableArrayClass ||
         cls == helpers.jsUnmodifiableArrayClass) {
-      addInterceptors(helpers.jsArrayClass, enqueuer, registry);
-      addInterceptors(helpers.jsMutableArrayClass, enqueuer, registry);
-      addInterceptors(helpers.jsFixedArrayClass, enqueuer, registry);
-      addInterceptors(helpers.jsExtendableArrayClass, enqueuer, registry);
-      addInterceptors(helpers.jsUnmodifiableArrayClass, enqueuer, registry);
-      // Literal lists can be translated into calls to these functions:
-      enqueueInResolution(helpers.jsArrayTypedConstructor, registry);
-      enqueueInResolution(helpers.setRuntimeTypeInfo, registry);
-      enqueueInResolution(helpers.getTypeArgumentByIndex, registry);
+      addInterceptors(helpers.jsArrayClass, enqueuer);
+      addInterceptors(helpers.jsMutableArrayClass, enqueuer);
+      addInterceptors(helpers.jsFixedArrayClass, enqueuer);
+      addInterceptors(helpers.jsExtendableArrayClass, enqueuer);
+      addInterceptors(helpers.jsUnmodifiableArrayClass, enqueuer);
+      if (enqueuer.isResolutionQueue) {
+        // Literal lists can be translated into calls to these functions:
+        enqueue(enqueuer, helpers.jsArrayTypedConstructor);
+        enqueue(enqueuer, helpers.setRuntimeTypeInfo);
+        enqueue(enqueuer, helpers.getTypeArgumentByIndex);
+      }
     } else if (cls == coreClasses.intClass || cls == helpers.jsIntClass) {
-      addInterceptors(helpers.jsIntClass, enqueuer, registry);
-      addInterceptors(helpers.jsPositiveIntClass, enqueuer, registry);
-      addInterceptors(helpers.jsUInt32Class, enqueuer, registry);
-      addInterceptors(helpers.jsUInt31Class, enqueuer, registry);
-      addInterceptors(helpers.jsNumberClass, enqueuer, registry);
+      addInterceptors(helpers.jsIntClass, enqueuer);
+      addInterceptors(helpers.jsPositiveIntClass, enqueuer);
+      addInterceptors(helpers.jsUInt32Class, enqueuer);
+      addInterceptors(helpers.jsUInt31Class, enqueuer);
+      addInterceptors(helpers.jsNumberClass, enqueuer);
     } else if (cls == coreClasses.doubleClass || cls == helpers.jsDoubleClass) {
-      addInterceptors(helpers.jsDoubleClass, enqueuer, registry);
-      addInterceptors(helpers.jsNumberClass, enqueuer, registry);
+      addInterceptors(helpers.jsDoubleClass, enqueuer);
+      addInterceptors(helpers.jsNumberClass, enqueuer);
     } else if (cls == coreClasses.boolClass || cls == helpers.jsBoolClass) {
-      addInterceptors(helpers.jsBoolClass, enqueuer, registry);
+      addInterceptors(helpers.jsBoolClass, enqueuer);
     } else if (cls == coreClasses.nullClass || cls == helpers.jsNullClass) {
-      addInterceptors(helpers.jsNullClass, enqueuer, registry);
+      addInterceptors(helpers.jsNullClass, enqueuer);
     } else if (cls == coreClasses.numClass || cls == helpers.jsNumberClass) {
-      addInterceptors(helpers.jsIntClass, enqueuer, registry);
-      addInterceptors(helpers.jsPositiveIntClass, enqueuer, registry);
-      addInterceptors(helpers.jsUInt32Class, enqueuer, registry);
-      addInterceptors(helpers.jsUInt31Class, enqueuer, registry);
-      addInterceptors(helpers.jsDoubleClass, enqueuer, registry);
-      addInterceptors(helpers.jsNumberClass, enqueuer, registry);
+      addInterceptors(helpers.jsIntClass, enqueuer);
+      addInterceptors(helpers.jsPositiveIntClass, enqueuer);
+      addInterceptors(helpers.jsUInt32Class, enqueuer);
+      addInterceptors(helpers.jsUInt31Class, enqueuer);
+      addInterceptors(helpers.jsDoubleClass, enqueuer);
+      addInterceptors(helpers.jsNumberClass, enqueuer);
     } else if (cls == helpers.jsJavaScriptObjectClass) {
-      addInterceptors(helpers.jsJavaScriptObjectClass, enqueuer, registry);
+      addInterceptors(helpers.jsJavaScriptObjectClass, enqueuer);
     } else if (cls == helpers.jsPlainJavaScriptObjectClass) {
-      addInterceptors(helpers.jsPlainJavaScriptObjectClass, enqueuer, registry);
+      addInterceptors(helpers.jsPlainJavaScriptObjectClass, enqueuer);
     } else if (cls == helpers.jsUnknownJavaScriptObjectClass) {
-      addInterceptors(
-          helpers.jsUnknownJavaScriptObjectClass, enqueuer, registry);
+      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, enqueuer);
     } else if (cls == helpers.jsJavaScriptFunctionClass) {
-      addInterceptors(helpers.jsJavaScriptFunctionClass, enqueuer, registry);
+      addInterceptors(helpers.jsJavaScriptFunctionClass, enqueuer);
     } else if (isNativeOrExtendsNative(cls)) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
     } else if (cls == helpers.jsIndexingBehaviorInterface) {
       // These two helpers are used by the emitter and the codegen.
       // Because we cannot enqueue elements at the time of emission,
       // we make sure they are always generated.
-      enqueue(enqueuer, helpers.isJsIndexable, registry);
+      enqueue(enqueuer, helpers.isJsIndexable);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls,
         forResolution: enqueuer.isResolutionQueue);
     if (!enqueuer.isResolutionQueue) {
       lookupMapAnalysis.registerInstantiatedClass(cls);
     }
   }
 
-  void registerInstantiatedType(
-      InterfaceType type, Enqueuer enqueuer, Registry registry,
-      {bool mirrorUsage: false}) {
+  void registerInstantiatedType(InterfaceType type) {
     lookupMapAnalysis.registerInstantiatedType(type);
-    super.registerInstantiatedType(type, enqueuer, registry,
-        mirrorUsage: mirrorUsage);
   }
 
-  void enqueueHelpers(ResolutionEnqueuer world, Registry registry) {
+  void enqueueHelpers(ResolutionEnqueuer enqueuer) {
     assert(helpers.interceptorsLibrary != null);
     // TODO(ngeoffray): Not enqueuing those two classes currently make
     // the compiler potentially crash. However, any reasonable program
     // will instantiate those two classes.
-    addInterceptors(helpers.jsBoolClass, world, registry);
-    addInterceptors(helpers.jsNullClass, world, registry);
+    addInterceptors(helpers.jsBoolClass, enqueuer);
+    addInterceptors(helpers.jsNullClass, enqueuer);
     if (compiler.options.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e = helpers.boolConversionCheck;
-      if (e != null) enqueue(world, e, registry);
+      if (e != null) enqueue(enqueuer, e);
     }
 
     if (TRACE_CALLS) {
       traceHelper = TRACE_METHOD == 'console'
           ? helpers.consoleTraceHelper
           : helpers.postTraceHelper;
       assert(traceHelper != null);
-      enqueueInResolution(traceHelper, registry);
+      enqueue(enqueuer, traceHelper);
     }
-    enqueueInResolution(helpers.assertUnreachableMethod, registry);
-    registerCheckedModeHelpers(registry);
+    enqueue(enqueuer, helpers.assertUnreachableMethod);
+    registerCheckedModeHelpers(enqueuer);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
     _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
-  void registerGetRuntimeTypeArgument(Registry registry) {
-    enqueueImpact(
-        compiler.enqueuer.resolution, impacts.getRuntimeTypeArgument, registry);
+  void registerGetRuntimeTypeArgument() {
+    enqueueImpact(compiler.enqueuer.resolution, impacts.getRuntimeTypeArgument);
   }
 
   void registerCallMethodWithFreeTypeVariables(
-      Element callMethod, Enqueuer enqueuer, Registry registry) {
+      Element callMethod, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(callMethod)) {
-      registerComputeSignature(enqueuer, registry);
+      registerComputeSignature(enqueuer);
     }
   }
 
   void registerClosureWithFreeTypeVariables(
-      Element closure, Enqueuer enqueuer, Registry registry) {
+      Element closure, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(closure)) {
-      registerComputeSignature(enqueuer, registry);
+      registerComputeSignature(enqueuer);
     }
   }
 
   void registerBoundClosure(Enqueuer enqueuer) {
     helpers.boundClosureClass.ensureResolved(resolution);
-    registerInstantiatedType(
-        helpers.boundClosureClass.rawType,
-        enqueuer,
-        // Precise dependency is not important here.
-        compiler.globalDependencies);
+    enqueuer.registerInstantiatedType(helpers.boundClosureClass.rawType);
   }
 
   void registerGetOfStaticFunction(Enqueuer enqueuer) {
     helpers.closureClass.ensureResolved(resolution);
-    registerInstantiatedType(
-        helpers.closureClass.rawType, enqueuer, compiler.globalDependencies);
+    enqueuer.registerInstantiatedType(helpers.closureClass.rawType);
   }
 
-  void registerComputeSignature(Enqueuer enqueuer, Registry registry) {
+  void registerComputeSignature(Enqueuer enqueuer) {
     // Calls to [:computeSignature:] are generated by the emitter and we
     // therefore need to enqueue the used elements in the codegen enqueuer as
     // well as in the resolution enqueuer.
-    enqueueImpact(enqueuer, impacts.computeSignature, registry);
+    enqueueImpact(enqueuer, impacts.computeSignature);
   }
 
-  void registerRuntimeType(Enqueuer enqueuer, Registry registry) {
-    registerComputeSignature(enqueuer, registry);
-    enqueueInResolution(helpers.setRuntimeTypeInfo, registry);
-    registerGetRuntimeTypeArgument(registry);
-    enqueueInResolution(helpers.getRuntimeTypeInfo, registry);
-    enqueueClass(enqueuer, coreClasses.listClass, registry);
+  void registerRuntimeType(ResolutionEnqueuer enqueuer) {
+    registerComputeSignature(enqueuer);
+    enqueue(enqueuer, helpers.setRuntimeTypeInfo);
+    registerGetRuntimeTypeArgument();
+    enqueue(enqueuer, helpers.getRuntimeTypeInfo);
+    enqueueClass(enqueuer, coreClasses.listClass);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(
       DartType typeArgument, DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
-  void registerCheckDeferredIsLoaded(Registry registry) {
-    enqueueInResolution(helpers.checkDeferredIsLoaded, registry);
+  void registerCheckDeferredIsLoaded(ResolutionEnqueuer enqueuer) {
+    enqueue(enqueuer, helpers.checkDeferredIsLoaded);
     // Also register the types of the arguments passed to this method.
-    enqueueClass(
-        compiler.enqueuer.resolution, coreClasses.stringClass, registry);
+    enqueueClass(enqueuer, coreClasses.stringClass);
   }
 
   void registerNoSuchMethod(FunctionElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
     native.NativeResolutionEnqueuer nativeEnqueuer =
@@ skipping 21 matching lines @@
         }
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   void enableNoSuchMethod(Enqueuer world) {
-    enqueue(world, helpers.createInvocationMirror, compiler.globalDependencies);
+    enqueue(world, helpers.createInvocationMirror);
     world.registerDynamicUse(new DynamicUse(Selectors.noSuchMethod_, null));
   }
 
   void enableIsolateSupport(Enqueuer enqueuer) {
     // TODO(floitsch): We should also ensure that the class IsolateMessage is
     // instantiated. Currently, just enabling isolate support works.
     if (compiler.mainFunction != null) {
       // The JavaScript backend implements [Isolate.spawn] by looking up
       // top-level functions by name. So all top-level function tear-off
       // closures have a private name field.
@@ skipping 42 matching lines @@
   }
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) ||
         compiler.enabledRuntimeType;
   }
 
   /// Enqueue [e] in [enqueuer].
   ///
   /// This method calls [registerBackendUse].
-  void enqueue(Enqueuer enqueuer, Element e, Registry registry) {
+  void enqueue(Enqueuer enqueuer, Element e) {
     if (e == null) return;
     registerBackendUse(e);
     enqueuer.addToWorkList(e);
-    registry.registerDependency(e);
-  }
-
-  /// Enqueue [e] in the resolution enqueuer.
-  ///
-  /// This method calls [registerBackendUse].
-  void enqueueInResolution(Element e, Registry registry) {
-    if (e == null) return;
-    ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
-    enqueue(enqueuer, e, registry);
+    compiler.globalDependencies.registerDependency(e);
   }
 
   /// Register instantiation of [cls] in [enqueuer].
   ///
   /// This method calls [registerBackendUse].
-  void enqueueClass(Enqueuer enqueuer, ClassElement cls, Registry registry) {
+  void enqueueClass(Enqueuer enqueuer, ClassElement cls) {
     if (cls == null) return;
     registerBackendUse(cls);
     helpersUsed.add(cls.declaration);
     if (cls.declaration != cls.implementation) {
       helpersUsed.add(cls.implementation);
     }
     cls.ensureResolved(resolution);
-    registerInstantiatedType(cls.rawType, enqueuer, registry);
+    enqueuer.registerInstantiatedType(cls.rawType);
   }
 
   /// Register instantiation of [type] in [enqueuer].
   ///
   /// This method calls [registerBackendUse].
-  void enqueueType(Enqueuer enqueuer, InterfaceType type, Registry registry) {
+  void enqueueType(Enqueuer enqueuer, InterfaceType type) {
     if (type == null) return;
     ClassElement cls = type.element;
     registerBackendUse(cls);
     helpersUsed.add(cls.declaration);
     if (cls.declaration != cls.implementation) {
       helpersUsed.add(cls.implementation);
     }
     cls.ensureResolved(resolution);
-    registerInstantiatedType(type, enqueuer, registry);
+    enqueuer.registerInstantiatedType(type);
   }
 
-  void enqueueImpact(
-      Enqueuer enqueuer, BackendImpact impact, Registry registry) {
+  void enqueueImpact(Enqueuer enqueuer, BackendImpact impact) {
     for (Element staticUse in impact.staticUses) {
-      enqueue(enqueuer, staticUse, registry);
+      enqueue(enqueuer, staticUse);
     }
     for (InterfaceType type in impact.instantiatedTypes) {
-      enqueueType(enqueuer, type, registry);
+      enqueueType(enqueuer, type);
     }
     for (ClassElement cls in impact.instantiatedClasses) {
-      enqueueClass(enqueuer, cls, registry);
+      enqueueClass(enqueuer, cls);
     }
     for (BackendImpact otherImpact in impact.otherImpacts) {
-      enqueueImpact(enqueuer, otherImpact, registry);
+      enqueueImpact(enqueuer, otherImpact);
     }
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   CodegenEnqueuer createCodegenEnqueuer(Compiler compiler) {
     return new CodegenEnqueuer(compiler, const TreeShakingEnqueuerStrategy());
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
@@ skipping 61 matching lines @@
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact =
         impactTransformer.transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
-    return new native.NativeResolutionEnqueuer(world, compiler);
+    return new native.NativeResolutionEnqueuer(compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
-    return new native.NativeCodegenEnqueuer(world, compiler, emitter);
+    return new native.NativeCodegenEnqueuer(compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     if (isJsInterop(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
     return isNative(element)
         ? helpers.jsInterceptorClass
         : coreClasses.objectClass;
@@ skipping 179 matching lines @@
             // interceptors?
             return typeCast ? 'interceptedTypeCast' : 'interceptedTypeCheck';
           } else {
             return typeCast ? 'propertyTypeCast' : 'propertyTypeCheck';
           }
         }
       }
     }
   }
 
-  void registerCheckedModeHelpers(Registry registry) {
+  void registerCheckedModeHelpers(ResolutionEnqueuer enqueuer) {
     // We register all the helpers in the resolution queue.
     // TODO(13155): Find a way to register fewer helpers.
     for (CheckedModeHelper helper in checkedModeHelpers) {
-      enqueueInResolution(helper.getStaticUse(compiler).element, registry);
+      enqueue(enqueuer, helper.getStaticUse(compiler).element);
     }
   }
 
   /**
    * Returns [:true:] if the checking of [type] is performed directly on the
    * object and not on an interceptor.
    */
   bool hasDirectCheckFor(DartType type) {
     Element element = type.element;
     return element == coreClasses.stringClass ||
@@ skipping 11 matching lines @@
   bool mayGenerateInstanceofCheck(DartType type) {
     // We can use an instanceof check for raw types that have no subclass that
     // is mixed-in or in an implements clause.
 
     if (!type.isRaw) return false;
     ClassElement classElement = type.element;
     if (isInterceptorClass(classElement)) return false;
     return compiler.closedWorld.hasOnlySubclasses(classElement);
   }
 
-  void registerStaticUse(Element element, {bool forResolution}) {
+  void registerStaticUse(Enqueuer enqueuer, Element element) {
     if (element == helpers.disableTreeShakingMarker) {
       isTreeShakingDisabled = true;
     } else if (element == helpers.preserveNamesMarker) {
       mustPreserveNames = true;
     } else if (element == helpers.preserveMetadataMarker) {
       mustRetainMetadata = true;
     } else if (element == helpers.preserveUrisMarker) {
       if (compiler.options.preserveUris) mustPreserveUris = true;
     } else if (element == helpers.preserveLibraryNamesMarker) {
       mustRetainLibraryNames = true;
     } else if (element == helpers.getIsolateAffinityTagMarker) {
       needToInitializeIsolateAffinityTag = true;
     } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (!isLoadLibraryFunctionResolved) {
         isLoadLibraryFunctionResolved = true;
-        enqueueInResolution(
-            helpers.loadLibraryWrapper, compiler.globalDependencies);
+        if (enqueuer.isResolutionQueue) {
+          enqueue(enqueuer, helpers.loadLibraryWrapper);
+        }
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     }
     customElementsAnalysis.registerStaticUse(element,
-        forResolution: forResolution);
+        forResolution: enqueuer.isResolutionQueue);
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 
@@ skipping 444 matching lines @@
         registerBackendUse(e);
         enqueuer.addToWorkList(e);
       }
     }
 
     if (!enqueuer.isResolutionQueue && preMirrorsMethodCount == 0) {
       preMirrorsMethodCount = generatedCode.length;
     }
 
     if (isTreeShakingDisabled) {
-      enqueuer.enqueueReflectiveElements(recentClasses);
+      mirrorsAnalysis.enqueueReflectiveElements(
+          enqueuer, recentClasses, compiler.libraryLoader.libraries);
     } else if (!targetsUsed.isEmpty && enqueuer.isResolutionQueue) {
       // Add all static elements (not classes) that have been requested for
       // reflection. If there is no mirror-usage these are probably not
       // necessary, but the backend relies on them being resolved.
-      enqueuer.enqueueReflectiveStaticFields(_findStaticFieldTargets());
+      mirrorsAnalysis.enqueueReflectiveStaticFields(
+          enqueuer, _findStaticFieldTargets());
     }
 
     if (mustPreserveNames) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
       reporter.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
 
       StagedWorldImpactBuilder impactBuilder = enqueuer.isResolutionQueue
@@ skipping 186 matching lines @@
     assert(name != "");
     String outPath = compiler.options.outputUri != null
         ? compiler.options.outputUri.path
         : "out";
     String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
     String extension = addExtension ? ".part.js" : "";
     return "${outName}_$name$extension";
   }
 
   @override
-  bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
-    registerCheckDeferredIsLoaded(registry);
+  bool enableDeferredLoadingIfSupported(
+      ResolutionEnqueuer enqueuer, Spannable node) {
+    registerCheckDeferredIsLoaded(enqueuer);
     return true;
   }
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) => true;
 
   jsAst.Expression rewriteAsync(
       FunctionElement element, jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
@@ skipping 163 matching lines @@
   }
 }
 
 class JavaScriptImpactTransformer extends ImpactTransformer {
   final JavaScriptBackend backend;
 
   JavaScriptImpactTransformer(this.backend);
 
   BackendImpacts get impacts => backend.impacts;
 
-  // TODO(johnniwinther): Avoid this dependency.
-  ResolutionEnqueuer get resolutionEnqueuer {
-    return backend.compiler.enqueuer.resolution;
-  }
-
   @override
-  WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) {
+  WorldImpact transformResolutionImpact(
+      ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
     for (Feature feature in worldImpact.features) {
       switch (feature) {
         case Feature.ABSTRACT_CLASS_INSTANTIATION:
           registerBackendImpact(
               transformed, impacts.abstractClassInstantiation);
           break;
         case Feature.ASSERT:
           registerBackendImpact(transformed, impacts.assertWithoutMessage);
@@ skipping 66 matching lines @@
           break;
       }
     }
 
     bool hasAsCast = false;
     bool hasTypeLiteral = false;
     for (TypeUse typeUse in worldImpact.typeUses) {
       DartType type = typeUse.type;
       switch (typeUse.kind) {
         case TypeUseKind.INSTANTIATION:
+        case TypeUseKind.MIRROR_INSTANTIATION:
+        case TypeUseKind.NATIVE_INSTANTIATION:
           registerRequiredType(type);
           break;
         case TypeUseKind.IS_CHECK:
           onIsCheck(type, transformed);
           break;
         case TypeUseKind.AS_CAST:
           onIsCheck(type, transformed);
           hasAsCast = true;
           break;
         case TypeUseKind.CHECKED_MODE_CHECK:
@@ skipping 60 matching lines @@
         backend.registerConstSymbol(constSymbolName);
       }
     }
 
     for (StaticUse staticUse in worldImpact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
           registerBackendImpact(transformed, impacts.closure);
           LocalFunctionElement closure = staticUse.element;
           if (closure.type.containsTypeVariables) {
-            resolutionEnqueuer.universe.closuresWithFreeTypeVariables
-                .add(closure);
             registerBackendImpact(transformed, impacts.computeSignature);
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
           registerRequiredType(staticUse.type);
           break;
         default:
       }
     }
@@ skipping 15 matching lines @@
         case ConstantExpressionKind.STRING:
           registerBackendImpact(transformed, impacts.stringLiteral);
           break;
         default:
           assert(invariant(NO_LOCATION_SPANNABLE, false,
               message: "Unexpected constant literal: ${constant.kind}."));
       }
     }
 
     for (native.NativeBehavior behavior in worldImpact.nativeData) {
-      resolutionEnqueuer.nativeEnqueuer
-          .registerNativeBehavior(behavior, worldImpact);
+      enqueuer.nativeEnqueuer
+          .registerNativeBehavior(transformed, behavior, worldImpact);
     }
 
     return transformed;
   }
 
   void registerBackendImpact(
       TransformedWorldImpact worldImpact, BackendImpact backendImpact) {
     for (Element staticUse in backendImpact.staticUses) {
       assert(staticUse != null);
       backend.registerBackendUse(staticUse);
@@ skipping 79 matching lines @@
 
   void onIsCheckForCodegen(DartType type, TransformedWorldImpact transformed) {
     type = type.unaliased;
     registerBackendImpact(transformed, impacts.typeCheck);
 
     bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       // All helpers are added to resolution queue in enqueueHelpers. These
-      // calls to enqueueInResolution serve as assertions that the helper was
-      // in fact added.
+      // calls to [enqueue] with the resolution enqueuer serve as assertions
+      // that the helper was in fact added.
       // TODO(13155): Find a way to enqueue helpers lazily.
       CheckedModeHelper helper =
           backend.getCheckedModeHelper(type, typeCast: false);
       if (helper != null) {
         StaticUse staticUse = helper.getStaticUse(backend.compiler);
         transformed.registerStaticUse(staticUse);
         backend.registerBackendUse(staticUse.element);
       }
       // We also need the native variant of the check (for DOM types).
       helper = backend.getNativeCheckedModeHelper(type, typeCast: false);
@@ skipping 170 matching lines @@
   ClassElement get mapImplementation => helpers.mapLiteralClass;
   ClassElement get constMapImplementation => helpers.constMapLiteralClass;
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
   ClassElement get functionImplementation => helpers.coreClasses.functionClass;
 }