Introduce BackendImpact to separate enqueueing from data.

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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 260 matching lines @@
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   LibraryElement jsHelperLibrary;
   LibraryElement asyncLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
   LibraryElement isolateHelperLibrary;
 
   ClassElement closureClass;
   ClassElement boundClosureClass;
-  Element assertTestMethod;
-  Element assertThrowMethod;
-  Element assertHelperMethod;
   Element assertUnreachableMethod;
   Element invokeOnMethod;
 
   ClassElement jsInterceptorClass;
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsNullClass;
@@ skipping 13 matching lines @@
   ClassElement jsUInt31Class;
 
   Element jsIndexableLength;
   Element jsArrayTypedConstructor;
   Element jsArrayRemoveLast;
   Element jsArrayAdd;
   Element jsStringSplit;
   Element jsStringToString;
   Element jsStringOperatorAdd;
   Element objectEquals;
-  Element cachedCheckConcurrentModificationError;
 
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
   ClassElement typeVariableClass;
   ConstructorElement mapLiteralConstructor;
   ConstructorElement mapLiteralConstructorEmpty;
   Element mapLiteralUntypedMaker;
   Element mapLiteralUntypedEmptyMaker;
 
@@ skipping 297 matching lines @@
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptResolutionCallbacks resolutionCallbacks;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
 
   final SourceInformationStrategy sourceInformationStrategy;
 
+  final BackendHelpers helpers;
+  final BackendImpacts impacts;
+
   JavaScriptBackend(Compiler compiler,
                     {bool generateSourceMap: true,
                      bool useStartupEmitter: false})
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
         annotations = new Annotations(compiler),
         this.sourceInformationStrategy =
             generateSourceMap
                 ? (useNewSourceInfo
                      ? const PositionSourceInformationStrategy()
                      : const StartEndSourceInformationStrategy())
                 : const JavaScriptSourceInformationStrategy(),
+        helpers = new BackendHelpers(compiler),
+        impacts = new BackendImpacts(compiler),
         super(compiler) {
     emitter = new CodeEmitterTask(
         compiler, namer, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
     patchResolverTask = new PatchResolverTask(compiler);
@@ skipping 330 matching lines @@
     registerInstantiatedConstantType(type, registry);
 
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       registry.registerGetOfStaticFunction(function.element);
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstantValue interceptor = constant;
       registerInstantiatedConstantType(interceptor.dispatchedType, registry);
     } else if (constant.isType) {
-      enqueueInResolution(getCreateRuntimeType(), registry);
+      enqueueInResolution(helpers.createRuntimeType, registry);
       registry.registerInstantiation(typeImplementation.rawType);
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
 
   void registerInstantiatedConstantType(DartType type, Registry registry) {
     DartType instantiatedType =
         type.isFunctionType ? compiler.functionClass.rawType : type;
     if (type is InterfaceType) {
       registry.registerInstantiation(instantiatedType);
       if (!type.treatAsRaw && classNeedsRti(type.element)) {
-        registry.registerStaticInvocation(getSetRuntimeTypeInfo());
+        registry.registerStaticInvocation(helpers.setRuntimeTypeInfo);
       }
       if (type.element == typeImplementation) {
         // If we use a type literal in a constant, the compile time
         // constant emitter will generate a call to the createRuntimeType
         // helper so we register a use of that.
-        registry.registerStaticInvocation(getCreateRuntimeType());
+        registry.registerStaticInvocation(helpers.createRuntimeType);
       }
     }
   }
 
   void registerMetadataConstant(MetadataAnnotation metadata,
                                 Element annotatedElement,
                                 Registry registry) {
     assert(registry.isForResolution);
     ConstantValue constant = constants.getConstantValueForMetadata(metadata);
     registerCompileTimeConstant(constant, registry, addForEmission: false);
@@ skipping 199 matching lines @@
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
-    enqueueInResolution(getGetRuntimeTypeArgument(), registry);
-    enqueueInResolution(getGetTypeArgumentByIndex(), registry);
-    enqueueInResolution(getCopyTypeArguments(), registry);
+    enqueueImpact(
+        compiler.enqueuer.resolution,
+        impacts.getRuntimeTypeArgument,
+        registry);
   }
 
   void registerCallMethodWithFreeTypeVariables(
       Element callMethod,
       Enqueuer enqueuer,
       Registry registry) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(callMethod)) {
       registerComputeSignature(enqueuer, registry);
     }
   }
