Split backend implementation of EnqueuerListener

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 29 matching lines @@
 import '../io/start_end_information.dart'
     show StartEndSourceInformationStrategy;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js/js_source_mapping.dart' show JavaScriptSourceInformationStrategy;
 import '../js/rewrite_async.dart';
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask;
 import '../kernel/task.dart';
 import '../library_loader.dart' show LibraryLoader, LoadedLibraries;
 import '../native/native.dart' as native;
+import '../options.dart' show CompilerOptions;
 import '../patch_parser.dart'
     show checkNativeAnnotation, checkJsInteropAnnotation;
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
 import '../tracer.dart';
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/feature.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart'
@@ skipping 242 matching lines @@
   }
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
   TYPEVARIABLE_REFERENCE, // Reference to a type in reflection data.
   NAME
 }
 
-class JavaScriptBackend extends Target implements EnqueuerListener {
+class JavaScriptBackend extends Target {
   final Compiler compiler;
 
   String get patchVersion => emitter.patchVersion;
 
   /// Returns true if the backend supports reflection.
   bool get supportsReflection => emitter.supportsReflection;
 
   final Annotations annotations;
 
   /// Set of classes that need to be considered for reflection although not
@@ skipping 48 matching lines @@
     List<CompilerTask> result = functionCompiler.tasks;
     result.add(emitter);
     result.add(patchResolverTask);
     result.add(kernelTask);
     return result;
   }
 
   final RuntimeTypes rti;
   final RuntimeTypesEncoder rtiEncoder;
 
-  /// True if a call to preserveUris has been seen and the preserve-uris flag
-  /// is set.
-  bool mustPreserveUris = false;
-
-  /// True if a core-library function requires the preamble file to function.
-  bool requiresPreamble = false;
-
   /// True if the html library has been loaded.
   bool htmlLibraryIsLoaded = false;
 
-  /// True when we enqueue the loadLibrary code.
-  bool isLoadLibraryFunctionResolved = false;
-
-  /// `true` if access to [BackendHelpers.invokeOnMethod] is supported.
-  bool hasInvokeOnSupport = false;
-
-  /// `true` of `Object.runtimeType` is supported.
-  bool hasRuntimeTypeSupport = false;
-
-  /// `true` of use of the `dart:isolate` library is supported.
-  bool hasIsolateSupport = false;
-
-  /// `true` of `Function.apply` is supported.
-  bool hasFunctionApplySupport = false;
-
   /// List of constants from metadata.  If metadata must be preserved,
   /// these constants must be registered.
   final List<Dependency> metadataConstants = <Dependency>[];
 
   /// Set of elements for which metadata has been registered as dependencies.
   final Set<Element> _registeredMetadata = new Set<Element>();
 
   TypeVariableHandler typeVariableHandler;
 
   /// Number of methods compiled before considering reflection.
@@ skipping 42 matching lines @@
 
   StagedWorldImpactBuilder constantImpactsForCodegen =
       new StagedWorldImpactBuilder();
 
   final NativeData nativeData = new NativeData();
   InterceptorData _interceptorData;
   BackendUsageImpl _backendUsage;
   final MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
+  ResolutionEnqueuerListener _resolutionEnqueuerListener;
+  CodegenEnqueuerListener _codegenEnqueuerListener;
+
   BackendHelpers helpers;
   final BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
 
   /// Backend access to the front-end.
   final JSFrontendAccess frontend;
 
   Tracer tracer;
@@ skipping 30 matching lines @@
     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);
     _interceptorData = new InterceptorData(nativeData, helpers, commonElements);
     backendClasses = new JavaScriptBackendClasses(
         compiler.elementEnvironment, helpers, nativeData, _interceptorData);
+    _resolutionEnqueuerListener = new ResolutionEnqueuerListener(this);
+    _codegenEnqueuerListener = new CodegenEnqueuerListener(this);
   }
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
   Resolution get resolution => compiler.resolution;
 
   InterceptorData get interceptorData => _interceptorData;
 
   BackendUsage get backendUsage => _backendUsage;
 
   BackendUsageBuilder get backendUsageBuilder => _backendUsage;
 
   CheckedModeHelpers get checkedModeHelpers => _checkedModeHelpers;
 
