Remove ResolutionEnqueuer.isLive

sdk/lib/_internal/compiler/implementation/world.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;
 
 abstract class ClassWorld {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
@@ skipping 130 matching lines @@
     if (x == objectClass) return false;
     while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
       if (x == y) return true;
       x = x.superclass;
     }
     return false;
   }
 
   /// Returns `true` if [cls] is instantiated.
   bool isInstantiated(ClassElement cls) {
-    return compiler.enqueuer.resolution.isLive(cls);
+    return compiler.resolverWorld.isInstantiated(cls);
   }
 
   /// Returns an iterable over the live classes that extend [cls] including
   /// [cls] itself.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     Set<ClassElement> subclasses = _subclasses[cls.declaration];
     if (subclasses == null) return const <ClassElement>[];
     assert(invariant(cls, isInstantiated(cls.declaration),
         message: 'Class $cls has not been instantiated.'));
     return subclasses;
@@ skipping 216 matching lines @@
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         superclass = superclass.superclass;
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
-    compiler.resolverWorld.allInstantiatedClasses.forEach(addSubtypes);
+    compiler.resolverWorld.directlyInstantiatedClasses.forEach(addSubtypes);
   }
 
   void registerMixinUse(MixinApplicationElement mixinApplication,
                         ClassElement mixin) {
     // TODO(johnniwinther): Add map restricted to live classes.
     // We don't support patch classes as mixin.
     assert(mixin.isDeclaration);
     List<MixinApplicationElement> users =
         _mixinUses.putIfAbsent(mixin, () =>
                                new List<MixinApplicationElement>());
@@ skipping 117 matching lines @@
     // method of function classes that were generated for function
     // expressions. In such a case, we have to look at the original
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is closureMapping.SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 }