@@ skipping 30 matching lines @@
     registerInstantiatedType(
         closureClass.rawType,
         enqueuer,
         compiler.globalDependencies);
   }
 
   void registerComputeSignature(Enqueuer enqueuer, Registry registry) {
     // 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.
-    enqueue(enqueuer, getSetRuntimeTypeInfo(), registry);
-    enqueue(enqueuer, getGetRuntimeTypeInfo(), registry);
-    enqueue(enqueuer, getComputeSignature(), registry);
-    enqueue(enqueuer, getGetRuntimeTypeArguments(), registry);
-    enqueueClass(enqueuer, compiler.listClass, registry);
+    enqueueImpact(enqueuer, impacts.computeSignature, registry);
   }
 
   void registerRuntimeType(Enqueuer enqueuer, Registry registry) {
     registerComputeSignature(enqueuer, registry);
-    enqueueInResolution(getSetRuntimeTypeInfo(), registry);
-    enqueueInResolution(getGetRuntimeTypeInfo(), registry);
+    enqueueInResolution(helpers.setRuntimeTypeInfo, registry);
     registerGetRuntimeTypeArgument(registry);
+    enqueueInResolution(helpers.getRuntimeTypeInfo, registry);
     enqueueClass(enqueuer, compiler.listClass, registry);
   }
 
   void registerIsCheckForCodegen(DartType type,
                                  Enqueuer world,
                                  Registry registry) {
     assert(!registry.isForResolution);
     type = type.unalias(resolution);
     enqueueClass(world, compiler.boolClass, registry);
     bool inCheckedMode = compiler.enableTypeAssertions;
@@ skipping 24 matching lines @@
       enqueue(world, findHelper('defineProperty'), registry);
     }
   }
 
   void registerTypeVariableBoundsSubtypeCheck(DartType typeArgument,
                                               DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
   void registerCheckDeferredIsLoaded(Registry registry) {
-    enqueueInResolution(getCheckDeferredIsLoaded(), registry);
+    enqueueInResolution(helpers.checkDeferredIsLoaded, registry);
     // Also register the types of the arguments passed to this method.
     enqueueClass(compiler.enqueuer.resolution, compiler.stringClass, registry);
   }
 
   void registerNoSuchMethod(FunctionElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   /// Called when resolving a call to a foreign function.
   void registerForeignCall(Send node,
@@ skipping 23 matching lines @@
           }
         }
       }
       reporter.reportErrorMessage(
           node,
           MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
   }
 
   void enableNoSuchMethod(Enqueuer world) {
-    enqueue(world, getCreateInvocationMirror(), compiler.globalDependencies);
+    enqueue(world, helpers.createInvocationMirror, compiler.globalDependencies);
     world.registerInvocation(
         new UniverseSelector(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
@@ skipping 94 matching lines @@
     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);
   }
 
+  /// Register instantiation of [type] in [enqueuer].
+  ///
+  /// This method calls [registerBackendUse].
+  void enqueueType(Enqueuer enqueuer, InterfaceType type, Registry registry) {
+    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);
+  }
+
+  void enqueueImpact(Enqueuer enqueuer,
+                     BackendImpact impact,
+                     Registry registry) {
+    for (Element staticUse in impact.staticUses) {
+      enqueue(enqueuer, staticUse, registry);
+    }
+    for (InterfaceType type in impact.instantiatedTypes) {
+      enqueueType(enqueuer, type, registry);
+    }
+    for (ClassElement cls in impact.instantiatedClasses) {
+      enqueueClass(enqueuer, cls, registry);
+    }
+    for (BackendImpact otherImpact in impact.otherImpacts) {
+      enqueueImpact(enqueuer, otherImpact, registry);
+    }
+  }
+
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
       generatedCode[element] = jsAst.js(
           "function () { throw new Error('Compile time error in $element') }");
       return const WorldImpact();
     }
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) {
       return const WorldImpact();
@@ skipping 11 matching lines @@
         // variables. For instance variables, we may need to generate
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) {
           return const WorldImpact();
         }
       } 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(getCyclicThrowHelper());
+        compiler.enqueuer.codegen.registerStaticUse(
+            helpers.cyclicThrowHelper);
       }
     }
 
     generatedCode[element] = functionCompiler.compile(work);
     return const WorldImpact();
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
@@ skipping 238 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.world.hasOnlySubclasses(classElement);
   }
 
