Decouple WorkItem from Compiler

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 317 matching lines @@
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   /// If [true], the compiler will emit code that logs whenever a method is
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
       TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
-  MethodElement traceHelper;
 
   TypeMask get stringType => compiler.closedWorld.commonMasks.stringType;
   TypeMask get doubleType => compiler.closedWorld.commonMasks.doubleType;
   TypeMask get intType => compiler.closedWorld.commonMasks.intType;
   TypeMask get uint32Type => compiler.closedWorld.commonMasks.uint32Type;
   TypeMask get uint31Type => compiler.closedWorld.commonMasks.uint31Type;
   TypeMask get positiveIntType =>
       compiler.closedWorld.commonMasks.positiveIntType;
   TypeMask get numType => compiler.closedWorld.commonMasks.numType;
   TypeMask get boolType => compiler.closedWorld.commonMasks.boolType;
@@ skipping 680 matching lines @@
       // differences.
       assert(invariant(interceptorMember,
           interceptorMember.enclosingClass == interceptorClass,
           message:
               "Member ${member.name} not overridden in ${interceptorClass}. "
               "Found $interceptorMember from "
               "${interceptorMember.enclosingClass}."));
     });
   }
 
-  void addInterceptorsForNativeClassMembers(
-      ClassElement cls, Enqueuer enqueuer) {
-    if (enqueuer.isResolutionQueue) {
+  void addInterceptorsForNativeClassMembers(ClassElement cls,
+      {bool forResolution}) {
+    if (forResolution) {
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
           return;
         }
         if (member.isSynthesized) return;
         // 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);
 
       // 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) {
-    if (enqueuer.isResolutionQueue) {
+  void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
+      {bool forResolution}) {
+    if (forResolution) {
+      if (_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);
+      }
       _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);
+    impactTransformer.registerBackendInstantiation(impactBuilder, 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) {
-    _processClass(cls, enqueuer);
+  WorldImpact registerInstantiatedClass(ClassElement cls,
+      {bool forResolution}) {
+    return _processClass(cls, forResolution: forResolution);
   }
 
-  void registerImplementedClass(ClassElement cls, Enqueuer enqueuer) {
-    _processClass(cls, enqueuer);
+  WorldImpact registerImplementedClass(ClassElement cls, {bool forResolution}) {
+    return _processClass(cls, forResolution: forResolution);
   }
 
-  void _processClass(ClassElement cls, Enqueuer enqueuer) {
+  WorldImpact _processClass(ClassElement cls, {bool forResolution}) {
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     if (!cls.typeVariables.isEmpty) {
-      typeVariableHandler.registerClassWithTypeVariables(cls, enqueuer);
+      typeVariableHandler.registerClassWithTypeVariables(cls,
+          forResolution: forResolution);
     }
 
     // Register any helper that will be needed by the backend.
-    if (enqueuer.isResolutionQueue) {
+    if (forResolution) {
       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);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.numClasses);
       } 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);
-        enqueue(enqueuer, helpers.throwIllegalArgumentException);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.listOrStringClasses);
       } else if (cls == coreClasses.functionClass) {
-        enqueueClass(enqueuer, helpers.closureClass);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.functionClass);
       } else if (cls == coreClasses.mapClass) {
-        // The backend will use a literal list to initialize the entries
-        // of the map.
-        enqueueClass(enqueuer, coreClasses.listClass);
-        enqueueClass(enqueuer, helpers.mapLiteralClass);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.mapClass);
         // 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);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.boundClosureClass);
       } else if (isNativeOrExtendsNative(cls)) {
-        enqueue(enqueuer, helpers.getNativeInterceptorMethod);
-        enqueueClass(enqueuer, helpers.jsInterceptorClass);
-        enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass);
-        enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass);
-        enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.nativeOrExtendsClass);
       } 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) &&