+  EnqueuerListener get resolutionEnqueuerListener =>
+      _resolutionEnqueuerListener;
+
+  EnqueuerListener get codegenEnqueuerListener => _codegenEnqueuerListener;
+
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   @override
   bool isDefaultNoSuchMethod(MethodElement element) {
     return noSuchMethodRegistry.isDefaultNoSuchMethodImplementation(element);
   }
@@ skipping 156 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,
-      {bool forResolution}) {
-    if (forResolution) {
-      cls.ensureResolved(resolution);
-      interceptorData.addInterceptorsForNativeClassMembers(cls);
-    }
-  }
-
-  void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
-      {bool forResolution}) {
-    if (forResolution) {
-      cls.ensureResolved(resolution);
-      interceptorData.addInterceptors(cls);
-    }
-    backendUsageBuilder.registerBackendInstantiation(impactBuilder, cls);
-  }
-
   /// Called during codegen when [constant] has been used.
   void computeImpactForCompileTimeConstant(ConstantValue constant,
       WorldImpactBuilder impactBuilder, bool isForResolution) {
     computeImpactForCompileTimeConstantInternal(
         constant, impactBuilder, isForResolution);
 
     if (!isForResolution && lookupMapAnalysis.isLookupMap(constant)) {
       // Note: internally, this registration will temporarily remove the
       // constant dependencies and add them later on-demand.
       lookupMapAnalysis.registerLookupMapReference(constant);
@@ skipping 53 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));
       }
     }
   }
 