-  Element getExceptionUnwrapper() {
-    return findHelper('unwrapException');
-  }
-
-  Element getThrowRuntimeError() {
-    return findHelper('throwRuntimeError');
-  }
-
-  Element getThrowTypeError() {
-    return findHelper('throwTypeError');
-  }
-
-  Element getThrowAbstractClassInstantiationError() {
-    return findHelper('throwAbstractClassInstantiationError');
-  }
-
-  Element getCheckConcurrentModificationError() {
-    if (cachedCheckConcurrentModificationError == null) {
-      cachedCheckConcurrentModificationError =
-          findHelper('checkConcurrentModificationError');
-    }
-    return cachedCheckConcurrentModificationError;
-  }
-
-  Element getThrowConcurrentModificationError() {
-    return findHelper('throwConcurrentModificationError');
-  }
-
-  Element getThrowIndexOutOfBoundsError() {
-    return findHelper('ioore');
-  }
-
-  Element getStringInterpolationHelper() {
-    return findHelper('S');
-  }
-
-  Element getWrapExceptionHelper() {
-    return findHelper(r'wrapException');
-  }
-
-  Element getThrowExpressionHelper() {
-    return findHelper('throwExpression');
-  }
-
-  Element getClosureConverter() {
-    return findHelper('convertDartClosureToJS');
-  }
-
-  Element getTraceFromException() {
-    return findHelper('getTraceFromException');
-  }
-
-  Element getSetRuntimeTypeInfo() {
-    return findHelper('setRuntimeTypeInfo');
-  }
-
-  Element getGetRuntimeTypeInfo() {
-    return findHelper('getRuntimeTypeInfo');
-  }
-
-  Element getGetTypeArgumentByIndex() {
-    return findHelper('getTypeArgumentByIndex');
-  }
-
-  Element getCopyTypeArguments() {
-    return findHelper('copyTypeArguments');
-  }
-
-  Element getComputeSignature() {
-    return findHelper('computeSignature');
-  }
-
-  Element getGetRuntimeTypeArguments() {
-    return findHelper('getRuntimeTypeArguments');
-  }
-
-  Element getGetRuntimeTypeArgument() {
-    return findHelper('getRuntimeTypeArgument');
-  }
-
-  Element getRuntimeTypeToString() {
-    return findHelper('runtimeTypeToString');
-  }
-
-  Element getAssertIsSubtype() {
-    return findHelper('assertIsSubtype');
-  }
-
-  Element getCheckSubtype() {
-    return findHelper('checkSubtype');
-  }
-
-  Element getAssertSubtype() {
-    return findHelper('assertSubtype');
-  }
-
-  Element getSubtypeCast() {
-    return findHelper('subtypeCast');
-  }
-
-  Element getCheckSubtypeOfRuntimeType() {
-    return findHelper('checkSubtypeOfRuntimeType');
-  }
-
-  Element getAssertSubtypeOfRuntimeType() {
-    return findHelper('assertSubtypeOfRuntimeType');
-  }
-
-  Element getSubtypeOfRuntimeTypeCast() {
-    return findHelper('subtypeOfRuntimeTypeCast');
-  }
-
-  Element getCheckDeferredIsLoaded() {
-    return findHelper('checkDeferredIsLoaded');
-  }
-
-  Element getThrowNoSuchMethod() {
-    return findHelper('throwNoSuchMethod');
-  }
-
-  Element getCreateRuntimeType() {
-    return findHelper('createRuntimeType');
-  }
-
-  Element getFallThroughError() {
-    return findHelper("getFallThroughError");
-  }
-
-  Element getCreateInvocationMirror() {
-    return findHelper(Compiler.CREATE_INVOCATION_MIRROR);
-  }
-
-  Element getCyclicThrowHelper() {
-    return findHelper("throwCyclicInit");
-  }
-
-  Element getAsyncHelper() {
-    return findAsyncHelper("_asyncHelper");
-  }
-
-  Element getWrapBody() {
-    return findAsyncHelper("_wrapJsFunctionForAsync");
-  }
-
-  Element getYieldStar() {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupLocalMember("yieldStar");
-  }
-
-  Element getYieldSingle() {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupLocalMember("yieldSingle");
-  }
-
-  Element getSyncStarUncaughtError() {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupLocalMember("uncaughtError");
-  }
-
-  Element getAsyncStarHelper() {
-    return findAsyncHelper("_asyncStarHelper");
-  }
-
-  Element getStreamOfController() {
-    return findAsyncHelper("_streamOfController");
-  }
-
-  Element getEndOfIteration() {
-    ClassElement classElement = findAsyncHelper("_IterationMarker");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupLocalMember("endOfIteration");
-  }
-
-  Element getSyncStarIterable() {
-    ClassElement classElement = findAsyncHelper("_SyncStarIterable");
-    classElement.ensureResolved(resolution);
-    return classElement;
-  }
-
-  Element getSyncStarIterableConstructor() {
-    ClassElement classElement = getSyncStarIterable();
-    classElement.ensureResolved(resolution);
-    return classElement.lookupConstructor("");
-  }
-
-  Element getSyncCompleterConstructor() {
-    ClassElement classElement = find(compiler.asyncLibrary, "Completer");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupConstructor("sync");
-  }
-
-  Element getASyncStarController() {
-    ClassElement classElement =
-        findAsyncHelper("_AsyncStarStreamController");
-    classElement.ensureResolved(resolution);
-    return classElement;
-  }
-
-  Element getASyncStarControllerConstructor() {
-    ClassElement classElement = getASyncStarController();
-    return classElement.lookupConstructor("");
-  }
-
-  Element getStreamIteratorConstructor() {
-    ClassElement classElement = find(compiler.asyncLibrary, "StreamIterator");
-    classElement.ensureResolved(resolution);
-    return classElement.lookupConstructor("");
-  }
-
   bool isNullImplementation(ClassElement cls) {
     return cls == jsNullClass;
   }
 
   ClassElement get intImplementation => jsIntClass;
   ClassElement get uint32Implementation => jsUInt32Class;
   ClassElement get uint31Implementation => jsUInt31Class;
   ClassElement get positiveIntImplementation => jsPositiveIntClass;
   ClassElement get doubleImplementation => jsDoubleClass;
   ClassElement get numImplementation => jsNumberClass;
@@ skipping 30 matching lines @@
         enqueueInResolution(compiler.loadLibraryFunction,
                             compiler.globalDependencies);
       }
     } else if (element == requiresPreambleMarker) {
       requiresPreamble = true;
     }
     customElementsAnalysis.registerStaticUse(element, enqueuer);
   }
 
   /// Called when [:const Symbol(name):] is seen.
