Remove ResolutionEnqueuer.isLive

sdk/lib/_internal/compiler/implementation/enqueue.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 dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 22 matching lines @@
 }
 
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final ItemCompilationContextCreator itemCompilationContextCreator;
   final Map<String, Set<Element>> instanceMembersByName
       = new Map<String, Set<Element>>();
   final Map<String, Set<Element>> instanceFunctionsByName
       = new Map<String, Set<Element>>();
-  final Set<ClassElement> _seenClasses = new Set<ClassElement>();
+  final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> recentClasses = new Setlet<ClassElement>();
   final Universe universe = new Universe();
 
   static final TRACE_MIRROR_ENQUEUING =
       const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
 
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer;  // Set by EnqueueTask
 
@@ skipping 30 matching lines @@
    */
   bool internalAddToWorkList(Element element);
 
   void registerInstantiatedType(InterfaceType type, Registry registry,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       registry.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.registerTypeInstantiation(type, byMirrors: mirrorUsage);
-      onRegisterInstantiatedClass(cls);
+      processInstantiatedClass(cls);
     });
   }
 
   void registerInstantiatedClass(ClassElement cls, Registry registry,
                                  {bool mirrorUsage: false}) {
     cls.ensureResolved(compiler);
     registerInstantiatedType(cls.rawType, registry, mirrorUsage: mirrorUsage);
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
 
-  void processInstantiatedClass(ClassElement cls) {
+  void processInstantiatedClassMembers(ClassElement cls) {
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
     if (!member.isInstanceMember) return;
 
     String memberName = member.name;
 
@@ skipping 88 matching lines @@
 
     // The element is not yet used. Add it to the list of instance
     // members to still be processed.
     instanceMembersByName.putIfAbsent(memberName, () => new Set<Element>())
         .add(member);
   }
 
   void enableNoSuchMethod(Element element) {}
   void enableIsolateSupport() {}
 
-  void onRegisterInstantiatedClass(ClassElement cls) {
+  void processInstantiatedClass(ClassElement cls) {
     task.measure(() {
-      if (_seenClasses.contains(cls)) return;
+      if (_processedClasses.contains(cls)) return;
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(compiler);
 
       void processClass(ClassElement cls) {
-        if (_seenClasses.contains(cls)) return;
+        if (_processedClasses.contains(cls)) return;
 
-        _seenClasses.add(cls);
+        _processedClasses.add(cls);
         recentClasses.add(cls);
         cls.ensureResolved(compiler);
         cls.implementation.forEachMember(processInstantiatedClassMember);
         if (isResolutionQueue) {
           compiler.resolver.checkClass(cls);
         }
         // We only tell the backend once that [cls] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
         compiler.backend.registerInstantiatedClass(
@@ skipping 165 matching lines @@
   /// annotation or, in lack thereof, all elements.
   void enqueueReflectiveElements(Iterable<ClassElement> recents) {
     if (!hasEnqueuedReflectiveElements) {
       logEnqueueReflectiveAction("!START enqueueAll");
       // First round of enqueuing, visit everything that is visible to
       // also pick up static top levels, etc.
       // Also, during the first round, consider all classes that have been seen
       // as recently seen, as we do not know how many rounds of resolution might
       // have run before tree shaking is disabled and thus everything is
       // enqueued.
-      recents = _seenClasses.toSet();
+      recents = _processedClasses.toSet();
       compiler.log('Enqueuing everything');
       for (LibraryElement lib in compiler.libraryLoader.libraries) {
         enqueueReflectiveElementsInLibrary(lib, recents);
       }
       enqueueReflectiveSpecialClasses();
       hasEnqueuedReflectiveElements = true;
       hasEnqueuedReflectiveStaticFields = true;
       logEnqueueReflectiveAction("!DONE enqueueAll");
     } else if (recents.isNotEmpty) {
       // Keep looking at new classes until fixpoint is reached.
@@ skipping 208 matching lines @@
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
   void _logSpecificSummary(log(message));
 
   String toString() => 'Enqueuer($name)';
 
   void forgetElement(Element element) {
     universe.forgetElement(element, compiler);
-    _seenClasses.remove(element);
+    _processedClasses.remove(element);
   }
 }
 
 /// [Enqueuer] which is specific to resolution.
 class ResolutionEnqueuer extends Enqueuer {
   /**
    * Map from declaration elements to the [TreeElements] object holding the
    * resolution mapping for the element implementation.
    *
    * Invariant: Key elements are declaration elements.
@@ skipping 22 matching lines @@
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
   bool hasBeenResolved(Element element) {
     return resolvedElements.contains(element.analyzableElement.declaration);
   }
 
   /// Registers [element] as resolved for the resolution enqueuer.
   void registerResolvedElement(AstElement element) {
     resolvedElements.add(element);
   }
 
-  /// Returns [:true:] if [element] has actually been used.
-  bool isLive(Element element) {
-    if (_seenClasses.contains(element)) return true;
-    if (hasBeenResolved(element)) return true;
-    return false;
-  }
-
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system.
    *
    * During resolution, we have to resort to matching elements against the
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
                                         {bool includedEnclosing}) {
@@ skipping 179 matching lines @@
       }
     }
   }
 }
 
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
     enqueuer.task.measure(() {
       // Run through the classes and see if we need to compile methods.
-      for (ClassElement classElement in enqueuer.universe.instantiatedClasses) {
+      for (ClassElement classElement in
+               enqueuer.universe.directlyInstantiatedClasses) {
         for (ClassElement currentClass = classElement;
              currentClass != null;
              currentClass = currentClass.superclass) {
-          enqueuer.processInstantiatedClass(currentClass);
+          enqueuer.processInstantiatedClassMembers(currentClass);
         }
       }
     });
     return true;
   }
 
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }