Extract BackendUsageBuilder from 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 443 matching lines @@
   JavaScriptBackendSerialization serialization;
 
   StagedWorldImpactBuilder constantImpactsForResolution =
       new StagedWorldImpactBuilder();
 
   StagedWorldImpactBuilder constantImpactsForCodegen =
       new StagedWorldImpactBuilder();
 
   final NativeData nativeData = new NativeData();
   InterceptorData _interceptorData;
-  BackendUsage _backendUsage;
+  BackendUsageImpl _backendUsage;
   final MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   BackendHelpers helpers;
   final BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
 
   /// Backend access to the front-end.
@@ skipping 12 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, resolution);
+    _backendUsage = new BackendUsageImpl(commonElements, helpers, resolution);
     _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 16 matching lines @@
   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;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   @override
   bool isDefaultNoSuchMethod(MethodElement element) {
@@ skipping 172 matching lines @@
       interceptorData.addInterceptorsForNativeClassMembers(cls);
     }
   }
 
   void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
       {bool forResolution}) {
     if (forResolution) {
       cls.ensureResolved(resolution);
       interceptorData.addInterceptors(cls);
     }
-    backendUsage.registerBackendInstantiation(impactBuilder, 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
@@ skipping 25 matching lines @@
       InterceptorConstantValue interceptor = constant;
       ClassElement cls = interceptor.cls;
       computeImpactForInstantiatedConstantType(cls.thisType, impactBuilder);
     } else if (constant.isType) {
       if (isForResolution) {
         MethodElement helper = helpers.createRuntimeType;
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             helper,
             null));
-        backendUsage.registerBackendUse(helper);
+        backendUsageBuilder.registerBackendUse(helper);
       }
       impactBuilder
           .registerTypeUse(new TypeUse.instantiation(backendClasses.typeType));
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
 
   void computeImpactForInstantiatedConstantType(
       DartType type, WorldImpactBuilder impactBuilder) {
     if (type is ResolutionInterfaceType) {
@@ skipping 30 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) {
-        backendUsage.registerBackendImpact(impactBuilder, impacts.numClasses);
+        backendUsageBuilder.registerBackendImpact(
+            impactBuilder, impacts.numClasses);
       } else if (cls == commonElements.listClass ||
           cls == commonElements.stringClass) {
-        backendUsage.registerBackendImpact(
+        backendUsageBuilder.registerBackendImpact(
             impactBuilder, impacts.listOrStringClasses);
       } else if (cls == commonElements.functionClass) {
-        backendUsage.registerBackendImpact(
+        backendUsageBuilder.registerBackendImpact(
             impactBuilder, impacts.functionClass);
       } else if (cls == commonElements.mapClass) {
-        backendUsage.registerBackendImpact(impactBuilder, impacts.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) {
-        backendUsage.registerBackendImpact(
+        backendUsageBuilder.registerBackendImpact(
             impactBuilder, impacts.boundClosureClass);
       } else if (nativeData.isNativeOrExtendsNative(cls)) {
-        backendUsage.registerBackendImpact(
+        backendUsageBuilder.registerBackendImpact(
             impactBuilder, impacts.nativeOrExtendsClass);
       } else if (cls == helpers.mapLiteralClass) {
-        backendUsage.registerBackendImpact(
+        backendUsageBuilder.registerBackendImpact(
             impactBuilder, impacts.mapLiteralClass);
       }
     }
     if (cls == helpers.closureClass) {
-      backendUsage.registerBackendImpact(impactBuilder, impacts.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) {
-        backendUsage.registerBackendImpact(impactBuilder, impacts.listClasses);
+        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);
@@ 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) {
-      backendUsage.registerBackendImpact(
+      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) {
-      backendUsage.registerGlobalDependency(type.element);
+      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) {
-      backendUsage.registerBackendImpact(
+      backendUsageBuilder.registerBackendImpact(
           impactBuilder, impacts.enableTypeAssertions);
     }
 
     if (TRACE_CALLS) {
-      backendUsage.registerBackendImpact(impactBuilder, impacts.traceHelper);
+      backendUsageBuilder.registerBackendImpact(
+          impactBuilder, impacts.traceHelper);
     }
-    backendUsage.registerBackendImpact(
+    backendUsageBuilder.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 backendUsage.createImpactFor(impacts.memberClosure);
+    return backendUsageBuilder.createImpactFor(impacts.memberClosure);
   }
 
   WorldImpact registerGetOfStaticFunction() {
-    return backendUsage.createImpactFor(impacts.staticClosure);
+    return backendUsageBuilder.createImpactFor(impacts.staticClosure);
   }
 
   WorldImpact _registerComputeSignature() {
-    return backendUsage.createImpactFor(impacts.computeSignature);
+    return backendUsageBuilder.createImpactFor(impacts.computeSignature);
   }
 
   /// 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);
+    return backendUsageBuilder.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 backendUsage.createImpactFor(impacts.deferredLoading);
+    return backendUsageBuilder.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 backendUsage.createImpactFor(impacts.noSuchMethodSupport);
+    return backendUsageBuilder.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));
     }
-    backendUsage.registerBackendImpact(impactBuilder, impacts.isolateSupport);
+    backendUsageBuilder.registerBackendImpact(
+        impactBuilder, impacts.isolateSupport);
     if (forResolution) {
-      backendUsage.registerBackendImpact(
+      backendUsageBuilder.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);
     }
-    backendUsage.registerBackendImpact(
+    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 ||
@@ skipping 13 matching lines @@
     // 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 == helpers.getIsolateAffinityTagMarker) {
-      backendUsage.needToInitializeIsolateAffinityTag = true;
     } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (!isLoadLibraryFunctionResolved) {
         isLoadLibraryFunctionResolved = true;
         if (forResolution) {
-          backendUsage.registerBackendImpact(worldImpact, impacts.loadLibrary);
+          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);
 
@@ 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) {
-      backendUsage.registerBackendImpact(mainImpact, impacts.mainWithArguments);
+      backendUsageBuilder.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;
+  BackendUsageBuilder get backendUsage => backend.backendUsageBuilder;
 
   @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:
           backendUsage.registerBackendImpact(
@@ skipping 286 matching lines @@
     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);
+        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);
+        backendUsage.registerBackendUse(staticUse.element);
       }
     }
     if (!type.treatAsRaw || type.containsTypeVariables) {
       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.
       backendUsage.registerBackendImpact(transformed, impacts.nativeTypeCheck);
@@ skipping 216 matching lines @@
   }
 
   @override
   FieldEntity get symbolField => helpers.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
     return _env.getRawType(helpers.symbolImplementationClass);
   }
 }