-  void registerConstSymbol(String name, Registry registry) {
+  void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 
   /// Called when [:new Symbol(...):] is seen.
   void registerNewSymbol(Registry registry) {
   }
 
@@ skipping 108 matching lines @@
         jsMutableArrayClass = findClass('JSMutableArray');
         jsFixedArrayClass = findClass('JSFixedArray');
         jsExtendableArrayClass = findClass('JSExtendableArray');
         jsUnmodifiableArrayClass = findClass('JSUnmodifiableArray');
         jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject');
         jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject');
         jsIndexableClass = findClass('JSIndexable');
         jsMutableIndexableClass = findClass('JSMutableIndexable');
       } else if (uri == DART_JS_HELPER) {
         initializeHelperClasses();
-        assertTestMethod = findHelper('assertTest');
-        assertThrowMethod = findHelper('assertThrow');
-        assertHelperMethod = findHelper('assertHelper');
+        helpers.assertTest = findHelper('assertTest');
+        helpers.assertThrow = findHelper('assertThrow');
+        helpers.assertHelper = findHelper('assertHelper');
         assertUnreachableMethod = findHelper('assertUnreachable');
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
         typeVariableClass = findClass('TypeVariable');
 
         jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
 
         noSideEffectsClass = findClass('NoSideEffects');
         noThrowsClass = findClass('NoThrows');
@@ skipping 609 matching lines @@
       _registerAsync(enqueuer, registry);
     } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
       _registerSyncStar(enqueuer, registry);
     } else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
       _registerAsyncStar(enqueuer, registry);
     }
   }
 
   void _registerAsync(Enqueuer enqueuer,
                       Registry registry) {
-    enqueue(enqueuer, getAsyncHelper(), registry);
-    enqueue(enqueuer, getSyncCompleterConstructor(), registry);
-    enqueue(enqueuer, getStreamIteratorConstructor(), registry);
-    enqueue(enqueuer, getWrapBody(), registry);
+    enqueueImpact(enqueuer, impacts.asyncBody, registry);
   }
 
   void _registerSyncStar(Enqueuer enqueuer,
                          Registry registry) {
-    ClassElement clsSyncStarIterable = getSyncStarIterable();
-    clsSyncStarIterable.ensureResolved(compiler.resolution);
-    registerInstantiatedType(clsSyncStarIterable.rawType, enqueuer, registry);
-    enqueue(enqueuer, getSyncStarIterableConstructor(), registry);
-    enqueue(enqueuer, getEndOfIteration(), registry);
-    enqueue(enqueuer, getYieldStar(), registry);
-    enqueue(enqueuer, getSyncStarUncaughtError(), registry);
+    enqueueImpact(enqueuer, impacts.syncStarBody, registry);
   }
 
   void _registerAsyncStar(Enqueuer enqueuer,
                           Registry registry) {
-    ClassElement clsASyncStarController = getASyncStarController();
-    clsASyncStarController.ensureResolved(compiler.resolution);
-    registerInstantiatedType(
-        clsASyncStarController.rawType, enqueuer, registry);
-    enqueue(enqueuer, getAsyncStarHelper(), registry);
-    enqueue(enqueuer, getStreamOfController(), registry);
-    enqueue(enqueuer, getYieldSingle(), registry);
-    enqueue(enqueuer, getYieldStar(), registry);
-    enqueue(enqueuer, getASyncStarControllerConstructor(), registry);
-    enqueue(enqueuer, getStreamIteratorConstructor(), registry);
-    enqueue(enqueuer, getWrapBody(), registry);
+    enqueueImpact(enqueuer, impacts.asyncStarBody, registry);
   }
 
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     registerCheckDeferredIsLoaded(registry);
     return true;
   }
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) {
@@ skipping 11 matching lines @@
   jsAst.Expression rewriteAsync(FunctionElement element,
                                 jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
     switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
         rewriter = new AsyncRewriter(
             reporter,
             element,
             asyncHelper:
-                emitter.staticFunctionAccess(getAsyncHelper()),
+                emitter.staticFunctionAccess(helpers.asyncHelper),
             wrapBody:
-                emitter.staticFunctionAccess(getWrapBody()),
+                emitter.staticFunctionAccess(helpers.wrapBody),
             newCompleter: emitter.staticFunctionAccess(
-                getSyncCompleterConstructor()),
+                helpers.syncCompleterConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       case AsyncMarker.SYNC_STAR:
         rewriter = new SyncStarRewriter(
             reporter,
             element,
             endOfIteration: emitter.staticFunctionAccess(
-                getEndOfIteration()),
+                helpers.endOfIteration),
             newIterable: emitter.staticFunctionAccess(
-                getSyncStarIterableConstructor()),
+                helpers.syncStarIterableConstructor),
             yieldStarExpression: emitter.staticFunctionAccess(
-                getYieldStar()),
+                helpers.yieldStar),
             uncaughtErrorExpression: emitter.staticFunctionAccess(
-                getSyncStarUncaughtError()),
+                helpers.syncStarUncaughtError),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
          break;
       case AsyncMarker.ASYNC_STAR:
         rewriter = new AsyncStarRewriter(
             reporter,
             element,
             asyncStarHelper: emitter.staticFunctionAccess(
-                getAsyncStarHelper()),
+                helpers.asyncStarHelper),
             streamOfController: emitter.staticFunctionAccess(
-                getStreamOfController()),
+                helpers.streamOfController),
             wrapBody:
