Move registerBackend* to BackendUsage

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 476 matching lines @@
         this.sourceInformationStrategy = generateSourceMap
             ? (useNewSourceInfo
                 ? new PositionSourceInformationStrategy()
                 : const StartEndSourceInformationStrategy())
             : const JavaScriptSourceInformationStrategy(),
         impacts = new BackendImpacts(compiler),
         frontend = new JSFrontendAccess(compiler),
         mirrorsData = new MirrorsData(compiler),
         this.compiler = compiler {
     helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
-    _backendUsage = new BackendUsage(commonElements, helpers);
+    _backendUsage = new BackendUsage(
+        commonElements, helpers, resolution, compiler.globalDependencies);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
@@ skipping 208 matching lines @@
       interceptorData.addInterceptorsForNativeClassMembers(cls);
     }
   }
 
   void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
       {bool forResolution}) {
     if (forResolution) {
       cls.ensureResolved(resolution);
       interceptorData.addInterceptors(cls);
     }
-    impactTransformer.registerBackendInstantiation(impactBuilder, cls);
+    backendUsage.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
@@ skipping 76 matching lines @@
     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) {
-        impactTransformer.registerBackendImpact(
-            impactBuilder, impacts.numClasses);
+        backendUsage.registerBackendImpact(impactBuilder, impacts.numClasses);
       } else if (cls == commonElements.listClass ||
           cls == commonElements.stringClass) {
-        impactTransformer.registerBackendImpact(
+        backendUsage.registerBackendImpact(
             impactBuilder, impacts.listOrStringClasses);
       } else if (cls == commonElements.functionClass) {
-        impactTransformer.registerBackendImpact(
+        backendUsage.registerBackendImpact(
             impactBuilder, impacts.functionClass);
       } else if (cls == commonElements.mapClass) {
-        impactTransformer.registerBackendImpact(
-            impactBuilder, impacts.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) {
-        impactTransformer.registerBackendImpact(
+        backendUsage.registerBackendImpact(
             impactBuilder, impacts.boundClosureClass);
       } else if (nativeData.isNativeOrExtendsNative(cls)) {
-        impactTransformer.registerBackendImpact(
+        backendUsage.registerBackendImpact(
             impactBuilder, impacts.nativeOrExtendsClass);
       } else if (cls == helpers.mapLiteralClass) {
-        impactTransformer.registerBackendImpact(
+        backendUsage.registerBackendImpact(
             impactBuilder, impacts.mapLiteralClass);
       }
     }
     if (cls == helpers.closureClass) {
-      impactTransformer.registerBackendImpact(
-          impactBuilder, impacts.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) {
-        impactTransformer.registerBackendImpact(
-            impactBuilder, impacts.listClasses);
+        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);
@@ skipping 32 matching lines @@
           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) {
-      impactTransformer.registerBackendImpact(
+      backendUsage.registerBackendImpact(
           impactBuilder, impacts.jsIndexingBehavior);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls,
         forResolution: forResolution);
     if (!forResolution) {
       lookupMapAnalysis.registerInstantiatedClass(cls);
     }
 
     return impactBuilder;
   }
 
   void registerInstantiatedType(ResolutionInterfaceType type) {
     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) {
-      impactTransformer.registerBackendImpact(
+      backendUsage.registerBackendImpact(
           impactBuilder, impacts.enableTypeAssertions);
     }
 
     if (TRACE_CALLS) {
-      impactTransformer.registerBackendImpact(
-          impactBuilder, impacts.traceHelper);
+      backendUsage.registerBackendImpact(impactBuilder, impacts.traceHelper);
     }
-    impactTransformer.registerBackendImpact(
+    backendUsage.registerBackendImpact(
         impactBuilder, impacts.assertUnreachable);
     _registerCheckedModeHelpers(impactBuilder);
     return impactBuilder;
   }
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
@@ skipping 23 matching lines @@
 
   WorldImpact registerClosureWithFreeTypeVariables(MethodElement closure,
       {bool forResolution}) {
     if (forResolution || methodNeedsRti(closure)) {
       return _registerComputeSignature();
     }
     return const WorldImpact();
   }
 
   WorldImpact registerBoundClosure() {
-    return impactTransformer.createImpactFor(impacts.memberClosure);
+    return backendUsage.createImpactFor(impacts.memberClosure);
   }
 
   WorldImpact registerGetOfStaticFunction() {
-    return impactTransformer.createImpactFor(impacts.staticClosure);
+    return backendUsage.createImpactFor(impacts.staticClosure);
   }
 
   WorldImpact _registerComputeSignature() {
-    return impactTransformer.createImpactFor(impacts.computeSignature);
+    return backendUsage.createImpactFor(impacts.computeSignature);
   }
 
   /// Called to register that the `runtimeType` property has been accessed. Any
   /// backend specific [WorldImpact] of this is returned.
   WorldImpact registerRuntimeType() {
-    return impactTransformer.createImpactFor(impacts.runtimeTypeSupport);
+    return backendUsage.createImpactFor(impacts.runtimeTypeSupport);
   }
 
   /// Register a runtime type variable bound tests between [typeArgument] and
   /// [bound].
   void registerTypeVariableBoundsSubtypeCheck(
       ResolutionDartType typeArgument, ResolutionDartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
   /// Returns the [WorldImpact] of enabling deferred loading.
   WorldImpact computeDeferredLoadingImpact() {
-    return impactTransformer.createImpactFor(impacts.deferredLoading);
+    return backendUsage.createImpactFor(impacts.deferredLoading);
   }
 
   /// Called to register a `noSuchMethod` implementation.
   void registerNoSuchMethod(MethodElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
@@ skipping 22 matching lines @@
         }
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   WorldImpact computeNoSuchMethodImpact() {
-    return impactTransformer.createImpactFor(impacts.noSuchMethodSupport);
+    return backendUsage.createImpactFor(impacts.noSuchMethodSupport);
   }
 
   /// Called to enable support for isolates. Any backend specific [WorldImpact]
   /// of this is returned.
   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.
       impactBuilder.registerStaticUse(
           new StaticUse.staticTearOff(compiler.mainFunction));
     }
-    impactTransformer.registerBackendImpact(
-        impactBuilder, impacts.isolateSupport);
+    backendUsage.registerBackendImpact(impactBuilder, impacts.isolateSupport);
     if (forResolution) {
-      impactTransformer.registerBackendImpact(
+      backendUsage.registerBackendImpact(
           impactBuilder, impacts.isolateSupportForResolution);
     }
     return impactBuilder;
   }
 
   bool classNeedsRti(ClassElement cls) {
     if (hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
@@ skipping 162 matching lines @@
     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);
     }
-    impactTransformer.registerBackendImpact(
+    backendUsage.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 ||
@@ skipping 30 matching lines @@
       if (compiler.options.preserveUris) mustPreserveUris = true;
     } else if (element == helpers.preserveLibraryNamesMarker) {
       mirrorsData.mustRetainLibraryNames = true;
     } else if (element == helpers.getIsolateAffinityTagMarker) {
       backendUsage.needToInitializeIsolateAffinityTag = true;
     } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (!isLoadLibraryFunctionResolved) {
         isLoadLibraryFunctionResolved = true;
         if (forResolution) {
-          impactTransformer.registerBackendImpact(
-              worldImpact, impacts.loadLibrary);
+          backendUsage.registerBackendImpact(worldImpact, impacts.loadLibrary);
         }
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     } else if (element == helpers.invokeOnMethod && forResolution) {
       hasInvokeOnSupport = true;
     }
     customElementsAnalysis.registerStaticUse(element,
         forResolution: forResolution);
 
@@ skipping 454 matching lines @@
 
   MethodElement helperForMissingMain() => helpers.missingMain;
 
   MethodElement helperForMainArity() => helpers.mainHasTooManyParameters;
 
   /// Computes the [WorldImpact] of calling [mainMethod] as the entry point.
   WorldImpact computeMainImpact(MethodElement mainMethod,
       {bool forResolution}) {
     WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
     if (mainMethod.parameters.isNotEmpty) {
-      impactTransformer.registerBackendImpact(
-          mainImpact, impacts.mainWithArguments);
+      backendUsage.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.
       mainImpact.addImpact(enableIsolateSupport(forResolution: forResolution));
     }
     mainImpact.registerStaticUse(
         new StaticUse.staticInvoke(mainMethod, CallStructure.NO_ARGS));
@@ skipping 197 matching lines @@
   }
 }
 
 class JavaScriptImpactTransformer extends ImpactTransformer {
   final JavaScriptBackend backend;
 
   JavaScriptImpactTransformer(this.backend);
 
   BackendImpacts get impacts => backend.impacts;
 
+  BackendUsage get backendUsage => backend.backendUsage;
+
   @override
   WorldImpact transformResolutionImpact(
       ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
     for (Feature feature in worldImpact.features) {
       switch (feature) {
         case Feature.ABSTRACT_CLASS_INSTANTIATION:
-          registerBackendImpact(
+          backendUsage.registerBackendImpact(
               transformed, impacts.abstractClassInstantiation);
           break;
         case Feature.ASSERT:
-          registerBackendImpact(transformed, impacts.assertWithoutMessage);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.assertWithoutMessage);
           break;
         case Feature.ASSERT_WITH_MESSAGE:
-          registerBackendImpact(transformed, impacts.assertWithMessage);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.assertWithMessage);
           break;
         case Feature.ASYNC:
-          registerBackendImpact(transformed, impacts.asyncBody);
+          backendUsage.registerBackendImpact(transformed, impacts.asyncBody);
           break;
         case Feature.ASYNC_FOR_IN:
-          registerBackendImpact(transformed, impacts.asyncForIn);
+          backendUsage.registerBackendImpact(transformed, impacts.asyncForIn);
           break;
         case Feature.ASYNC_STAR:
-          registerBackendImpact(transformed, impacts.asyncStarBody);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.asyncStarBody);
           break;
         case Feature.CATCH_STATEMENT:
-          registerBackendImpact(transformed, impacts.catchStatement);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.catchStatement);
           break;
         case Feature.COMPILE_TIME_ERROR:
           if (backend.compiler.options.generateCodeWithCompileTimeErrors) {
             // TODO(johnniwinther): This should have its own uncatchable error.
-            registerBackendImpact(transformed, impacts.throwRuntimeError);
+            backendUsage.registerBackendImpact(
+                transformed, impacts.throwRuntimeError);
           }
           break;
         case Feature.FALL_THROUGH_ERROR:
-          registerBackendImpact(transformed, impacts.fallThroughError);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.fallThroughError);
           break;
         case Feature.FIELD_WITHOUT_INITIALIZER:
         case Feature.LOCAL_WITHOUT_INITIALIZER:
           transformed.registerTypeUse(
               new TypeUse.instantiation(backend.commonElements.nullType));
-          registerBackendImpact(transformed, impacts.nullLiteral);
+          backendUsage.registerBackendImpact(transformed, impacts.nullLiteral);
           break;
         case Feature.LAZY_FIELD:
-          registerBackendImpact(transformed, impacts.lazyField);
+          backendUsage.registerBackendImpact(transformed, impacts.lazyField);
           break;
         case Feature.STACK_TRACE_IN_CATCH:
-          registerBackendImpact(transformed, impacts.stackTraceInCatch);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.stackTraceInCatch);
           break;
         case Feature.STRING_INTERPOLATION:
-          registerBackendImpact(transformed, impacts.stringInterpolation);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.stringInterpolation);
           break;
         case Feature.STRING_JUXTAPOSITION:
-          registerBackendImpact(transformed, impacts.stringJuxtaposition);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.stringJuxtaposition);
           break;
         case Feature.SUPER_NO_SUCH_METHOD:
-          registerBackendImpact(transformed, impacts.superNoSuchMethod);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.superNoSuchMethod);
           break;
         case Feature.SYMBOL_CONSTRUCTOR:
-          registerBackendImpact(transformed, impacts.symbolConstructor);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.symbolConstructor);
           break;
         case Feature.SYNC_FOR_IN:
-          registerBackendImpact(transformed, impacts.syncForIn);
+          backendUsage.registerBackendImpact(transformed, impacts.syncForIn);
           break;
         case Feature.SYNC_STAR:
-          registerBackendImpact(transformed, impacts.syncStarBody);
+          backendUsage.registerBackendImpact(transformed, impacts.syncStarBody);
           break;
         case Feature.THROW_EXPRESSION:
-          registerBackendImpact(transformed, impacts.throwExpression);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.throwExpression);
           break;
         case Feature.THROW_NO_SUCH_METHOD:
-          registerBackendImpact(transformed, impacts.throwNoSuchMethod);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.throwNoSuchMethod);
           break;
         case Feature.THROW_RUNTIME_ERROR:
-          registerBackendImpact(transformed, impacts.throwRuntimeError);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.throwRuntimeError);
           break;
         case Feature.TYPE_VARIABLE_BOUNDS_CHECK:
-          registerBackendImpact(transformed, impacts.typeVariableBoundCheck);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.typeVariableBoundCheck);
           break;
       }
     }
 
     bool hasAsCast = false;
     bool hasTypeLiteral = false;
     for (TypeUse typeUse in worldImpact.typeUses) {
       ResolutionDartType type = typeUse.type;
       switch (typeUse.kind) {
         case TypeUseKind.INSTANTIATION:
@@ skipping 19 matching lines @@
         case TypeUseKind.TYPE_LITERAL:
           backend.customElementsAnalysis.registerTypeLiteral(type);
           if (type.isTypeVariable && type is! MethodTypeVariableType) {
             // GENERIC_METHODS: The `is!` test above filters away method type
             // variables, because they have the value `dynamic` with the
             // incomplete support for generic methods offered with
             // '--generic-method-syntax'. This must be revised in order to
             // support generic methods fully.
             ClassElement cls = type.element.enclosingClass;
             backend.rti.registerClassUsingTypeVariableExpression(cls);
-            registerBackendImpact(transformed, impacts.typeVariableExpression);
+            backendUsage.registerBackendImpact(
+                transformed, impacts.typeVariableExpression);
           }
           hasTypeLiteral = true;
           break;
       }
     }
 
     if (hasAsCast) {
-      registerBackendImpact(transformed, impacts.asCheck);
+      backendUsage.registerBackendImpact(transformed, impacts.asCheck);
     }
 
     if (hasTypeLiteral) {
       transformed.registerTypeUse(
           new TypeUse.instantiation(backend.compiler.commonElements.typeType));
-      registerBackendImpact(transformed, impacts.typeLiteral);
+      backendUsage.registerBackendImpact(transformed, impacts.typeLiteral);
     }
 
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
       if (mapLiteralUse.isConstant) {
-        registerBackendImpact(transformed, impacts.constantMapLiteral);
+        backendUsage.registerBackendImpact(
+            transformed, impacts.constantMapLiteral);
       } else {
         transformed
             .registerTypeUse(new TypeUse.instantiation(mapLiteralUse.type));
       }
       ResolutionInterfaceType type = mapLiteralUse.type;
       registerRequiredType(type);
     }
 
     for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
       // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
       // factory constructors are registered directly.
       transformed
           .registerTypeUse(new TypeUse.instantiation(listLiteralUse.type));
       ResolutionInterfaceType type = listLiteralUse.type;
       registerRequiredType(type);
     }
 
     if (worldImpact.constSymbolNames.isNotEmpty) {
-      registerBackendImpact(transformed, impacts.constSymbol);
+      backendUsage.registerBackendImpact(transformed, impacts.constSymbol);
       for (String constSymbolName in worldImpact.constSymbolNames) {
         backend.mirrorsData.registerConstSymbol(constSymbolName);
       }
     }
 
     for (StaticUse staticUse in worldImpact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
-          registerBackendImpact(transformed, impacts.closure);
+          backendUsage.registerBackendImpact(transformed, impacts.closure);
           LocalFunctionElement closure = staticUse.element;
           if (closure.type.containsTypeVariables) {
-            registerBackendImpact(transformed, impacts.computeSignature);
+            backendUsage.registerBackendImpact(
+                transformed, impacts.computeSignature);
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
           registerRequiredType(staticUse.type);
           break;
         default:
       }
     }
 
     for (ConstantExpression constant in worldImpact.constantLiterals) {
       switch (constant.kind) {
         case ConstantExpressionKind.NULL:
-          registerBackendImpact(transformed, impacts.nullLiteral);
+          backendUsage.registerBackendImpact(transformed, impacts.nullLiteral);
           break;
         case ConstantExpressionKind.BOOL:
-          registerBackendImpact(transformed, impacts.boolLiteral);
+          backendUsage.registerBackendImpact(transformed, impacts.boolLiteral);
           break;
         case ConstantExpressionKind.INT:
-          registerBackendImpact(transformed, impacts.intLiteral);
+          backendUsage.registerBackendImpact(transformed, impacts.intLiteral);
           break;
         case ConstantExpressionKind.DOUBLE:
-          registerBackendImpact(transformed, impacts.doubleLiteral);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.doubleLiteral);
           break;
         case ConstantExpressionKind.STRING:
-          registerBackendImpact(transformed, impacts.stringLiteral);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.stringLiteral);
           break;
         default:
           assert(invariant(NO_LOCATION_SPANNABLE, false,
               message: "Unexpected constant literal: ${constant.kind}."));
       }
     }
 
     for (native.NativeBehavior behavior in worldImpact.nativeData) {
       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.backendUsage.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.backendUsage.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);