-                  ctor.library != helpers.mapLiteralClass.library)) {
-            reporter.internalError(
-                helpers.mapLiteralClass,
-                "Map literal class ${helpers.mapLiteralClass} missing "
-                "'$name' constructor"
-                "  ${helpers.mapLiteralClass.constructors}");
-          }
-          return ctor;
-        }
-
-        Element getMember(String name) {
-          // The constructor is on the patch class, but dart2js unit tests don't
-          // have a patch class.
-          ClassElement implementation = cls.implementation;
-          Element element = implementation.lookupLocalMember(name);
-          if (element == null || !element.isFunction || !element.isStatic) {
-            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);
-        enqueue(enqueuer, helpers.mapLiteralConstructor);
-        enqueue(enqueuer, helpers.mapLiteralConstructorEmpty);
-
-        helpers.mapLiteralUntypedMaker = getMember('_makeLiteral');
-        helpers.mapLiteralUntypedEmptyMaker = getMember('_makeEmpty');
-        enqueue(enqueuer, helpers.mapLiteralUntypedMaker);
-        enqueue(enqueuer, helpers.mapLiteralUntypedEmptyMaker);
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.mapLiteralClass);
       }
     }
     if (cls == helpers.closureClass) {
-      enqueue(enqueuer, helpers.closureFromTearOff);
+      impactTransformer.registerBackendImpact(
+          impactBuilder, impacts.closureClass);
     }
     if (cls == coreClasses.stringClass || cls == helpers.jsStringClass) {
-      addInterceptors(helpers.jsStringClass, enqueuer);
+      addInterceptors(helpers.jsStringClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == coreClasses.listClass ||
         cls == helpers.jsArrayClass ||
         cls == helpers.jsFixedArrayClass ||
         cls == helpers.jsExtendableArrayClass ||
         cls == helpers.jsUnmodifiableArrayClass) {
-      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);
+      addInterceptors(helpers.jsArrayClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsMutableArrayClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsFixedArrayClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsExtendableArrayClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsUnmodifiableArrayClass, impactBuilder,
+          forResolution: forResolution);
+      if (forResolution) {
+        impactTransformer.registerBackendImpact(
+            impactBuilder, impacts.listClasses);
       }
     } else if (cls == coreClasses.intClass || cls == helpers.jsIntClass) {
-      addInterceptors(helpers.jsIntClass, enqueuer);
-      addInterceptors(helpers.jsPositiveIntClass, enqueuer);
-      addInterceptors(helpers.jsUInt32Class, enqueuer);
-      addInterceptors(helpers.jsUInt31Class, enqueuer);
-      addInterceptors(helpers.jsNumberClass, enqueuer);
+      addInterceptors(helpers.jsIntClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsPositiveIntClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsUInt32Class, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsUInt31Class, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsNumberClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == coreClasses.doubleClass || cls == helpers.jsDoubleClass) {
-      addInterceptors(helpers.jsDoubleClass, enqueuer);
-      addInterceptors(helpers.jsNumberClass, enqueuer);
+      addInterceptors(helpers.jsDoubleClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsNumberClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == coreClasses.boolClass || cls == helpers.jsBoolClass) {
-      addInterceptors(helpers.jsBoolClass, enqueuer);
+      addInterceptors(helpers.jsBoolClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == coreClasses.nullClass || cls == helpers.jsNullClass) {
-      addInterceptors(helpers.jsNullClass, enqueuer);
+      addInterceptors(helpers.jsNullClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == coreClasses.numClass || cls == helpers.jsNumberClass) {
-      addInterceptors(helpers.jsIntClass, enqueuer);
-      addInterceptors(helpers.jsPositiveIntClass, enqueuer);
-      addInterceptors(helpers.jsUInt32Class, enqueuer);
-      addInterceptors(helpers.jsUInt31Class, enqueuer);
-      addInterceptors(helpers.jsDoubleClass, enqueuer);
-      addInterceptors(helpers.jsNumberClass, enqueuer);
+      addInterceptors(helpers.jsIntClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsPositiveIntClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsUInt32Class, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsUInt31Class, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsDoubleClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsNumberClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == helpers.jsJavaScriptObjectClass) {
-      addInterceptors(helpers.jsJavaScriptObjectClass, enqueuer);
+      addInterceptors(helpers.jsJavaScriptObjectClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == helpers.jsPlainJavaScriptObjectClass) {
-      addInterceptors(helpers.jsPlainJavaScriptObjectClass, enqueuer);
+      addInterceptors(helpers.jsPlainJavaScriptObjectClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == helpers.jsUnknownJavaScriptObjectClass) {
-      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, enqueuer);
+      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, impactBuilder,
+          forResolution: forResolution);
     } else if (cls == helpers.jsJavaScriptFunctionClass) {
-      addInterceptors(helpers.jsJavaScriptFunctionClass, enqueuer);
+      addInterceptors(helpers.jsJavaScriptFunctionClass, impactBuilder,
+          forResolution: forResolution);
     } else if (isNativeOrExtendsNative(cls)) {
-      addInterceptorsForNativeClassMembers(cls, enqueuer);
+      addInterceptorsForNativeClassMembers(cls, forResolution: forResolution);
     } 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);
+      impactTransformer.registerBackendImpact(
+          impactBuilder, impacts.jsIndexingBehavior);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls,
-        forResolution: enqueuer.isResolutionQueue);
-    if (!enqueuer.isResolutionQueue) {
+        forResolution: forResolution);
+    if (!forResolution) {
       lookupMapAnalysis.registerInstantiatedClass(cls);
     }
+
+    return impactBuilder;
   }
 
   void registerInstantiatedType(InterfaceType type) {
     lookupMapAnalysis.registerInstantiatedType(type);
   }
 
-  void enqueueHelpers(ResolutionEnqueuer enqueuer) {
+  @override
+  WorldImpact computeHelpersImpact() {
     assert(helpers.interceptorsLibrary != null);
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     // 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, enqueuer);
-    addInterceptors(helpers.jsNullClass, enqueuer);
+    addInterceptors(helpers.jsBoolClass, impactBuilder, forResolution: true);
+    addInterceptors(helpers.jsNullClass, impactBuilder, forResolution: true);
     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(enqueuer, e);
+      impactTransformer.registerBackendImpact(
+          impactBuilder, impacts.enableTypeAssertions);
     }
 
     if (TRACE_CALLS) {
-      traceHelper = TRACE_METHOD == 'console'
-          ? helpers.consoleTraceHelper
-          : helpers.postTraceHelper;
-      assert(traceHelper != null);
-      enqueue(enqueuer, traceHelper);
+      impactTransformer.registerBackendImpact(
+          impactBuilder, impacts.traceHelper);
     }
-    enqueue(enqueuer, helpers.assertUnreachableMethod);
-    registerCheckedModeHelpers(enqueuer);
+    impactTransformer.registerBackendImpact(
+        impactBuilder, impacts.assertUnreachable);
+    _registerCheckedModeHelpers(impactBuilder);
+    return impactBuilder;
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
     _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
-  void registerGetRuntimeTypeArgument() {
-    enqueueImpact(compiler.enqueuer.resolution, impacts.getRuntimeTypeArgument);
+  WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod,
+      {bool forResolution}) {
+    if (forResolution || methodNeedsRti(callMethod)) {
+      return _registerComputeSignature();
+    }
+    return const WorldImpact();
   }
 
-  void registerCallMethodWithFreeTypeVariables(
-      Element callMethod, Enqueuer enqueuer) {
-    if (enqueuer.isResolutionQueue || methodNeedsRti(callMethod)) {
-      registerComputeSignature(enqueuer);
+  WorldImpact registerClosureWithFreeTypeVariables(Element closure,
+      {bool forResolution}) {
+    if (forResolution || methodNeedsRti(closure)) {
+      return _registerComputeSignature();
     }
+    return const WorldImpact();
   }
 
-  void registerClosureWithFreeTypeVariables(
-      Element closure, Enqueuer enqueuer) {
-    if (enqueuer.isResolutionQueue || methodNeedsRti(closure)) {
-      registerComputeSignature(enqueuer);
-    }
+  WorldImpact registerBoundClosure() {
+    return impactTransformer.createImpactFor(impacts.memberClosure);
   }
 
-  void registerBoundClosure(Enqueuer enqueuer) {
-    helpers.boundClosureClass.ensureResolved(resolution);
-    enqueuer.registerInstantiatedType(helpers.boundClosureClass.rawType);
+  WorldImpact registerGetOfStaticFunction() {
+    return impactTransformer.createImpactFor(impacts.staticClosure);
   }
 
-  void registerGetOfStaticFunction(Enqueuer enqueuer) {
-    helpers.closureClass.ensureResolved(resolution);
-    enqueuer.registerInstantiatedType(helpers.closureClass.rawType);
-  }
-
-  void registerComputeSignature(Enqueuer enqueuer) {
+  WorldImpact _registerComputeSignature() {
     // 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);
+    return impactTransformer.createImpactFor(impacts.computeSignature);
   }
 
-  void registerRuntimeType(ResolutionEnqueuer enqueuer) {
-    registerComputeSignature(enqueuer);
-    enqueue(enqueuer, helpers.setRuntimeTypeInfo);
-    registerGetRuntimeTypeArgument();
-    enqueue(enqueuer, helpers.getRuntimeTypeInfo);
-    enqueueClass(enqueuer, coreClasses.listClass);
+  WorldImpact registerRuntimeType() {
+    return impactTransformer.createImpactFor(impacts.runtimeTypeSupport);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(
       DartType typeArgument, DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
-  void registerCheckDeferredIsLoaded(ResolutionEnqueuer enqueuer) {
-    enqueue(enqueuer, helpers.checkDeferredIsLoaded);
-    // Also register the types of the arguments passed to this method.
-    enqueueClass(enqueuer, coreClasses.stringClass);
+  WorldImpact computeDeferredLoadingImpact() {
+    return impactTransformer.createImpactFor(impacts.deferredLoading);
   }
 
   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 20 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);
-    world.registerDynamicUse(new DynamicUse(Selectors.noSuchMethod_, null));
+  WorldImpact enableNoSuchMethod() {
+    return impactTransformer.createImpactFor(impacts.noSuchMethodSupport);
   }
 
-  void enableIsolateSupport(Enqueuer enqueuer) {
+  WorldImpact enableIsolateSupport({bool forResolution}) {
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     // 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.
       //
       // The JavaScript backend of [Isolate.spawnUri] uses the same internal
       // implementation as [Isolate.spawn], and fails if it cannot look main up
       // by name.
-      enqueuer.registerStaticUse(
+      impactBuilder.registerStaticUse(
           new StaticUse.staticTearOff(compiler.mainFunction));
     }
-    if (enqueuer.isResolutionQueue) {
-      void enqueue(Element element) {
-        enqueuer.addToWorkList(element);
-        compiler.globalDependencies.registerDependency(element);
-        helpersUsed.add(element.declaration);
-      }
-
-      enqueue(helpers.startRootIsolate);
-      enqueue(helpers.currentIsolate);
-      enqueue(helpers.callInIsolate);
-    } else {
-      enqueuer.addToWorkList(helpers.startRootIsolate);
+    impactTransformer.registerBackendImpact(
+        impactBuilder, impacts.isolateSupport);
+    if (forResolution) {
+      impactTransformer.registerBackendImpact(
+          impactBuilder, impacts.isolateSupportForResolution);
     }
+    return impactBuilder;
   }
 
   bool classNeedsRti(ClassElement cls) {
     if (compiler.resolverWorld.hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool classNeedsRtiField(ClassElement cls) {
     if (cls.rawType.typeArguments.isEmpty) return false;
     if (compiler.resolverWorld.hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == coreClasses.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) ||
         compiler.resolverWorld.hasRuntimeTypeSupport;
   }
 
-  /// Enqueue [e] in [enqueuer].
-  ///
-  /// This method calls [registerBackendUse].
-  void enqueue(Enqueuer enqueuer, Element e) {
-    if (e == null) return;
-    registerBackendUse(e);
-    enqueuer.addToWorkList(e);
-    compiler.globalDependencies.registerDependency(e);
-  }
-
-  /// Register instantiation of [cls] in [enqueuer].
-  ///
-  /// This method calls [registerBackendUse].
-  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);
-    enqueuer.registerInstantiatedType(cls.rawType);
-  }
-
-  /// Register instantiation of [type] in [enqueuer].
-  ///
-  /// This method calls [registerBackendUse].
-  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);
-    enqueuer.registerInstantiatedType(type);
-  }
-
-  void enqueueImpact(Enqueuer enqueuer, BackendImpact impact) {
-    for (Element staticUse in impact.staticUses) {
-      enqueue(enqueuer, staticUse);
-    }
-    for (InterfaceType type in impact.instantiatedTypes) {
-      enqueueType(enqueuer, type);
-    }
-    for (ClassElement cls in impact.instantiatedClasses) {
-      enqueueClass(enqueuer, cls);
-    }
-    for (BackendImpact otherImpact in impact.otherImpacts) {
-      enqueueImpact(enqueuer, otherImpact);
-    }
-  }
-
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   CodegenEnqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler) {
     return new CodegenEnqueuer(
         task, compiler, const TreeShakingEnqueuerStrategy());
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
@@ skipping 41 matching lines @@
                   constant.isImplicit ||
                   constant.isPotential,
               message: "Constant expression without value: "
                   "${constant.toStructuredText()}."));
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
-        compiler.enqueuer.codegen.registerStaticUse(new StaticUse.staticInvoke(
+        work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
             helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
     jsAst.Fun function = functionCompiler.compile(work);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
@@ skipping 201 matching lines @@
             // interceptors?
             return typeCast ? 'interceptedTypeCast' : 'interceptedTypeCheck';
           } else {
             return typeCast ? 'propertyTypeCast' : 'propertyTypeCheck';
           }
         }
       }
     }
   }
 
-  void registerCheckedModeHelpers(ResolutionEnqueuer enqueuer) {
+  void _registerCheckedModeHelpers(WorldImpactBuilder impactBuilder) {
     // We register all the helpers in the resolution queue.
     // TODO(13155): Find a way to register fewer helpers.
+    List<Element> staticUses = <Element>[];
     for (CheckedModeHelper helper in checkedModeHelpers) {
-      enqueue(enqueuer, helper.getStaticUse(compiler).element);
+      staticUses.add(helper.getStaticUse(compiler).element);
     }
+    impactTransformer.registerBackendImpact(
+        impactBuilder, new BackendImpact(globalUses: staticUses));
   }
 
   /**
    * 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 ||
         element == coreClasses.boolClass ||
@@ skipping 10 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(Enqueuer enqueuer, Element element) {
+  WorldImpact registerStaticUse(Element element, {bool forResolution}) {
+    WorldImpactBuilderImpl worldImpact = new WorldImpactBuilderImpl();
     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;
-        if (enqueuer.isResolutionQueue) {
-          enqueue(enqueuer, helpers.loadLibraryWrapper);
+        if (forResolution) {
+          impactTransformer.registerBackendImpact(
+              worldImpact, impacts.loadLibrary);
         }
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     }
     customElementsAnalysis.registerStaticUse(element,
-        forResolution: enqueuer.isResolutionQueue);
+        forResolution: forResolution);
+    return worldImpact;
   }
 
   /// 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 406 matching lines @@
     return staticFields;
   }
 
   /// Called when [enqueuer] is empty, but before it is closed.
   bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassElement> recentClasses) {
     // Add elements used synthetically, that is, through features rather than
     // syntax, for instance custom elements.
     //
     // Return early if any elements are added to avoid counting the elements as
     // due to mirrors.
+    enqueuer.applyImpact(customElementsAnalysis.flush(
+        forResolution: enqueuer.isResolutionQueue));
     enqueuer.applyImpact(
-        compiler.impactStrategy,
-        customElementsAnalysis.flush(
-            forResolution: enqueuer.isResolutionQueue));
-    enqueuer.applyImpact(compiler.impactStrategy,
         lookupMapAnalysis.flush(forResolution: enqueuer.isResolutionQueue));
-    enqueuer.applyImpact(compiler.impactStrategy,
+    enqueuer.applyImpact(
         typeVariableHandler.flush(forResolution: enqueuer.isResolutionQueue));
 
     if (!enqueuer.queueIsEmpty) return false;
 
     noSuchMethodRegistry.onQueueEmpty();
     if (!enabledNoSuchMethod &&
         (noSuchMethodRegistry.hasThrowingNoSuchMethod ||
             noSuchMethodRegistry.hasComplexNoSuchMethod)) {
-      enableNoSuchMethod(enqueuer);
+      enqueuer.applyImpact(enableNoSuchMethod());
       enabledNoSuchMethod = true;
     }
 
     if (compiler.options.useKernel && compiler.mainApp != null) {
       kernelTask.buildKernelIr();
     }
 
     if (compiler.options.hasIncrementalSupport) {
       // Always enable tear-off closures during incremental compilation.
-      Element e = helpers.closureFromTearOff;
-      if (e != null && !enqueuer.isProcessed(e)) {
-        registerBackendUse(e);
-        enqueuer.addToWorkList(e);
+      Element element = helpers.closureFromTearOff;
+      if (element != null && !enqueuer.isProcessed(element)) {
+        enqueuer.applyImpact(
+            impactTransformer.createImpactFor(impacts.closureClass));
       }
     }
 
     if (!enqueuer.isResolutionQueue && preMirrorsMethodCount == 0) {
       preMirrorsMethodCount = generatedCode.length;
     }
 
     if (isTreeShakingDisabled) {
-      enqueuer.applyImpact(
-          compiler.impactStrategy,
-          mirrorsAnalysis.computeImpactForReflectiveElements(recentClasses,
-              enqueuer.processedClasses, compiler.libraryLoader.libraries,
-              forResolution: enqueuer.isResolutionQueue));
+      enqueuer.applyImpact(mirrorsAnalysis.computeImpactForReflectiveElements(
+          recentClasses,
+          enqueuer.processedClasses,
+          compiler.libraryLoader.libraries,
+          forResolution: enqueuer.isResolutionQueue));
     } 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.applyImpact(
-          compiler.impactStrategy,
-          mirrorsAnalysis.computeImpactForReflectiveStaticFields(
-              _findStaticFieldTargets(),
+      enqueuer.applyImpact(mirrorsAnalysis
+          .computeImpactForReflectiveStaticFields(_findStaticFieldTargets(),
               forResolution: enqueuer.isResolutionQueue));
     }
 
     if (mustPreserveNames) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
       reporter.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
 
@@ skipping 16 matching lines @@
         // elements and process these instead.
         processMetadata(compiler.enqueuer.resolution.processedElements,
             registerMetadataConstant);
       } else {
         for (Dependency dependency in metadataConstants) {
           computeImpactForCompileTimeConstant(
               dependency.constant, impactBuilder, enqueuer.isResolutionQueue);
         }
         metadataConstants.clear();
       }
-      enqueuer.applyImpact(compiler.impactStrategy, impactBuilder.flush());
+      enqueuer.applyImpact(impactBuilder.flush());
     }
     return true;
   }
 
   /// Call [registerMetadataConstant] on all metadata from [elements].
   void processMetadata(Iterable<Element> elements,
       void onMetadata(MetadataAnnotation metadata)) {
     void processLibraryMetadata(LibraryElement library) {
       if (_registeredMetadata.add(library)) {
         library.metadata.forEach(onMetadata);
@@ skipping 128 matching lines @@
 
   FunctionElement helperForMainArity() => helpers.mainHasTooManyParameters;
 
   void forgetElement(Element element) {
     constants.forgetElement(element);
     constantCompilerTask.dartConstantCompiler.forgetElement(element);
     aliasedSuperMembers.remove(element);
   }
 
   @override
-  WorldImpact computeMainImpact(Enqueuer enqueuer, MethodElement mainMethod) {
+  WorldImpact computeMainImpact(MethodElement mainMethod,
+      {bool forResolution}) {
     WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
     if (mainMethod.parameters.isNotEmpty) {
       impactTransformer.registerBackendImpact(
           mainImpact, impacts.mainWithArguments);
       mainImpact.registerStaticUse(
           new StaticUse.staticInvoke(mainMethod, CallStructure.TWO_ARGS));
       // If the main method takes arguments, this compilation could be the
       // target of Isolate.spawnUri. Strictly speaking, that can happen also if
       // main takes no arguments, but in this case the spawned isolate can't
       // communicate with the spawning isolate.
-      enqueuer.enableIsolateSupport();
+      mainImpact.addImpact(enableIsolateSupport(forResolution: forResolution));
     }
     mainImpact.registerStaticUse(
         new StaticUse.staticInvoke(mainMethod, CallStructure.NO_ARGS));
     return mainImpact;
   }
 
   /// Returns the filename for the output-unit named [name].
   ///
   /// The filename is of the form "<main output file>_<name>.part.js".
   /// If [addExtension] is false, the ".part.js" suffix is left out.
   String deferredPartFileName(String name, {bool addExtension: true}) {
     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(
-      ResolutionEnqueuer enqueuer, Spannable node) {
-    registerCheckDeferredIsLoaded(enqueuer);
-    return true;
-  }
+  bool enableDeferredLoadingIfSupported(Spannable node) => true;
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) => true;
 
   jsAst.Expression rewriteAsync(
       FunctionElement element, jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
     switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
@@ skipping 374 matching lines @@
     }
 
     for (native.NativeBehavior behavior in worldImpact.nativeData) {
       enqueuer.nativeEnqueuer
           .registerNativeBehavior(transformed, behavior, worldImpact);
     }
 
     return transformed;
   }
 
+  WorldImpact createImpactFor(BackendImpact impact) {
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
+    registerBackendImpact(impactBuilder, impact);
+    return impactBuilder;
+  }
+
+  void registerBackendStaticUse(
+      WorldImpactBuilder worldImpact, MethodElement element,
+      {bool isGlobal: false}) {
+    backend.registerBackendUse(element);
+    worldImpact.registerStaticUse(
+        // TODO(johnniwinther): Store the correct use in impacts.
+        new StaticUse.foreignUse(element));
+    if (isGlobal) {
+      backend.compiler.globalDependencies.registerDependency(element);
+    }
+  }
+
+  void registerBackendInstantiation(
+      WorldImpactBuilder worldImpact, ClassElement cls,
+      {bool isGlobal: false}) {
+    cls.ensureResolved(backend.resolution);
+    backend.registerBackendUse(cls);
+    worldImpact.registerTypeUse(new TypeUse.instantiation(cls.rawType));
+    if (isGlobal) {
+      backend.compiler.globalDependencies.registerDependency(cls);
+    }
+  }
+
   void registerBackendImpact(
       WorldImpactBuilder worldImpact, BackendImpact backendImpact) {
     for (Element staticUse in backendImpact.staticUses) {
       assert(staticUse != null);
-      backend.registerBackendUse(staticUse);
-      worldImpact.registerStaticUse(
-          // TODO(johnniwinther): Store the correct use in impacts.
-          new StaticUse.foreignUse(staticUse));
+      registerBackendStaticUse(worldImpact, staticUse);
+    }
+    for (Element staticUse in backendImpact.globalUses) {
+      assert(staticUse != null);
+      registerBackendStaticUse(worldImpact, staticUse, isGlobal: true);
     }
     for (Selector selector in backendImpact.dynamicUses) {
       assert(selector != null);
       worldImpact.registerDynamicUse(new DynamicUse(selector, null));
     }
     for (InterfaceType instantiatedType in backendImpact.instantiatedTypes) {
       backend.registerBackendUse(instantiatedType.element);
       worldImpact.registerTypeUse(new TypeUse.instantiation(instantiatedType));
     }
     for (ClassElement cls in backendImpact.instantiatedClasses) {
-      cls.ensureResolved(backend.resolution);
-      backend.registerBackendUse(cls);
-      worldImpact.registerTypeUse(new TypeUse.instantiation(cls.rawType));
+      registerBackendInstantiation(worldImpact, cls);
+    }
+    for (ClassElement cls in backendImpact.globalClasses) {
+      registerBackendInstantiation(worldImpact, cls, isGlobal: true);
     }
     for (BackendImpact otherImpact in backendImpact.otherImpacts) {
       registerBackendImpact(worldImpact, otherImpact);
     }
     for (BackendFeature feature in backendImpact.features) {
       switch (feature) {
         case BackendFeature.needToInitializeDispatchProperty:
           backend.needToInitializeDispatchProperty = true;
           break;
         case BackendFeature.needToInitializeIsolateAffinityTag:
@@ skipping 245 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;
 }