-                emitter.staticFunctionAccess(getWrapBody()),
+                emitter.staticFunctionAccess(helpers.wrapBody),
             newController: emitter.staticFunctionAccess(
-                getASyncStarControllerConstructor()),
+                helpers.asyncStarControllerConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             yieldExpression: emitter.staticFunctionAccess(
-                getYieldSingle()),
+                helpers.yieldSingle),
             yieldStarExpression: emitter.staticFunctionAccess(
-                getYieldStar()),
+                helpers.yieldStar),
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       default:
         assert(element.asyncMarker == AsyncMarker.SYNC);
         return code;
     }
     return rewriter.rewrite(code);
   }
 }
 
@@ skipping 69 matching lines @@
       return false;
     });
   }
 }
 
 class JavaScriptResolutionCallbacks extends ResolutionCallbacks {
   final JavaScriptBackend backend;
 
   JavaScriptResolutionCallbacks(this.backend);
 
+  BackendImpacts get impacts => backend.impacts;
+
   WorldImpact transformImpact(ResolutionWorldImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
     for (Feature feature in worldImpact.features) {
       switch (feature) {
         case Feature.ABSTRACT_CLASS_INSTANTIATION:
-          onAbstractClassInstantiation(transformed);
+          registerBackendImpact(
+              transformed, impacts.abstractClassInstantiation);
           break;
         case Feature.ASSERT:
-          onAssert(false, transformed);
+          registerBackendImpact(transformed, impacts.assertWithoutMessage);
           break;
         case Feature.ASSERT_WITH_MESSAGE:
-          onAssert(true, transformed);
+          registerBackendImpact(transformed, impacts.assertWithMessage);
           break;
         case Feature.ASYNC:
-          backend._registerAsync(
-              backend.compiler.enqueuer.resolution, transformed);
+          registerBackendImpact(transformed, impacts.asyncBody);
           break;
         case Feature.ASYNC_FOR_IN:
-          onAsyncForIn(null, transformed);
+          registerBackendImpact(transformed, impacts.asyncForIn);
           break;
         case Feature.ASYNC_STAR:
-          backend._registerAsyncStar(
-              backend.compiler.enqueuer.resolution, transformed);
+          registerBackendImpact(transformed, impacts.asyncStarBody);
           break;
         case Feature.CATCH_STATEMENT:
-          onCatchStatement(transformed);
+          registerBackendImpact(transformed, impacts.catchStatement);
           break;
         case Feature.COMPILE_TIME_ERROR:
-          onCompileTimeError(transformed, null);
+          if (backend.compiler.generateCodeWithCompileTimeErrors) {
+            // TODO(johnniwinther): This should have its own uncatchable error.
+            registerBackendImpact(transformed, impacts.throwRuntimeError);
+          }
           break;
         case Feature.FALL_THROUGH_ERROR:
-          onFallThroughError(transformed);
+          registerBackendImpact(transformed, impacts.fallThroughError);
           break;
         case Feature.INC_DEC_OPERATION:
-          onIncDecOperation(transformed);
+          registerBackendImpact(transformed, impacts.incDecOperation);
           break;
         case Feature.LAZY_FIELD:
-          onLazyField(transformed);
-          break;
-        case Feature.NEW_SYMBOL:
-          backend.registerNewSymbol(transformed);
+          registerBackendImpact(transformed, impacts.lazyField);
           break;
         case Feature.STACK_TRACE_IN_CATCH:
-          onStackTraceInCatch(transformed);
+          registerBackendImpact(transformed, impacts.stackTraceInCatch);
           break;
         case Feature.STRING_INTERPOLATION:
-          onStringInterpolation(transformed);
+          registerBackendImpact(transformed, impacts.stringInterpolation);
           break;
         case Feature.SUPER_NO_SUCH_METHOD:
-          onSuperNoSuchMethod(transformed);
+          registerBackendImpact(transformed, impacts.superNoSuchMethod);
           break;
         case Feature.SYMBOL_CONSTRUCTOR:
-          onSymbolConstructor(transformed);
+          registerBackendImpact(transformed, impacts.symbolConstructor);
           break;
         case Feature.SYNC_FOR_IN:
-          onSyncForIn(transformed);
+          registerBackendImpact(transformed, impacts.syncForIn);
           break;
         case Feature.SYNC_STAR:
-          backend._registerSyncStar(
-              backend.compiler.enqueuer.resolution, transformed);
+          registerBackendImpact(transformed, impacts.syncStarBody);
           break;
         case Feature.THROW_EXPRESSION:
-          onThrowExpression(transformed);
+          registerBackendImpact(transformed, impacts.throwExpression);
           break;
         case Feature.THROW_NO_SUCH_METHOD:
-          onThrowNoSuchMethod(transformed);
+          registerBackendImpact(transformed, impacts.throwNoSuchMethod);
           break;
         case Feature.THROW_RUNTIME_ERROR:
-          onThrowRuntimeError(transformed);
+          registerBackendImpact(transformed, impacts.throwRuntimeError);
           break;
         case Feature.TYPE_VARIABLE_BOUNDS_CHECK:
-          onTypeVariableBoundCheck(transformed);
+          registerBackendImpact(transformed, impacts.typeVariableBoundCheck);
           break;
       }
     }
     for (DartType type in worldImpact.isChecks) {
       onIsCheck(type, transformed);
     }
-    for (DartType type in worldImpact.asCasts) {
-      onIsCheck(type, transformed);
-      onAsCheck(type, transformed);
-    }
+
+    if (worldImpact.asCasts.isNotEmpty) {
+      for (DartType type in worldImpact.asCasts) {
+        onIsCheck(type, transformed);
+      }
+      registerBackendImpact(transformed, impacts.asCheck);
+    }
+
     if (backend.compiler.enableTypeAssertions) {
       for (DartType type in worldImpact.checkedModeChecks) {
         onIsCheck(type, transformed);
       }
     }
+
     for (DartType requiredType in worldImpact.requiredTypes) {
       backend.registerRequiredType(requiredType);
     }
+
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
-      onMapLiteral(transformed, mapLiteralUse.type, mapLiteralUse.isConstant);
-    }
+      if (mapLiteralUse.isConstant) {
+        registerBackendImpact(transformed, impacts.constantMapLiteral);
+      } else {
+        transformed.registerInstantiatedType(mapLiteralUse.type);
+      }
+    }
+
     for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
       // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
       // factory constructors are registered directly.
