Remove Enqueuer argument from Backend.registerStaticUse

pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart

 // Copyright (c) 2013, 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.
 
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../enqueue.dart' show Enqueuer;
 import '../universe/use.dart' show StaticUse;
@@ skipping 53 matching lines @@
         codegenJoin = new CustomElementsAnalysisJoin(backend) {
     // TODO(sra): Remove this work-around.  We should mark allClassesSelected in
     // both joins only when we see a construct generating an unknown [Type] but
     // we can't currently recognize all cases.  In particular, the work-around
     // for the unimplemented `ClassMirror.reflectedType` is not recognizable.
     // TODO(12607): Match on [ClassMirror.reflectedType]
     resolutionJoin.allClassesSelected = true;
     codegenJoin.allClassesSelected = true;
   }
 
-  CustomElementsAnalysisJoin joinFor(Enqueuer enqueuer) =>
-      enqueuer.isResolutionQueue ? resolutionJoin : codegenJoin;
+  CustomElementsAnalysisJoin joinFor({bool forResolution}) =>
+      forResolution ? resolutionJoin : codegenJoin;
 
-  void registerInstantiatedClass(ClassElement classElement, Enqueuer enqueuer) {
+  void registerInstantiatedClass(ClassElement classElement,
+      {bool forResolution}) {
     classElement.ensureResolved(compiler.resolution);
     if (!backend.isNativeOrExtendsNative(classElement)) return;
     if (classElement.isMixinApplication) return;
     if (classElement.isAbstract) return;
     // JsInterop classes are opaque interfaces without a concrete
     // implementation.
     if (backend.isJsInterop(classElement)) return;
-    joinFor(enqueuer).instantiatedClasses.add(classElement);
+    joinFor(forResolution: forResolution).instantiatedClasses.add(classElement);
   }
 
   void registerTypeLiteral(DartType type) {
     if (type.isInterfaceType) {
       // TODO(sra): If we had a flow query from the type literal expression to
       // the Type argument of the metadata lookup, we could tell if this type
       // literal is really a demand for the metadata.
       resolutionJoin.selectedClasses.add(type.element);
     } else if (type.isTypeVariable) {
       // This is a type parameter of a parameterized class.
       // TODO(sra): Is there a way to determine which types are bound to the
       // parameter?
       resolutionJoin.allClassesSelected = true;
     }
   }
 
   void registerTypeConstant(Element element) {
     assert(element.isClass);
     codegenJoin.selectedClasses.add(element);
   }
 
-  void registerStaticUse(Element element, Enqueuer enqueuer) {
+  void registerStaticUse(Element element, {bool forResolution}) {
     assert(element != null);
     if (!fetchedTableAccessorMethod) {
       fetchedTableAccessorMethod = true;
       tableAccessorMethod = backend.helpers.findIndexForNativeSubclassType;
     }
     if (element == tableAccessorMethod) {
-      joinFor(enqueuer).demanded = true;
+      joinFor(forResolution: forResolution).demanded = true;
     }
   }
 
-  void onQueueEmpty(Enqueuer enqueuer) {
-    joinFor(enqueuer).flush(enqueuer);
+  /// Computes the [WorldImpact] of the classes registered since last flush.
+  WorldImpact flush({bool forResolution}) {
+    return joinFor(forResolution: forResolution).flush();
   }
 
   bool get needsTable => codegenJoin.demanded;
 
   bool needsClass(ClassElement classElement) =>
       codegenJoin.activeClasses.contains(classElement);
 
   List<Element> constructors(ClassElement classElement) =>
       codegenJoin.computeEscapingConstructors(classElement);
 }
@@ skipping 15 matching lines @@
   bool allClassesSelected = false;
 
   // Did we see a demand for the data?
   bool demanded = false;
 
   // ClassesOutput: classes requiring metadata.
   final activeClasses = new Set<ClassElement>();
 
   CustomElementsAnalysisJoin(this.backend);
 
-  void flush(Enqueuer enqueuer) {
-    if (!demanded) return;
+  WorldImpact flush() {
+    if (!demanded) return const WorldImpact();
     var newActiveClasses = new Set<ClassElement>();
     for (ClassElement classElement in instantiatedClasses) {
       bool isNative = backend.isNative(classElement);
       bool isExtension =
           !isNative && backend.isNativeOrExtendsNative(classElement);
       // Generate table entries for native classes that are explicitly named and
       // extensions that fix our criteria.
       if ((isNative && selectedClasses.contains(classElement)) ||
           (isExtension &&
               (allClassesSelected || selectedClasses.contains(classElement)))) {
         newActiveClasses.add(classElement);
         Iterable<ConstructorElement> escapingConstructors =
             computeEscapingConstructors(classElement);
         for (ConstructorElement constructor in escapingConstructors) {
-          enqueuer.registerStaticUse(new StaticUse.foreignUse(constructor));
+          impactBuilder
+              .registerStaticUse(new StaticUse.foreignUse(constructor));
         }
         escapingConstructors
             .forEach(compiler.globalDependencies.registerDependency);
         // Force the generaton of the type constant that is the key to an entry
         // in the generated table.
         ConstantValue constant = makeTypeConstant(classElement);
         backend.computeImpactForCompileTimeConstant(
             constant, impactBuilder, false);
         backend.addCompileTimeConstantForEmission(constant);
       }
     }
     activeClasses.addAll(newActiveClasses);
     instantiatedClasses.removeAll(newActiveClasses);
-    enqueuer.applyImpact(null, impactBuilder.flush());
+    return impactBuilder.flush();
   }
 
   TypeConstantValue makeTypeConstant(ClassElement element) {
     DartType elementType = element.rawType;
     return backend.constantSystem.createType(compiler, elementType);
   }
 
   List<ConstructorElement> computeEscapingConstructors(
       ClassElement classElement) {
     List<ConstructorElement> result = <ConstructorElement>[];
@@ skipping 12 matching lines @@
           result.add(member);
         }
       }
     }
 
     classElement.forEachMember(selectGenerativeConstructors,
         includeBackendMembers: false, includeSuperAndInjectedMembers: false);
     return result;
   }
 }