-  WorldImpact registerInstantiatedClass(ClassElement cls,
-      {bool forResolution}) {
-    return _processClass(cls, forResolution: forResolution);
-  }
-
-  WorldImpact registerImplementedClass(ClassElement cls, {bool forResolution}) {
-    return _processClass(cls, forResolution: forResolution);
-  }
-
-  WorldImpact _processClass(ClassElement cls, {bool forResolution}) {
-    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
-    if (!cls.typeVariables.isEmpty) {
-      typeVariableHandler.registerClassWithTypeVariables(cls,
-          forResolution: forResolution);
-    }
-
-    // Register any helper that will be needed by the backend.
-    if (forResolution) {
-      if (cls == commonElements.intClass ||
-          cls == commonElements.doubleClass ||
-          cls == commonElements.numClass) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.numClasses);
-      } else if (cls == commonElements.listClass ||
-          cls == commonElements.stringClass) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.listOrStringClasses);
-      } else if (cls == commonElements.functionClass) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.functionClass);
-      } else if (cls == commonElements.mapClass) {
-        backendUsageBuilder.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) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.boundClosureClass);
-      } else if (nativeData.isNativeOrExtendsNative(cls)) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.nativeOrExtendsClass);
-      } else if (cls == helpers.mapLiteralClass) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.mapLiteralClass);
-      }
-    }
-    if (cls == helpers.closureClass) {
-      backendUsageBuilder.registerBackendImpact(
-          impactBuilder, impacts.closureClass);
-    }
-    if (cls == commonElements.stringClass || cls == helpers.jsStringClass) {
-      addInterceptors(helpers.jsStringClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == commonElements.listClass ||
-        cls == helpers.jsArrayClass ||
-        cls == helpers.jsFixedArrayClass ||
-        cls == helpers.jsExtendableArrayClass ||
-        cls == helpers.jsUnmodifiableArrayClass) {
-      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) {
-        backendUsageBuilder.registerBackendImpact(
-            impactBuilder, impacts.listClasses);
-      }
-    } else if (cls == commonElements.intClass || cls == helpers.jsIntClass) {
-      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 == commonElements.doubleClass ||
-        cls == helpers.jsDoubleClass) {
-      addInterceptors(helpers.jsDoubleClass, impactBuilder,
-          forResolution: forResolution);
-      addInterceptors(helpers.jsNumberClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == commonElements.boolClass || cls == helpers.jsBoolClass) {
-      addInterceptors(helpers.jsBoolClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == commonElements.nullClass || cls == helpers.jsNullClass) {
-      addInterceptors(helpers.jsNullClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == commonElements.numClass || cls == helpers.jsNumberClass) {
-      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, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == helpers.jsPlainJavaScriptObjectClass) {
-      addInterceptors(helpers.jsPlainJavaScriptObjectClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == helpers.jsUnknownJavaScriptObjectClass) {
-      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (cls == helpers.jsJavaScriptFunctionClass) {
-      addInterceptors(helpers.jsJavaScriptFunctionClass, impactBuilder,
-          forResolution: forResolution);
-    } else if (nativeData.isNativeOrExtendsNative(cls)) {
-      addInterceptorsForNativeClassMembers(cls, forResolution: forResolution);
-    } else if (cls == helpers.jsIndexingBehaviorInterface) {
-      backendUsageBuilder.registerBackendImpact(
-          impactBuilder, impacts.jsIndexingBehavior);
-    }
-
-    customElementsAnalysis.registerInstantiatedClass(cls,
-        forResolution: forResolution);
-    if (!forResolution) {
-      lookupMapAnalysis.registerInstantiatedClass(cls);
-    }
-
-    return impactBuilder;
-  }
-
-  void registerInstantiatedType(ResolutionInterfaceType type,
-      {bool isGlobal: false}) {
-    if (isGlobal) {
-      backendUsageBuilder.registerGlobalDependency(type.element);
-    }
-    lookupMapAnalysis.registerInstantiatedType(type);
-  }
-
-  /// Compute the [WorldImpact] for backend helper methods.
-  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, impactBuilder, forResolution: true);
-    addInterceptors(helpers.jsNullClass, impactBuilder, forResolution: true);
-    if (compiler.options.enableTypeAssertions) {
-      backendUsageBuilder.registerBackendImpact(
-          impactBuilder, impacts.enableTypeAssertions);
-    }
-
-    if (TRACE_CALLS) {
-      backendUsageBuilder.registerBackendImpact(
-          impactBuilder, impacts.traceHelper);
-    }
-    backendUsageBuilder.registerBackendImpact(
-        impactBuilder, impacts.assertUnreachable);
-    _registerCheckedModeHelpers(impactBuilder);
-    return impactBuilder;
-  }
+  // TODO(johnniwinther): Avoid the need for this.
+  WorldImpact computeHelpersImpact() =>
+      _resolutionEnqueuerListener.computeHelpersImpact();
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsData.computeMembersNeededForReflection(closedWorld);
     rti.computeClassesNeedingRti(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _registeredMetadata.clear();
@@ skipping 118 matching lines @@
     backendUsageBuilder.registerBackendImpact(
         impactBuilder, impacts.isolateSupport);
     if (forResolution) {
       backendUsageBuilder.registerBackendImpact(
           impactBuilder, impacts.isolateSupportForResolution);
     }
     return impactBuilder;
   }
 
   bool classNeedsRti(ClassElement cls) {
-    if (hasRuntimeTypeSupport) return true;
+    if (backendUsage.isRuntimeTypeUsed) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool classNeedsRtiField(ClassElement cls) {
     if (cls.rawType.typeArguments.isEmpty) return false;
-    if (hasRuntimeTypeSupport) return true;
+    if (backendUsage.isRuntimeTypeUsed) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   bool methodNeedsRti(FunctionElement function) {
-    return rti.methodsNeedingRti.contains(function) || hasRuntimeTypeSupport;
+    return rti.methodsNeedingRti.contains(function) ||
+        backendUsage.isRuntimeTypeUsed;
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler) {
     return new CodegenEnqueuer(
         task, this, compiler.options, const TreeShakingEnqueuerStrategy());
   }
 
@@ skipping 134 matching lines @@
 
   Element getDartClass(Element element) {
     for (ClassElement dartClass in implementationClasses.keys) {
       if (element == implementationClasses[dartClass]) {
         return dartClass;
       }
     }
     return element;
   }
 
-  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.helpers) {
-      staticUses.add(helper.getStaticUse(helpers).element);
-    }
-    backendUsageBuilder.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(ResolutionDartType type) {
     Element element = type.element;
     return element == commonElements.stringClass ||
         element == commonElements.boolClass ||
         element == commonElements.numClass ||
         element == commonElements.intClass ||
         element == commonElements.doubleClass ||
         element == helpers.jsArrayClass ||
         element == helpers.jsMutableArrayClass ||
         element == helpers.jsExtendableArrayClass ||
         element == helpers.jsFixedArrayClass ||
         element == helpers.jsUnmodifiableArrayClass;
   }
 
   bool mayGenerateInstanceofCheck(ResolutionDartType 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 (interceptorData.isInterceptorClass(classElement)) return false;
     return _closedWorld.hasOnlySubclasses(classElement);
   }
 
-  WorldImpact registerUsedElement(MemberElement element, {bool forResolution}) {
-    WorldImpactBuilderImpl worldImpact = new WorldImpactBuilderImpl();
-    backendUsageBuilder.registerUsedMember(element);
-    if (element == helpers.disableTreeShakingMarker) {
-      mirrorsData.isTreeShakingDisabled = true;
-    } else if (element == helpers.preserveNamesMarker) {
-      mirrorsData.mustPreserveNames = true;
-    } else if (element == helpers.preserveMetadataMarker) {
-      mirrorsData.mustRetainMetadata = true;
-    } else if (element == helpers.preserveUrisMarker) {
-      if (compiler.options.preserveUris) mustPreserveUris = true;
-    } else if (element == helpers.preserveLibraryNamesMarker) {
-      mirrorsData.mustRetainLibraryNames = true;
-    } else if (element.isDeferredLoaderGetter) {
-      // TODO(sigurdm): Create a function registerLoadLibraryAccess.
-      if (!isLoadLibraryFunctionResolved) {
-        isLoadLibraryFunctionResolved = true;
-        if (forResolution) {
-          backendUsageBuilder.registerBackendImpact(
-              worldImpact, impacts.loadLibrary);
-        }
-      }
-    } else if (element == helpers.requiresPreambleMarker) {
-      requiresPreamble = true;
-    } else if (element == helpers.invokeOnMethod && forResolution) {
-      hasInvokeOnSupport = true;
-    }
-    customElementsAnalysis.registerStaticUse(element,
-        forResolution: forResolution);
-
-    if (element.isFunction && element.isInstanceMember) {
-      MemberElement function = element;
-      ClassElement cls = function.enclosingClass;
-      if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
-        worldImpact.addImpact(registerCallMethodWithFreeTypeVariables(function,
-            forResolution: forResolution));
-      }
-    }
-    if (forResolution) {
-      // Enable isolate support if we start using something from the isolate
-      // library, or timers for the async library.  We exclude constant fields,
-      // which are ending here because their initializing expression is
-      // compiled.
-      LibraryElement library = element.library;
-      if (!hasIsolateSupport && !(element.isField && element.isConst)) {
-        Uri uri = library.canonicalUri;
-        if (uri == Uris.dart_isolate) {
-          hasIsolateSupport = true;
-          worldImpact
-              .addImpact(enableIsolateSupport(forResolution: forResolution));
-        } else if (uri == Uris.dart_async) {
-          if (element.name == '_createTimer' ||
-              element.name == '_createPeriodicTimer') {
-            // The [:Timer:] class uses the event queue of the isolate
-            // library, so we make sure that event queue is generated.
-            hasIsolateSupport = true;
-            worldImpact
-                .addImpact(enableIsolateSupport(forResolution: forResolution));
-          }
-        }
-      }
-
-      if (element.isGetter && element.name == Identifiers.runtimeType_) {
-        // Enable runtime type support if we discover a getter called
-        // runtimeType. We have to enable runtime type before hitting the
-        // codegen, so that constructors know whether they need to generate code
-        // for runtime type.
-        hasRuntimeTypeSupport = true;
-        // TODO(ahe): Record precise dependency here.
-        worldImpact.addImpact(registerRuntimeType());
-      } else if (compiler.commonElements.isFunctionApplyMethod(element)) {
-        hasFunctionApplySupport = true;
-      }
-    } else {
-      // TODO(sigmund): add other missing dependencies (internals, selectors
-      // enqueued after allocations).
-      compiler.dumpInfoTask.registerDependency(element);
-    }
-    return worldImpact;
-  }
-
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     if (!compiler.serialization.isDeserialized(library)) {
       if (canLibraryUseNative(library)) {
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
             checkNativeAnnotation(compiler, element);
           }
         });
@@ skipping 104 matching lines @@
       if (target == null) continue;
       if (target.isField) {
         staticFields.add(target);
       } else if (target.isLibrary || target.isClass) {
         addFieldsInContainer(target);
       }
     }
     return staticFields;
   }
 