-      transformed.registerInstantiation(listLiteralUse.type);
-    }
-    for (DartType typeLiteral in worldImpact.typeLiterals) {
-      onTypeLiteral(typeLiteral, transformed);
-      transformed.registerInstantiation(backend.compiler.coreTypes.typeType);
-      if (typeLiteral.isTypeVariable) {
-        onTypeVariableExpression(transformed, typeLiteral.element);
-      }
-    }
+      transformed.registerInstantiatedType(listLiteralUse.type);
+    }
+
+    if (worldImpact.typeLiterals.isNotEmpty) {
+      transformed.registerInstantiatedType(backend.compiler.coreTypes.typeType);
+      registerBackendImpact(transformed, impacts.typeLiteral);
+      for (DartType typeLiteral in worldImpact.typeLiterals) {
+        backend.customElementsAnalysis.registerTypeLiteral(typeLiteral);
+        if (typeLiteral.isTypedef) {
+          backend.compiler.world.allTypedefs.add(typeLiteral.element);
+        }
+        if (typeLiteral.isTypeVariable) {
+          ClassElement cls = typeLiteral.element.enclosingClass;
+          backend.rti.classesUsingTypeVariableExpression.add(cls);
+          registerBackendImpact(transformed, impacts.typeVariableExpression);
+        }
+      }
+    }
+
     for (String constSymbolName in worldImpact.constSymbolNames) {
-      backend.registerConstSymbol(constSymbolName, transformed);
-    }
+      backend.registerConstSymbol(constSymbolName);
+    }
+
     for (LocalFunctionElement closure in worldImpact.closures) {
       if (closure.computeType(backend.resolution).containsTypeVariables) {
-        backend.registerClosureWithFreeTypeVariables(
-            closure, backend.compiler.enqueuer.resolution, transformed);
+        backend.compiler.enqueuer.resolution.universe
+            .closuresWithFreeTypeVariables.add(closure);
+        registerBackendImpact(transformed, impacts.computeSignature);
       }
     }
     // TODO(johnniwinther): Remove this when dependency tracking is done on
     // the world impact itself.
     for (InterfaceType instantiatedType in worldImpact.instantiatedTypes) {
-      transformed.registerInstantiation(instantiatedType);
+      transformed.registerInstantiatedType(instantiatedType);
     }
     for (Element element in worldImpact.staticUses) {
-      transformed.registerStaticInvocation(element);
+      transformed.registerStaticUse(element);
     }
 
     return transformed;
   }
 
-  void registerBackendStaticInvocation(Element element, Registry registry) {
-    registry.registerStaticInvocation(backend.registerBackendUse(element));
+  void registerBackendImpact(TransformedWorldImpact worldImpact,
+                             BackendImpact backendImpact) {
+    for (Element staticUse in backendImpact.staticUses) {
+      assert(staticUse != null);
+      backend.registerBackendUse(staticUse);
+      worldImpact.registerStaticUse(staticUse);
+    }
+    for (InterfaceType instantiatedType in backendImpact.instantiatedTypes) {
+      backend.registerBackendUse(instantiatedType.element);
+      worldImpact.registerInstantiatedType(instantiatedType);
+    }
+    for (ClassElement cls in backendImpact.instantiatedClasses) {
+      cls.ensureResolved(backend.resolution);
+      backend.registerBackendUse(cls);
+      worldImpact.registerInstantiatedType(cls.rawType);
+    }
+    for (BackendImpact otherImpact in backendImpact.otherImpacts) {
+      registerBackendImpact(worldImpact, otherImpact);
+    }
   }
 
-  void registerBackendInstantiation(ClassElement element, Registry registry) {
-    backend.registerBackendUse(element);
-    element.ensureResolved(backend.resolution);
-    registry.registerInstantiation(element.rawType);
-  }
-
-  void onAssert(bool hasMessage, Registry registry) {
-    if (hasMessage) {
-      registerBackendStaticInvocation(backend.assertTestMethod, registry);
-      registerBackendStaticInvocation(backend.assertThrowMethod, registry);
-    } else {
-      registerBackendStaticInvocation(backend.assertHelperMethod, registry);
-    }
-  }
-
-  void onAsyncForIn(AsyncForIn node, Registry registry) {
-    registerBackendStaticInvocation(backend.getStreamIteratorConstructor(),
-                                    registry);
-  }
-
-  void onStringInterpolation(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(
-        backend.getStringInterpolationHelper(), registry);
-  }
-
-  void onCatchStatement(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getExceptionUnwrapper(), registry);
-    registerBackendInstantiation(
-        backend.jsPlainJavaScriptObjectClass, registry);
-    registerBackendInstantiation(
-        backend.jsUnknownJavaScriptObjectClass, registry);
-  }
-
-  void onThrowExpression(Registry registry) {
-    assert(registry.isForResolution);
-    // We don't know ahead of time whether we will need the throw in a
-    // statement context or an expression context, so we register both
-    // here, even though we may not need the throwExpression helper.
-    registerBackendStaticInvocation(backend.getWrapExceptionHelper(), registry);
-    registerBackendStaticInvocation(
-        backend.getThrowExpressionHelper(), registry);
-  }
-
-  void onLazyField(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getCyclicThrowHelper(), registry);
-  }
-
-  void onTypeLiteral(DartType type, Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendInstantiation(backend.typeImplementation, registry);
-    registerBackendStaticInvocation(backend.getCreateRuntimeType(), registry);
-    // TODO(ahe): Might want to register [element] as an instantiated class
-    // when reflection is used.  However, as long as we disable tree-shaking
-    // eagerly it doesn't matter.
-    if (type.isTypedef) {
-      backend.compiler.world.allTypedefs.add(type.element);
-    }
-    backend.customElementsAnalysis.registerTypeLiteral(type, registry);
-  }
-
-  void onStackTraceInCatch(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getTraceFromException(), registry);
-  }
-
-  void onSyncForIn(Registry registry) {
-    assert(registry.isForResolution);
-    // The SSA builder recognizes certain for-in loops and can generate calls to
-    // throwConcurrentModificationError.
-    registerBackendStaticInvocation(
-        backend.getCheckConcurrentModificationError(), registry);
-  }
-
-  void onTypeVariableExpression(Registry registry,
-                                TypeVariableElement variable) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getSetRuntimeTypeInfo(), registry);
-    registerBackendStaticInvocation(backend.getGetRuntimeTypeInfo(), registry);
-    backend.registerGetRuntimeTypeArgument(registry);
-    registerBackendInstantiation(backend.compiler.listClass, registry);
-    registerBackendStaticInvocation(backend.getRuntimeTypeToString(), registry);
-    registerBackendStaticInvocation(backend.getCreateRuntimeType(), registry);
-    needsInt(registry, 'Needed for accessing a type variable literal on this.');
-    ClassElement cls = variable.enclosingClass;
-    backend.rti.classesUsingTypeVariableExpression.add(cls);
-  }
-
   // TODO(johnniwinther): Maybe split this into [onAssertType] and [onTestType].