-      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 (ResolutionInterfaceType instantiatedType
-        in backendImpact.instantiatedTypes) {
-      backend.backendUsage.registerBackendUse(instantiatedType.element);
-      worldImpact.registerTypeUse(new TypeUse.instantiation(instantiatedType));
-    }
-    for (ClassElement cls in backendImpact.instantiatedClasses) {
-      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.backendUsage.needToInitializeDispatchProperty = true;
-          break;
-        case BackendFeature.needToInitializeIsolateAffinityTag:
-          backend.backendUsage.needToInitializeIsolateAffinityTag = true;
-          break;
-      }
-    }
-  }
-
   /// Register [type] as required for the runtime type information system.
   void registerRequiredType(ResolutionDartType type) {
     if (!type.isInterfaceType) return;
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
     // defined (that is the enclosing class of the current element being
     // resolved) and the class of [type]. If the class of [type] requires RTI,
     // then the class of the type variable does too.
     ClassElement contextClass = Types.getClassContext(type);
     if (contextClass != null) {
       backend.rti.registerRtiDependency(type.element, contextClass);
     }
   }
 
   // TODO(johnniwinther): Maybe split this into [onAssertType] and [onTestType].
   void onIsCheck(ResolutionDartType type, TransformedWorldImpact transformed) {
     registerRequiredType(type);
     type.computeUnaliased(backend.resolution);
     type = type.unaliased;
-    registerBackendImpact(transformed, impacts.typeCheck);
+    backendUsage.registerBackendImpact(transformed, impacts.typeCheck);
 
     bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
     if (inCheckedMode) {
-      registerBackendImpact(transformed, impacts.checkedModeTypeCheck);
+      backendUsage.registerBackendImpact(
+          transformed, impacts.checkedModeTypeCheck);
     }
     if (type.isMalformed) {
-      registerBackendImpact(transformed, impacts.malformedTypeCheck);
+      backendUsage.registerBackendImpact(
+          transformed, impacts.malformedTypeCheck);
     }
     if (!type.treatAsRaw || type.containsTypeVariables || type.isFunctionType) {
-      registerBackendImpact(transformed, impacts.genericTypeCheck);
+      backendUsage.registerBackendImpact(transformed, impacts.genericTypeCheck);
       if (inCheckedMode) {
-        registerBackendImpact(transformed, impacts.genericCheckedModeTypeCheck);
+        backendUsage.registerBackendImpact(
+            transformed, impacts.genericCheckedModeTypeCheck);
       }
       if (type.isTypeVariable) {
-        registerBackendImpact(transformed, impacts.typeVariableTypeCheck);
+        backendUsage.registerBackendImpact(
+            transformed, impacts.typeVariableTypeCheck);
         if (inCheckedMode) {
-          registerBackendImpact(
+          backendUsage.registerBackendImpact(
               transformed, impacts.typeVariableCheckedModeTypeCheck);
         }
       }
     }
     if (type is ResolutionFunctionType) {
-      registerBackendImpact(transformed, impacts.functionTypeCheck);
+      backendUsage.registerBackendImpact(
+          transformed, impacts.functionTypeCheck);
     }
     if (type.element != null && backend.isNative(type.element)) {
-      registerBackendImpact(transformed, impacts.nativeTypeCheck);
+      backendUsage.registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
 
   void onIsCheckForCodegen(
       ResolutionDartType type, TransformedWorldImpact transformed) {
     if (type.isDynamic) return;
     type = type.unaliased;
-    registerBackendImpact(transformed, impacts.typeCheck);
+    backendUsage.registerBackendImpact(transformed, impacts.typeCheck);
 
     bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       // All helpers are added to resolution queue in enqueueHelpers. These
       // calls to [enqueue] with the resolution enqueuer serve as assertions
       // that the helper was in fact added.
       // TODO(13155): Find a way to enqueue helpers lazily.
       CheckedModeHelper helper = backend.checkedModeHelpers
           .getCheckedModeHelper(type, typeCast: false);
       if (helper != null) {
         StaticUse staticUse = helper.getStaticUse(backend.helpers);
         transformed.registerStaticUse(staticUse);
         backend.backendUsage.registerBackendUse(staticUse.element);
       }
       // We also need the native variant of the check (for DOM types).
       helper = backend.checkedModeHelpers
           .getNativeCheckedModeHelper(type, typeCast: false);
       if (helper != null) {
         StaticUse staticUse = helper.getStaticUse(backend.helpers);
         transformed.registerStaticUse(staticUse);
         backend.backendUsage.registerBackendUse(staticUse.element);
       }
     }
     if (!type.treatAsRaw || type.containsTypeVariables) {
-      registerBackendImpact(transformed, impacts.genericIsCheck);
+      backendUsage.registerBackendImpact(transformed, impacts.genericIsCheck);
     }
     if (type.element != null && backend.isNative(type.element)) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
-      registerBackendImpact(transformed, impacts.nativeTypeCheck);
+      backendUsage.registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
 
   @override
   WorldImpact transformCodegenImpact(CodegenImpact impact) {
     TransformedWorldImpact transformed = new TransformedWorldImpact(impact);
 
     for (TypeUse typeUse in impact.typeUses) {
       ResolutionDartType type = typeUse.type;
       switch (typeUse.kind) {
@@ skipping 15 matching lines @@
     for (Pair<ResolutionDartType, ResolutionDartType> check
         in impact.typeVariableBoundsSubtypeChecks) {
       backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
     }
 
     for (StaticUse staticUse in impact.staticUses) {
       switch (staticUse.kind) {
         case StaticUseKind.CLOSURE:
           LocalFunctionElement closure = staticUse.element;
           if (backend.methodNeedsRti(closure)) {
-            registerBackendImpact(transformed, impacts.computeSignature);
+            backendUsage.registerBackendImpact(
+                transformed, impacts.computeSignature);
           }
           break;
         case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         case StaticUseKind.CONSTRUCTOR_INVOKE:
           backend.lookupMapAnalysis.registerInstantiatedType(staticUse.type);
           break;
         default:
       }
     }
 
     for (String name in impact.constSymbols) {
       backend.mirrorsData.registerConstSymbol(name);
     }
 
     for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
       backend.interceptorData
           .registerSpecializedGetInterceptor(classes, backend.namer);
     }
 
     if (impact.usesInterceptor) {
       if (backend.codegenEnqueuer.nativeEnqueuer.hasInstantiatedNativeClasses) {
-        registerBackendImpact(transformed, impacts.interceptorUse);
+        backendUsage.registerBackendImpact(transformed, impacts.interceptorUse);
       }
     }
 
     for (ClassElement element in impact.typeConstants) {
       backend.customElementsAnalysis.registerTypeConstant(element);
       backend.lookupMapAnalysis.registerTypeConstant(element);
     }
 
     for (FunctionElement element in impact.asyncMarkers) {
       switch (element.asyncMarker) {
         case AsyncMarker.ASYNC:
-          registerBackendImpact(transformed, impacts.asyncBody);
+          backendUsage.registerBackendImpact(transformed, impacts.asyncBody);
           break;
         case AsyncMarker.SYNC_STAR:
-          registerBackendImpact(transformed, impacts.syncStarBody);
+          backendUsage.registerBackendImpact(transformed, impacts.syncStarBody);
           break;
         case AsyncMarker.ASYNC_STAR:
-          registerBackendImpact(transformed, impacts.asyncStarBody);
+          backendUsage.registerBackendImpact(
+              transformed, impacts.asyncStarBody);
           break;
       }
     }
 
     // TODO(johnniwinther): Remove eager registration.
     return transformed;
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
@@ skipping 128 matching lines @@
   }
 
   @override
   FieldEntity get symbolField => helpers.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
     return _env.getRawType(helpers.symbolImplementationClass);
   }
 }