Use entity WorldImpl where possible

pkg/compiler/lib/src/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.
 
 library dart2js.world;
 
 import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show BackendClasses;
 import 'common.dart';
 import 'constants/constant_system.dart';
@@ skipping 379 matching lines @@
 
 class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   final JavaScriptBackend _backend;
   BackendClasses get backendClasses => _backend.backendClasses;
   InterceptorData get interceptorData => _backend.interceptorData;
   FunctionSet _allFunctions;
 
   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;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   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>();
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
-  bool get isClosed => true;
-
   ClosedWorldImpl(
       {JavaScriptBackend backend,
       this.commonElements,
       ResolutionWorldBuilder resolutionWorldBuilder,
       FunctionSetBuilder functionSetBuilder,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : this._backend = backend,
         this._resolverWorld = resolutionWorldBuilder,
         this._allTypedefs = allTypedefs,
         this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
     _allFunctions = functionSetBuilder.close(this);
   }
 
   NativeData get nativeData => _backend.nativeData;
 
   @override
   ClosedWorld get closedWorld => this;
 
   /// 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.') &&
             invariant(cls, cls.isResolved,
                 message:
                     '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
                  message: '$cls is not instantiated.'))*/
         ;
   }
 
   /// 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));
 
     if (y == commonElements.objectClass) return true;
     if (x == commonElements.objectClass) return false;
     if (x.asInstanceOf(y) != null) return true;
     if (y != commonElements.functionClass) return false;
     return x.callType != null;
   }
 
   /// 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));
 
     if (y == commonElements.objectClass) return true;
     if (x == commonElements.objectClass) return false;
     while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
       if (x == y) return true;
       x = x.superclass;
     }
     return false;
   }
 
   @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);
   }
 
   /// 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;
   }
 
   /// 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);
   }
 
   /// 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,
         strict: true);
   }
 
   /// 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);
     }
   }
 
   /// 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);
     }
   }
 
   /// 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;
   }
 
   /// 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);
   }
 
   /// 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,
         strict: true);
   }
 
   /// 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;
       }
     }
     return false;
   }
 
   /// 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;
     }
     return classSet.hasOnlyInstantiatedSubclasses;
   }
 
   @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>[];
 
     ClassElement cls = iterator.current;
     assert(checkInvariants(cls));
     OrderedTypeSet typeSet = cls.allSupertypesAndSelf;
     if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
 
     int depth = typeSet.maxDepth;
     Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
@@ skipping 19 matching lines @@
         if (link.head.asInstanceOf(cls) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
     commonSupertypes.add(commonElements.objectClass);
     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.
     return common.where((ClassElement each) {
       bool containsSuperclass = common.contains(each.supertype.element);
       // If the superclass is also a candidate, then we don't want to
       // deal with this class. If we're only looking for a subclass we
       // know we don't have to look at the list of interfaces because
       // they can never be in the common set.
       if (containsSuperclass ||
           query1 == ClassQuery.SUBCLASS ||
           query2 == ClassQuery.SUBCLASS) {
         return !containsSuperclass;
       }
       // Run through the direct supertypes of the class. If the common
       // set contains the direct supertype of the class, we ignore the
       // the class because the supertype is a better candidate.
       for (Link link = each.interfaces; !link.isEmpty; link = link.tail) {
         if (common.contains(link.head.element)) return false;
       }
       return true;
     });
   }
 
-  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;
       case ClassQuery.SUBCLASS:
         return strictSubclassesOf(cls);
       case ClassQuery.SUBTYPE:
         return strictSubtypesOf(cls);
     }
     throw new ArgumentError('Unexpected query: $query.');
   }
 
   /// 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)) {
             uses.add(mixinApplication);
           } else if (mixinApplication.isNamedMixinApplication) {
             Set<ClassEntity> next = _mixinUses[mixinApplication];
             if (next != null) {
               next.forEach(addLiveUse);
             }
           }
         }
 
         _mixinUses[mixin].forEach(addLiveUse);
         if (uses.isNotEmpty) {
           _liveMixinUses[mixin] = uses;
         }
       }
     }
-    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) {
         if (current.isMixinApplication) {
           MixinApplicationElement application = current;
           if (application.mixin == mixin) return true;
         }
         current = current.superclass;
       }
     }
     return false;
   }
 
   /// 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);
     return result == null
         ? false
         : result.implementation == element.implementation;
   }
 
   MemberElement findMatchIn(ClassElement cls, Selector selector,
       {ClassElement stopAtSuperclass}) {
@@ skipping 65 matching lines @@
       }
       return false;
     }
   }
 
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// 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
   /// relations of known classes.
   ///
   /// 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) {
     ClassHierarchyNode parentNode = getClassHierarchyNode(cls.superclass);
     ClassHierarchyNode node = _classHierarchyNodes[cls] =
         new ClassHierarchyNode(parentNode, cls, cls.hierarchyDepth);
     for (ResolutionInterfaceType type in cls.allSupertypes) {
       ClassSet subtypeSet = getClassSet(type.element);
       subtypeSet.addSubtype(node);
     }
@@ skipping 34 matching lines @@
   bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
     return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
   FieldElement locateSingleField(Selector selector, TypeMask mask) {
     Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
   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 &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
     return canReachAll ? commonMasks.dynamicType : mask;
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
@@ skipping 99 matching lines @@
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
 }