-  void onIsCheck(DartType type, Registry registry) {
-    assert(registry.isForResolution);
+  void onIsCheck(DartType type, TransformedWorldImpact transformed) {
     type = type.unalias(backend.resolution);
-    registerBackendInstantiation(backend.compiler.boolClass, registry);
+    registerBackendImpact(transformed, impacts.typeCheck);
+
     bool inCheckedMode = backend.compiler.enableTypeAssertions;
     if (inCheckedMode) {
-      registerBackendStaticInvocation(backend.getThrowRuntimeError(), registry);
+      registerBackendImpact(transformed, impacts.checkedModeTypeCheck);
     }
     if (type.isMalformed) {
-      registerBackendStaticInvocation(backend.getThrowTypeError(), registry);
+      registerBackendImpact(transformed, impacts.malformedTypeCheck);
     }
     if (!type.treatAsRaw || type.containsTypeVariables || type.isFunctionType) {
-      // TODO(johnniwinther): Investigate why this is needed.
-      registerBackendStaticInvocation(
-          backend.getSetRuntimeTypeInfo(), registry);
-      registerBackendStaticInvocation(
-          backend.getGetRuntimeTypeInfo(), registry);
-      backend.registerGetRuntimeTypeArgument(registry);
+      registerBackendImpact(transformed, impacts.genericTypeCheck);
       if (inCheckedMode) {
-        registerBackendStaticInvocation(backend.getAssertSubtype(), registry);
-      }
-      registerBackendStaticInvocation(backend.getCheckSubtype(), registry);
+        registerBackendImpact(transformed, impacts.genericCheckedModeTypeCheck);
+      }
       if (type.isTypeVariable) {
-        registerBackendStaticInvocation(
-            backend.getCheckSubtypeOfRuntimeType(), registry);
+        registerBackendImpact(transformed, impacts.typeVariableTypeCheck);
         if (inCheckedMode) {
-          registerBackendStaticInvocation(
-              backend.getAssertSubtypeOfRuntimeType(), registry);
+          registerBackendImpact(transformed,
+              impacts.typeVariableCheckedModeTypeCheck);
         }
       }
-      registerBackendInstantiation(backend.compiler.listClass, registry);
     }
     if (type is FunctionType) {
-      registerBackendStaticInvocation(
-          backend.find(backend.jsHelperLibrary, 'functionTypeTestMetaHelper'),
-          registry);
+      registerBackendImpact(transformed, impacts.functionTypeCheck);
     }
     if (type.element != null && type.element.isNative) {
-      // We will neeed to add the "$is" and "$as" properties on the
-      // JavaScript object prototype, so we make sure
-      // [:defineProperty:] is compiled.
-      registerBackendStaticInvocation(
-          backend.find(backend.jsHelperLibrary, 'defineProperty'), registry);
-    }
-  }
-
-  void onTypeVariableBoundCheck(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getThrowTypeError(), registry);
-    registerBackendStaticInvocation(backend.getAssertIsSubtype(), registry);
-  }
-
-  void onAbstractClassInstantiation(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(
-        backend.getThrowAbstractClassInstantiationError(), registry);
-    // Also register the types of the arguments passed to this method.
-    needsString(registry, '// Needed to encode the message.');
-  }
-
-  void onFallThroughError(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getFallThroughError(), registry);
-  }
-
-  void onAsCheck(DartType type, Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getThrowRuntimeError(), registry);
-  }
-
-  void onThrowNoSuchMethod(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getThrowNoSuchMethod(), registry);
-    // Also register the types of the arguments passed to this method.
-    needsList(registry,
-        'Needed to encode the arguments for throw NoSuchMethodError.');
-    needsString(registry,
-        'Needed to encode the name for throw NoSuchMethodError.');
-  }
-
-  void onThrowRuntimeError(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(backend.getThrowRuntimeError(), registry);
-    // Also register the types of the arguments passed to this method.
-    registerBackendInstantiation(backend.compiler.stringClass, registry);
-  }
-
-  void onCompileTimeError(Registry registry, ErroneousElement error) {
-    if (backend.compiler.generateCodeWithCompileTimeErrors) {
-      // TODO(johnniwinther): This should have its own uncatchable error.
-      onThrowRuntimeError(registry);
-    }
-  }
-
-  void onSuperNoSuchMethod(Registry registry) {
-    assert(registry.isForResolution);
-    registerBackendStaticInvocation(
-        backend.getCreateInvocationMirror(), registry);
-    registerBackendStaticInvocation(
-        backend.compiler.objectClass.lookupLocalMember(
-            Identifiers.noSuchMethod_),
-        registry);
-    needsInt(registry,
-        'Needed to encode the invocation kind of super.noSuchMethod.');
-    needsList(registry,
-        'Needed to encode the arguments of super.noSuchMethod.');
-    needsString(registry,
-        'Needed to encode the name of super.noSuchMethod.');
-  }
-
-  void onMapLiteral(Registry registry,
-                    DartType type,
-                    bool isConstant) {
-    assert(registry.isForResolution);
-    void enqueue(String name) {
-      Element e = backend.find(backend.jsHelperLibrary, name);
-      registerBackendInstantiation(e, registry);
-    }
-
-    if (isConstant) {
-      enqueue(JavaScriptMapConstant.DART_CLASS);
-      enqueue(JavaScriptMapConstant.DART_PROTO_CLASS);
-      enqueue(JavaScriptMapConstant.DART_STRING_CLASS);
-      enqueue(JavaScriptMapConstant.DART_GENERAL_CLASS);
-    } else {
-      registry.registerInstantiation(type);
-    }
-  }
-
-  /// Called when resolving the `Symbol` constructor.
-  void onSymbolConstructor(Registry registry) {
-    assert(registry.isForResolution);
-    // Make sure that _internals.Symbol.validated is registered.
-    assert(backend.compiler.symbolValidatedConstructor != null);
-    registerBackendStaticInvocation(
-        backend.compiler.symbolValidatedConstructor, registry);
-  }
-
-  /// Called when resolving a prefix or postfix expression.
-  void onIncDecOperation(Registry registry) {
-    needsInt(registry, 'Needed for the `+ 1` or `- 1` operation of ++/--.');
-  }
-
-  /// Helper for registering that `int` is needed.
-  void needsInt(Registry registry, String reason) {
-    // TODO(johnniwinther): Register [reason] for use in dump-info.
-    registerBackendInstantiation(backend.compiler.intClass, registry);
-  }
-
-  /// Helper for registering that `List` is needed.
-  void needsList(Registry registry, String reason) {
-    // TODO(johnniwinther): Register [reason] for use in dump-info.
-    registerBackendInstantiation(backend.compiler.listClass, registry);
-  }
-
-  /// Helper for registering that `String` is needed.
-  void needsString(Registry registry, String reason) {
-    // TODO(johnniwinther): Register [reason] for use in dump-info.
-    registerBackendInstantiation(backend.compiler.stringClass, registry);
+      registerBackendImpact(transformed, impacts.nativeTypeCheck);
+    }
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }
+