Use entity WorldImpl where possible

pkg/compiler/lib/src/world.dart

Index: pkg/compiler/lib/src/world.dart
diff --git a/pkg/compiler/lib/src/world.dart b/pkg/compiler/lib/src/world.dart
index 95e60a74b965aad2f278834384be6ec1c0cb56fd..7f29d27c8a5a8a9e458b1e30651c3c9655bf4947 100644
--- a/pkg/compiler/lib/src/world.dart
+++ b/pkg/compiler/lib/src/world.dart
@@ -397,7 +397,7 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   final Iterable<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
-  Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
+  Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
   final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
 
@@ -406,8 +406,8 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
   final Map<ClassEntity, ClassSet> _classSets;
 
-  final Map<ClassElement, Map<ClassElement, bool>> _subtypeCoveredByCache =
-      <ClassElement, Map<ClassElement, bool>>{};
+  final Map<ClassEntity, Map<ClassEntity, bool>> _subtypeCoveredByCache =
+      <ClassEntity, Map<ClassEntity, bool>>{};
 
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
@@ -425,8 +425,6 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   final ResolutionWorldBuilder _resolverWorld;
 
-  bool get isClosed => true;
-
   ClosedWorldImpl(
       {JavaScriptBackend backend,
       this.commonElements,
@@ -455,24 +453,25 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
-  final List<Map<ClassElement, TypeMask>> _canonicalizedTypeMasks =
-      new List<Map<ClassElement, TypeMask>>.filled(8, null);
+  final List<Map<ClassEntity, TypeMask>> _canonicalizedTypeMasks =
+      new List<Map<ClassEntity, TypeMask>>.filled(8, null);
 
   FunctionSet get allFunctions => _allFunctions;
 
   CommonMasks get commonMasks {
-    assert(isClosed);
     return _commonMasks;
   }
 
   ConstantSystem get constantSystem => _backend.constantSystem;
 
-  TypeMask getCachedMask(ClassElement base, int flags, TypeMask createMask()) {
-    Map<ClassElement, TypeMask> cachedMasks =
-        _canonicalizedTypeMasks[flags] ??= <ClassElement, TypeMask>{};
+  TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
+    Map<ClassEntity, TypeMask> cachedMasks =
+        _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
+  bool _checkClass(ClassElement cls) => cls.isDeclaration;
+
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
@@ -489,7 +488,6 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassElement x, ClassElement y) {
-    assert(isClosed);
     assert(checkInvariants(x));
     assert(checkInvariants(y, mustBeInstantiated: false));
 
@@ -502,7 +500,6 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Return `true` if [x] is a (non-strict) subclass of [y].
   bool isSubclassOf(ClassElement x, ClassElement y) {
-    assert(isClosed);
     assert(checkInvariants(x));
     assert(checkInvariants(y));
 
@@ -516,65 +513,64 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   }
 
   @override
-  bool isInstantiated(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+  bool isInstantiated(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
 
   @override
-  bool isDirectlyInstantiated(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+  bool isDirectlyInstantiated(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isDirectlyInstantiated;
   }
 
   @override
-  bool isAbstractlyInstantiated(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+  bool isAbstractlyInstantiated(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isAbstractlyInstantiated;
   }
 
   @override
-  bool isExplicitlyInstantiated(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+  bool isExplicitlyInstantiated(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isExplicitlyInstantiated;
   }
 
   @override
-  bool isIndirectlyInstantiated(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+  bool isIndirectlyInstantiated(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isIndirectlyInstantiated;
   }
 
   @override
-  bool isAbstract(ClassElement cls) => cls.isAbstract;
+  bool isAbstract(ClassEntity cls) => cls.isAbstract;
 
   /// Returns `true` if [cls] is implemented by an instantiated class.
-  bool isImplemented(ClassElement cls) {
-    assert(isClosed);
+  bool isImplemented(ClassEntity cls) {
     return _resolverWorld.isImplemented(cls);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
-  Iterable<ClassElement> subclassesOf(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
-    if (hierarchy == null) return const <ClassElement>[];
+  Iterable<ClassEntity> subclassesOf(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode hierarchy = _classHierarchyNodes[cls];
+    if (hierarchy == null) return const <ClassEntity>[];
     return hierarchy
         .subclassesByMask(ClassHierarchyNode.EXPLICITLY_INSTANTIATED);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] _not_ including [cls] itself.
-  Iterable<ClassElement> strictSubclassesOf(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
-    if (subclasses == null) return const <ClassElement>[];
+  Iterable<ClassEntity> strictSubclassesOf(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode subclasses = _classHierarchyNodes[cls];
+    if (subclasses == null) return const <ClassEntity>[];
     return subclasses.subclassesByMask(
         ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
         strict: true);
@@ -582,9 +578,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns the number of live classes that extend [cls] _not_
   /// including [cls] itself.
-  int strictSubclassCount(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
+  int strictSubclassCount(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode subclasses = _classHierarchyNodes[cls];
     if (subclasses == null) return 0;
     return subclasses.instantiatedSubclassCount;
   }
@@ -592,9 +588,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   /// Applies [f] to each live class that extend [cls] _not_ including [cls]
   /// itself.
   void forEachStrictSubclassOf(
-      ClassElement cls, IterationStep f(ClassElement cls)) {
-    assert(isClosed);
-    ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
+      ClassEntity cls, IterationStep f(ClassEntity cls)) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode subclasses = _classHierarchyNodes[cls];
     if (subclasses == null) return;
     subclasses.forEachSubclass(f, ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
         strict: true);
@@ -602,9 +598,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
-  bool anyStrictSubclassOf(ClassElement cls, bool predicate(ClassElement cls)) {
-    assert(isClosed);
-    ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
+  bool anyStrictSubclassOf(ClassEntity cls, bool predicate(ClassEntity cls)) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode subclasses = _classHierarchyNodes[cls];
     if (subclasses == null) return false;
     return subclasses.anySubclass(
         predicate, ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
@@ -613,11 +609,11 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// possibly including [cls] itself, if it is live.
-  Iterable<ClassElement> subtypesOf(ClassElement cls) {
-    assert(isClosed);
-    ClassSet classSet = _classSets[cls.declaration];
+  Iterable<ClassEntity> subtypesOf(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) {
-      return const <ClassElement>[];
+      return const <ClassEntity>[];
     } else {
       return classSet
           .subtypesByMask(ClassHierarchyNode.EXPLICITLY_INSTANTIATED);
@@ -626,11 +622,11 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// _not_ including [cls].
-  Iterable<ClassElement> strictSubtypesOf(ClassElement cls) {
-    assert(isClosed);
-    ClassSet classSet = _classSets[cls.declaration];
+  Iterable<ClassEntity> strictSubtypesOf(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) {
-      return const <ClassElement>[];
+      return const <ClassEntity>[];
     } else {
       return classSet.subtypesByMask(ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
           strict: true);
@@ -639,9 +635,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns the number of live classes that implement [cls] _not_
   /// including [cls] itself.
-  int strictSubtypeCount(ClassElement cls) {
-    assert(isClosed);
-    ClassSet classSet = _classSets[cls.declaration];
+  int strictSubtypeCount(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) return 0;
     return classSet.instantiatedSubtypeCount;
   }
@@ -649,9 +645,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   /// Applies [f] to each live class that implements [cls] _not_ including [cls]
   /// itself.
   void forEachStrictSubtypeOf(
-      ClassElement cls, IterationStep f(ClassElement cls)) {
-    assert(isClosed);
-    ClassSet classSet = _classSets[cls.declaration];
+      ClassEntity cls, IterationStep f(ClassEntity cls)) {
+    assert(_checkClass(cls));
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) return;
     classSet.forEachSubtype(f, ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
         strict: true);
@@ -659,9 +655,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
-  bool anyStrictSubtypeOf(ClassElement cls, bool predicate(ClassElement cls)) {
-    assert(isClosed);
-    ClassSet classSet = _classSets[cls.declaration];
+  bool anyStrictSubtypeOf(ClassEntity cls, bool predicate(ClassEntity cls)) {
+    assert(_checkClass(cls));
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) return false;
     return classSet.anySubtype(
         predicate, ClassHierarchyNode.EXPLICITLY_INSTANTIATED,
@@ -669,14 +665,15 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   }
 
   /// Returns `true` if [a] and [b] have any known common subtypes.
-  bool haveAnyCommonSubtypes(ClassElement a, ClassElement b) {
-    assert(isClosed);
-    ClassSet classSetA = _classSets[a.declaration];
-    ClassSet classSetB = _classSets[b.declaration];
+  bool haveAnyCommonSubtypes(ClassEntity a, ClassEntity b) {
+    assert(_checkClass(a));
+    assert(_checkClass(b));
+    ClassSet classSetA = _classSets[a];
+    ClassSet classSetB = _classSets[b];
     if (classSetA == null || classSetB == null) return false;
     // TODO(johnniwinther): Implement an optimized query on [ClassSet].
-    Set<ClassElement> subtypesOfB = classSetB.subtypes().toSet();
-    for (ClassElement subtypeOfA in classSetA.subtypes()) {
+    Set<ClassEntity> subtypesOfB = classSetB.subtypes().toSet();
+    for (ClassEntity subtypeOfA in classSetA.subtypes()) {
       if (subtypesOfB.contains(subtypeOfA)) {
         return true;
       }
@@ -686,26 +683,26 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns `true` if any directly instantiated class other than [cls] extends
   /// [cls].
-  bool hasAnyStrictSubclass(ClassElement cls) {
-    assert(isClosed);
-    ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
+  bool hasAnyStrictSubclass(ClassEntity cls) {
+    assert(_checkClass(cls));
+    ClassHierarchyNode subclasses = _classHierarchyNodes[cls];
     if (subclasses == null) return false;
     return subclasses.isIndirectlyInstantiated;
   }
 
   /// Returns `true` if any directly instantiated class other than [cls]
   /// implements [cls].
-  bool hasAnyStrictSubtype(ClassElement cls) {
+  bool hasAnyStrictSubtype(ClassEntity cls) {
     return strictSubtypeCount(cls) > 0;
   }
 
   /// Returns `true` if all directly instantiated classes that implement [cls]
   /// extend it.
-  bool hasOnlySubclasses(ClassElement cls) {
-    assert(isClosed);
+  bool hasOnlySubclasses(ClassEntity cls) {
+    assert(_checkClass(cls));
     // TODO(johnniwinther): move this to ClassSet?
     if (cls == commonElements.objectClass) return true;
-    ClassSet classSet = _classSets[cls.declaration];
+    ClassSet classSet = _classSets[cls];
     if (classSet == null) {
       // Vacuously true.
       return true;
@@ -714,30 +711,29 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   }
 
   @override
-  ClassElement getLubOfInstantiatedSubclasses(ClassElement cls) {
-    assert(isClosed);
+  ClassEntity getLubOfInstantiatedSubclasses(ClassEntity cls) {
+    assert(_checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return _backend.helpers.jsJavaScriptObjectClass;
     }
-    ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
+    ClassHierarchyNode hierarchy = _classHierarchyNodes[cls];
     return hierarchy != null
         ? hierarchy.getLubOfInstantiatedSubclasses()
         : null;
   }
 
   @override
-  ClassElement getLubOfInstantiatedSubtypes(ClassElement cls) {
-    assert(isClosed);
+  ClassEntity getLubOfInstantiatedSubtypes(ClassEntity cls) {
+    assert(_checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return _backend.helpers.jsJavaScriptObjectClass;
     }
-    ClassSet classSet = _classSets[cls.declaration];
+    ClassSet classSet = _classSets[cls];
     return classSet != null ? classSet.getLubOfInstantiatedSubtypes() : null;
   }
 
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes) {
-    assert(isClosed);
     Iterator<ClassElement> iterator = classes.iterator;
     if (!iterator.moveNext()) return const <ClassElement>[];
 
@@ -777,13 +773,13 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
     return commonSupertypes;
   }
 
-  Iterable<ClassElement> commonSubclasses(ClassElement cls1, ClassQuery query1,
-      ClassElement cls2, ClassQuery query2) {
+  Iterable<ClassEntity> commonSubclasses(ClassEntity cls1, ClassQuery query1,
+      ClassEntity cls2, ClassQuery query2) {
     // TODO(johnniwinther): Use [ClassSet] to compute this.
     // Compute the set of classes that are contained in both class subsets.
     Set<ClassEntity> common =
         _commonContainedClasses(cls1, query1, cls2, query2);
-    if (common == null || common.isEmpty) return const <ClassElement>[];
+    if (common == null || common.isEmpty) return const <ClassEntity>[];
     // Narrow down the candidates by only looking at common classes
     // that do not have a superclass or supertype that will be a
     // better candidate.
@@ -808,16 +804,16 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
     });
   }
 
-  Set<ClassElement> _commonContainedClasses(ClassElement cls1,
-      ClassQuery query1, ClassElement cls2, ClassQuery query2) {
-    Iterable<ClassElement> xSubset = _containedSubset(cls1, query1);
+  Set<ClassEntity> _commonContainedClasses(ClassEntity cls1, ClassQuery query1,
+      ClassEntity cls2, ClassQuery query2) {
+    Iterable<ClassEntity> xSubset = _containedSubset(cls1, query1);
     if (xSubset == null) return null;
-    Iterable<ClassElement> ySubset = _containedSubset(cls2, query2);
+    Iterable<ClassEntity> ySubset = _containedSubset(cls2, query2);
     if (ySubset == null) return null;
     return xSubset.toSet().intersection(ySubset.toSet());
   }
 
-  Iterable<ClassElement> _containedSubset(ClassElement cls, ClassQuery query) {
+  Iterable<ClassEntity> _containedSubset(ClassEntity cls, ClassQuery query) {
     switch (query) {
       case ClassQuery.EXACT:
         return null;
@@ -830,12 +826,11 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
-  Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls) {
-    assert(isClosed);
+  Iterable<ClassEntity> mixinUsesOf(ClassEntity cls) {
     if (_liveMixinUses == null) {
-      _liveMixinUses = new Map<ClassElement, List<MixinApplicationElement>>();
+      _liveMixinUses = new Map<ClassEntity, List<ClassEntity>>();
       for (ClassElement mixin in _mixinUses.keys) {
-        List<MixinApplicationElement> uses = <MixinApplicationElement>[];
+        List<ClassEntity> uses = <ClassEntity>[];
 
         void addLiveUse(MixinApplicationElement mixinApplication) {
           if (isInstantiated(mixinApplication)) {
@@ -854,36 +849,34 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
         }
       }
     }
-    Iterable<MixinApplicationElement> uses = _liveMixinUses[cls];
-    return uses != null ? uses : const <MixinApplicationElement>[];
+    Iterable<ClassEntity> uses = _liveMixinUses[cls];
+    return uses != null ? uses : const <ClassEntity>[];
   }
 
   /// Returns `true` if [cls] is mixed into a live class.
-  bool isUsedAsMixin(ClassElement cls) {
-    assert(isClosed);
+  bool isUsedAsMixin(ClassEntity cls) {
     return !mixinUsesOf(cls).isEmpty;
   }
 
   /// Returns `true` if any live class that mixes in [cls] implements [type].
   bool hasAnySubclassOfMixinUseThatImplements(
-      ClassElement cls, ClassElement type) {
-    assert(isClosed);
+      ClassEntity cls, ClassEntity type) {
     return mixinUsesOf(cls)
         .any((use) => hasAnySubclassThatImplements(use, type));
   }
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
-  bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement mixin) {
-    assert(isClosed);
-    return mixinUsesOf(mixin).any((each) => each.isSubclassOf(superclass));
+  bool hasAnySubclassThatMixes(ClassEntity superclass, ClassEntity mixin) {
+    return mixinUsesOf(mixin).any((ClassElement each) {
+      return each.isSubclassOf(superclass);
+    });
   }
 
   /// Returns `true` if [cls] or any superclass mixes in [mixin].
-  bool isSubclassOfMixinUseOf(ClassElement cls, ClassElement mixin) {
-    assert(isClosed);
-    assert(cls.isDeclaration);
-    assert(mixin.isDeclaration);
+  bool isSubclassOfMixinUseOf(ClassEntity cls, ClassEntity mixin) {
+    assert(_checkClass(cls));
+    assert(_checkClass(mixin));
     if (isUsedAsMixin(mixin)) {
       ClassElement current = cls;
       while (current != null) {
@@ -899,29 +892,25 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
 
   /// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass
   /// of a mixin application of [y].
-  bool everySubtypeIsSubclassOfOrMixinUseOf(ClassElement x, ClassElement y) {
-    assert(isClosed);
-    assert(x.isDeclaration);
-    assert(y.isDeclaration);
-    Map<ClassElement, bool> secondMap =
-        _subtypeCoveredByCache[x] ??= <ClassElement, bool>{};
-    return secondMap[y] ??= subtypesOf(x).every((ClassElement cls) =>
+  bool everySubtypeIsSubclassOfOrMixinUseOf(ClassEntity x, ClassEntity y) {
+    assert(_checkClass(x));
+    assert(_checkClass(y));
+    Map<ClassEntity, bool> secondMap =
+        _subtypeCoveredByCache[x] ??= <ClassEntity, bool>{};
+    return secondMap[y] ??= subtypesOf(x).every((ClassEntity cls) =>
         isSubclassOf(cls, y) || isSubclassOfMixinUseOf(cls, y));
   }
 
   /// Returns `true` if any subclass of [superclass] implements [type].
-  bool hasAnySubclassThatImplements(
-      ClassElement superclass, ClassElement type) {
-    assert(isClosed);
-
-    Set<ClassEntity> subclasses =
-        _typesImplementedBySubclasses[superclass.declaration];
+  bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) {
+    assert(_checkClass(superclass));
+    Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   @override
-  bool hasElementIn(ClassElement cls, Selector selector, Element element) {
+  bool hasElementIn(ClassEntity cls, Selector selector, Element element) {
     // Use [:implementation:] of [element]
     // because our function set only stores declarations.
     Element result = findMatchIn(cls, selector);
@@ -1007,8 +996,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
-  ClassHierarchyNode getClassHierarchyNode(ClassElement cls) {
-    return _classHierarchyNodes[cls.declaration];
+  ClassHierarchyNode getClassHierarchyNode(ClassEntity cls) {
+    assert(_checkClass(cls));
+    return _classHierarchyNodes[cls];
   }
 
   /// Returns [ClassSet] for [cls] used to model the extends and implements
@@ -1016,8 +1006,9 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
-  ClassSet getClassSet(ClassElement cls) {
-    return _classSets[cls.declaration];
+  ClassSet getClassSet(ClassEntity cls) {
+    assert(_checkClass(cls));
+    return _classSets[cls];
   }
 
   void registerClosureClass(ClosureClassElement cls) {
@@ -1072,13 +1063,11 @@ class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   }
 
   MemberElement locateSingleElement(Selector selector, TypeMask mask) {
-    assert(isClosed);
     mask ??= commonMasks.dynamicType;
     return mask.locateSingleElement(selector, this);
   }
 
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
-    assert(isClosed);
     bool canReachAll = true;
     if (mask != null) {
       canReachAll = _backend.backendUsage.isInvokeOnUsed &&