-  bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {
+  // TODO(johnniwinther): Split this into [ResolutionEnqueuerListener]
+  // and [CodegenEnqueuerListener].
+  bool _onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> 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(
         lookupMapAnalysis.flush(forResolution: enqueuer.isResolutionQueue));
     enqueuer.applyImpact(
@@ skipping 147 matching lines @@
   }
 
   /// Called when the compiler starts running the codegen enqueuer. The
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(ClosedWorld closedWorld) {
     _closedWorld = closedWorld;
     _namer = determineNamer(_closedWorld, compiler.codegenWorldBuilder);
     tracer = new Tracer(_closedWorld, namer, compiler.outputProvider);
     emitter.createEmitter(_namer, _closedWorld);
     lookupMapAnalysis.onCodegenStart();
-    if (hasIsolateSupport) {
+    if (backendUsage.isIsolateInUse) {
       return enableIsolateSupport(forResolution: false);
     }
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
   }
@@ skipping 871 matching lines @@
   }
 
   @override
   FieldEntity get symbolField => helpers.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
     return _env.getRawType(helpers.symbolImplementationClass);
   }
 }
+
+abstract class EnqueuerListenerBase implements EnqueuerListener {
+  // TODO(johnniwinther): Avoid the need for accessing through [_backend].
+  JavaScriptBackend _backend;
+
+  EnqueuerListenerBase(this._backend);
+
+  // TODO(johnniwinther): Change these to final fields.
+  CommonElements get commonElements => _backend.commonElements;
+  BackendHelpers get helpers => _backend.helpers;
+  BackendImpacts get impacts => _backend.impacts;
+  BackendUsageBuilder get backendUsage => _backend.backendUsageBuilder;
+  CustomElementsAnalysis get customElementsAnalysis =>
+      _backend.customElementsAnalysis;
+  NativeData get nativeData => _backend.nativeData;
+  InterceptorData get interceptorData => _backend.interceptorData;
+  RuntimeTypes get rti => _backend.rti;
+  TypeVariableHandler get typeVariableHandler => _backend.typeVariableHandler;
+  Resolution get resolution => _backend.resolution;
+  MirrorsData get mirrorsData => _backend.mirrorsData;
+  CompilerOptions get options => _backend.compiler.options;
+
+  WorldImpact registerBoundClosure() {
+    return backendUsage.createImpactFor(impacts.memberClosure);
+  }
+
+  WorldImpact registerGetOfStaticFunction() {
+    return backendUsage.createImpactFor(impacts.staticClosure);
+  }
+
+  WorldImpact _registerComputeSignature() {
+    return backendUsage.createImpactFor(impacts.computeSignature);
+  }
+
+  /// Called to register that an instantiated generic class has a call method.
+  /// Any backend specific [WorldImpact] of this is returned.
+  ///
+  /// Note: The [callMethod] is registered even thought it doesn't reference
+  /// the type variables.
+  WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod);
+
+  WorldImpact _processClass(ClassElement cls, {bool forResolution}) {
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
+    if (!cls.typeVariables.isEmpty) {
+      typeVariableHandler.registerClassWithTypeVariables(cls,
+          forResolution: forResolution);
+    }
+
+    // Register any helper that will be needed by the backend.
+    if (forResolution) {
+      if (cls == commonElements.intClass ||
+          cls == commonElements.doubleClass ||
+          cls == commonElements.numClass) {
+        backendUsage.registerBackendImpact(impactBuilder, impacts.numClasses);
+      } else if (cls == commonElements.listClass ||
+          cls == commonElements.stringClass) {
+        backendUsage.registerBackendImpact(
+            impactBuilder, impacts.listOrStringClasses);
+      } else if (cls == commonElements.functionClass) {
+        backendUsage.registerBackendImpact(
+            impactBuilder, impacts.functionClass);
+      } else if (cls == commonElements.mapClass) {
+        backendUsage.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) {
+        backendUsage.registerBackendImpact(
+            impactBuilder, impacts.boundClosureClass);
+      } else if (nativeData.isNativeOrExtendsNative(cls)) {
+        backendUsage.registerBackendImpact(
+            impactBuilder, impacts.nativeOrExtendsClass);
+      } else if (cls == helpers.mapLiteralClass) {
+        backendUsage.registerBackendImpact(
+            impactBuilder, impacts.mapLiteralClass);
+      }
+    }
+    if (cls == helpers.closureClass) {
+      backendUsage.registerBackendImpact(impactBuilder, impacts.closureClass);
+    }
+    if (cls == commonElements.stringClass || cls == helpers.jsStringClass) {
+      addInterceptors(helpers.jsStringClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == commonElements.listClass ||
+        cls == helpers.jsArrayClass ||
+        cls == helpers.jsFixedArrayClass ||
+        cls == helpers.jsExtendableArrayClass ||
+        cls == helpers.jsUnmodifiableArrayClass) {
+      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) {
+        backendUsage.registerBackendImpact(impactBuilder, impacts.listClasses);
+      }
+    } else if (cls == commonElements.intClass || cls == helpers.jsIntClass) {
+      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 == commonElements.doubleClass ||
+        cls == helpers.jsDoubleClass) {
+      addInterceptors(helpers.jsDoubleClass, impactBuilder,
+          forResolution: forResolution);
+      addInterceptors(helpers.jsNumberClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == commonElements.boolClass || cls == helpers.jsBoolClass) {
+      addInterceptors(helpers.jsBoolClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == commonElements.nullClass || cls == helpers.jsNullClass) {
+      addInterceptors(helpers.jsNullClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == commonElements.numClass || cls == helpers.jsNumberClass) {
+      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, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == helpers.jsPlainJavaScriptObjectClass) {
+      addInterceptors(helpers.jsPlainJavaScriptObjectClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == helpers.jsUnknownJavaScriptObjectClass) {
+      addInterceptors(helpers.jsUnknownJavaScriptObjectClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (cls == helpers.jsJavaScriptFunctionClass) {
+      addInterceptors(helpers.jsJavaScriptFunctionClass, impactBuilder,
+          forResolution: forResolution);
+    } else if (nativeData.isNativeOrExtendsNative(cls)) {
+      addInterceptorsForNativeClassMembers(cls, forResolution: forResolution);
+    } else if (cls == helpers.jsIndexingBehaviorInterface) {
+      backendUsage.registerBackendImpact(
+          impactBuilder, impacts.jsIndexingBehavior);
+    }
+
+    customElementsAnalysis.registerInstantiatedClass(cls,
+        forResolution: forResolution);
+
+    return impactBuilder;
+  }
+
+  void addInterceptorsForNativeClassMembers(ClassElement cls,
+      {bool forResolution}) {
+    if (forResolution) {
+      cls.ensureResolved(resolution);
+      interceptorData.addInterceptorsForNativeClassMembers(cls);
+    }
+  }
+
+  void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
+      {bool forResolution}) {
+    if (forResolution) {
+      cls.ensureResolved(resolution);
+      interceptorData.addInterceptors(cls);
+    }
+    backendUsage.registerBackendInstantiation(impactBuilder, cls);
+  }
+
+  void _registerUsedElement(
+      WorldImpactBuilderImpl worldImpact, MemberElement element,
+      {bool forResolution}) {
+    backendUsage.registerUsedMember(element);
+    mirrorsData.registerUsedMember(element);
+    customElementsAnalysis.registerStaticUse(element,
+        forResolution: forResolution);
+
+    if (element.isFunction && element.isInstanceMember) {
+      MemberElement function = element;
+      ClassElement cls = function.enclosingClass;
+      if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
+        worldImpact
+            .addImpact(registerCallMethodWithFreeTypeVariables(function));
+      }
+    }
+  }
+}
+
+class ResolutionEnqueuerListener extends EnqueuerListenerBase {
+  ResolutionEnqueuerListener(JavaScriptBackend backend) : super(backend);
+
+  // TODO(johnniwinther): Change this to a final field.
+  NoSuchMethodRegistry get noSuchMethodRegistry =>
+      _backend.noSuchMethodRegistry;
+
+  /// True when we enqueue the loadLibrary code.
+  bool _isLoadLibraryFunctionResolved = false;
+
+  @override
+  void registerInstantiatedType(ResolutionInterfaceType type,
+      {bool isGlobal: false}) {
+    if (isGlobal) {
+      backendUsage.registerGlobalDependency(type.element);
+    }
+  }
+
+  @override
+  bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {
+    return _backend._onQueueEmpty(enqueuer, recentClasses);
+  }
+
+  @override
+  WorldImpact registerUsedElement(MemberElement member) {
+    WorldImpactBuilderImpl worldImpact = new WorldImpactBuilderImpl();
+    _registerUsedElement(worldImpact, member, forResolution: true);
+
+    if (member.isDeferredLoaderGetter) {
+      // TODO(sigurdm): Create a function registerLoadLibraryAccess.
+      if (!_isLoadLibraryFunctionResolved) {
+        _isLoadLibraryFunctionResolved = true;
+        backendUsage.registerBackendImpact(worldImpact, impacts.loadLibrary);
+      }
+    }
+
+    // Enable isolate support if we start using something from the isolate
+    // library, or timers for the async library.  We exclude constant fields,
+    // which are ending here because their initializing expression is
+    // compiled.
+    LibraryElement library = member.library;
+    if (!backendUsage.isIsolateInUse && !(member.isField && member.isConst)) {
+      Uri uri = library.canonicalUri;
+      if (uri == Uris.dart_isolate) {
+        backendUsage.isIsolateInUse = true;
+        worldImpact.addImpact(enableIsolateSupport());
+      } else if (uri == Uris.dart_async) {
+        if (member.name == '_createTimer' ||
+            member.name == '_createPeriodicTimer') {
+          // The [:Timer:] class uses the event queue of the isolate
+          // library, so we make sure that event queue is generated.
+          backendUsage.isIsolateInUse = true;
+          worldImpact.addImpact(enableIsolateSupport());
+        }
+      }
+    }
+
+    if (member.isGetter && member.name == Identifiers.runtimeType_) {
+      // Enable runtime type support if we discover a getter called
+      // runtimeType. We have to enable runtime type before hitting the
+      // codegen, so that constructors know whether they need to generate code
+      // for runtime type.
+      backendUsage.isRuntimeTypeUsed = true;
+      // TODO(ahe): Record precise dependency here.
+      worldImpact.addImpact(registerRuntimeType());
+    }
+
+    return worldImpact;
+  }
+
+  WorldImpact enableIsolateSupport() =>
+      _backend.enableIsolateSupport(forResolution: true);
+
+  /// Called to register that the `runtimeType` property has been accessed. Any
+  /// backend specific [WorldImpact] of this is returned.
+  WorldImpact registerRuntimeType() {
+    return backendUsage.createImpactFor(impacts.runtimeTypeSupport);
+  }
+
+  WorldImpact registerClosureWithFreeTypeVariables(MethodElement closure) {
+    return _registerComputeSignature();
+  }
+
+  WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod,
+      {bool forResolution}) {
+    return _registerComputeSignature();
+  }
+
+  @override
+  WorldImpact registerImplementedClass(ClassEntity cls) {
+    return _processClass(cls, forResolution: true);
+  }
+
+  @override
+  WorldImpact registerInstantiatedClass(ClassEntity cls) {
+    return _processClass(cls, forResolution: true);
+  }
+
+  /// Compute the [WorldImpact] for backend helper methods.
+  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, impactBuilder, forResolution: true);
+    addInterceptors(helpers.jsNullClass, impactBuilder, forResolution: true);
+    if (options.enableTypeAssertions) {
+      backendUsage.registerBackendImpact(
+          impactBuilder, impacts.enableTypeAssertions);
+    }
+
+    if (JavaScriptBackend.TRACE_CALLS) {
+      backendUsage.registerBackendImpact(impactBuilder, impacts.traceHelper);
+    }
+    backendUsage.registerBackendImpact(
+        impactBuilder, impacts.assertUnreachable);
+    _registerCheckedModeHelpers(impactBuilder);
+    return impactBuilder;
+  }
+
+  /// Called to register a `noSuchMethod` implementation.
+  void registerNoSuchMethod(MethodElement noSuchMethod) {
+    noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
+  }
+
+  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.helpers) {
+      staticUses.add(helper.getStaticUse(helpers).element);
+    }
+    backendUsage.registerBackendImpact(
+        impactBuilder, new BackendImpact(globalUses: staticUses));
+  }
+}
+
+class CodegenEnqueuerListener extends EnqueuerListenerBase {
+  CodegenEnqueuerListener(JavaScriptBackend backend) : super(backend);
+
+  // TODO(johnniwinther): Change these to final fields.
+  LookupMapAnalysis get lookupMapAnalysis => _backend.lookupMapAnalysis;
+  DumpInfoTask get dumpInfoTask => _backend.compiler.dumpInfoTask;
+
+  @override
+  void registerInstantiatedType(ResolutionInterfaceType type,
+      {bool isGlobal: false}) {
+    lookupMapAnalysis.registerInstantiatedType(type);
+  }
+
+  @override
+  bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {
+    // TODO(johnniwinther): Avoid the need for accessing [_backend].
+    return _backend._onQueueEmpty(enqueuer, recentClasses);
+  }
+
+  @override
+  WorldImpact registerUsedElement(MemberElement member) {
+    WorldImpactBuilderImpl worldImpact = new WorldImpactBuilderImpl();
+    _registerUsedElement(worldImpact, member, forResolution: false);
+
+    // TODO(sigmund): add other missing dependencies (internals, selectors
+    // enqueued after allocations).
+    dumpInfoTask.registerDependency(member);
+
+    return worldImpact;
+  }
+
+  WorldImpact registerClosureWithFreeTypeVariables(MethodElement closure) {
+    if (methodNeedsRti(closure)) {
+      return _registerComputeSignature();
+    }
+    return const WorldImpact();
+  }
+
+  WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod) {
+    if (methodNeedsRti(callMethod)) {
+      return _registerComputeSignature();
+    }
+    return const WorldImpact();
+  }
+
+  @override
+  WorldImpact registerImplementedClass(ClassEntity cls) {
+    WorldImpact worldImpact = _processClass(cls, forResolution: false);
+    lookupMapAnalysis.registerInstantiatedClass(cls);
+    return worldImpact;
+  }
+
+  @override
+  WorldImpact registerInstantiatedClass(ClassEntity cls) {
+    WorldImpact worldImpact = _processClass(cls, forResolution: false);
+    lookupMapAnalysis.registerInstantiatedClass(cls);
+    return worldImpact;
+  }
+
+  // TODO(johnniwinther): Avoid the need for accessing [_backend].
+  bool methodNeedsRti(FunctionElement function) =>
+      _backend.methodNeedsRti(function);
+}