Introduce JsStrategy skeleton

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.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements;
@@ skipping 385 matching lines @@
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final ConstantSystem constantSystem;
   final NativeData nativeData;
   final InterceptorData interceptorData;
   final BackendUsage backendUsage;
 
   final FunctionSet _allFunctions;
 
-  final Iterable<TypedefElement> _allTypedefs;
+  final Set<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
   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<ClassEntity, Map<ClassEntity, bool>> _subtypeCoveredByCache =
       <ClassEntity, Map<ClassEntity, bool>>{};
 
   final Set<Entity> _functionsCalledInLoop = new Set<Entity>();
   final Map<Entity, SideEffects> _sideEffects = new Map<Entity, SideEffects>();
 
   final Set<Entity> _sideEffectsFreeElements = new Set<Entity>();
 
   final Set<Entity> _elementsThatCannotThrow = new Set<Entity>();
 
   final Set<Entity> _functionsThatMightBePassedToApply = new Set<Entity>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
+  // TODO(johnniwinther): Avoid this.
   final ResolutionWorldBuilder _resolverWorld;
 
+  // TODO(johnniwinther): Can this be derived from [ClassSet]s?
+  final Set<ClassEntity> _implementedClasses;
+
   ClosedWorldBase(
       {this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
+      Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
-      Iterable<TypedefElement> allTypedefs,
+      Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : this._resolverWorld = resolutionWorldBuilder,
+        this._implementedClasses = implementedClasses,
         this._allFunctions = functionSet,
         this._allTypedefs = allTypedefs,
         this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
   }
 
   @override
   ClosedWorld get closedWorld => this;
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
   final List<Map<ClassEntity, TypeMask>> _canonicalizedTypeMasks =
       new List<Map<ClassEntity, TypeMask>>.filled(8, null);
 
   CommonMasks get commonMasks {
     return _commonMasks;
   }
 
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
     Map<ClassEntity, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
-  bool _checkEntity(Entity element);
+  bool checkEntity(Entity element);
 
-  bool _checkClass(ClassEntity cls);
+  bool checkClass(ClassEntity cls);
 
-  bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true});
+  bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true});
 
-  OrderedTypeSet _getOrderedTypeSet(ClassEntity cls);
+  OrderedTypeSet getOrderedTypeSet(ClassEntity cls);
 
-  int _getHierarchyDepth(ClassEntity cls);
+  int getHierarchyDepth(ClassEntity cls);
 
-  ClassEntity _getSuperClass(ClassEntity cls);
+  ClassEntity getSuperClass(ClassEntity cls);
 
-  Iterable<ClassEntity> _getInterfaces(ClassEntity cls);
+  Iterable<ClassEntity> getInterfaces(ClassEntity cls);
 
-  ClassEntity _getAppliedMixin(ClassEntity cls);
+  ClassEntity getAppliedMixin(ClassEntity cls);
 
-  bool _isNamedMixinApplication(ClassEntity cls);
+  bool isNamedMixinApplication(ClassEntity cls);
 
   @override
   bool isInstantiated(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
 
   @override
   bool isDirectlyInstantiated(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isDirectlyInstantiated;
   }
 
   @override
   bool isAbstractlyInstantiated(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isAbstractlyInstantiated;
   }
 
   @override
   bool isExplicitlyInstantiated(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isExplicitlyInstantiated;
   }
 
   @override
   bool isIndirectlyInstantiated(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isIndirectlyInstantiated;
   }
 
   @override
   bool isAbstract(ClassEntity cls) => cls.isAbstract;
 
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassEntity cls) {
-    return _resolverWorld.isImplemented(cls);
+    return _implementedClasses.contains(cls);
   }
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassEntity x, ClassEntity y) {
-    assert(_checkInvariants(x));
-    assert(_checkInvariants(y, mustBeInstantiated: false));
+    assert(checkInvariants(x));
+    assert(checkInvariants(y, mustBeInstantiated: false));
     return _classSets[y].hasSubtype(_classHierarchyNodes[x]);
   }
 
   /// Return `true` if [x] is a (non-strict) subclass of [y].
   bool isSubclassOf(ClassEntity x, ClassEntity y) {
-    assert(_checkInvariants(x));
-    assert(_checkInvariants(y));
+    assert(checkInvariants(x));
+    assert(checkInvariants(y));
     return _classHierarchyNodes[y].hasSubclass(_classHierarchyNodes[x]);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassEntity> subclassesOf(ClassEntity cls) {
-    assert(_checkClass(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<ClassEntity> strictSubclassesOf(ClassEntity cls) {
-    assert(_checkClass(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(ClassEntity cls) {
-    assert(_checkClass(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(
       ClassEntity cls, IterationStep f(ClassEntity cls)) {
-    assert(_checkClass(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(ClassEntity cls, bool predicate(ClassEntity cls)) {
-    assert(_checkClass(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<ClassEntity> subtypesOf(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassSet classSet = _classSets[cls];
     if (classSet == null) {
       return const <ClassEntity>[];
     } else {
       return classSet
           .subtypesByMask(ClassHierarchyNode.EXPLICITLY_INSTANTIATED);
     }
   }
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// _not_ including [cls].
   Iterable<ClassEntity> strictSubtypesOf(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     ClassSet classSet = _classSets[cls];
     if (classSet == null) {
       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(ClassEntity cls) {
-    assert(_checkClass(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(
       ClassEntity cls, IterationStep f(ClassEntity cls)) {
-    assert(_checkClass(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(ClassEntity cls, bool predicate(ClassEntity cls)) {
-    assert(_checkClass(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(ClassEntity a, ClassEntity b) {
-    assert(_checkClass(a));
-    assert(_checkClass(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<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(ClassEntity cls) {
-    assert(_checkClass(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(ClassEntity cls) {
     return strictSubtypeCount(cls) > 0;
   }
 
   /// Returns `true` if all directly instantiated classes that implement [cls]
   /// extend it.
   bool hasOnlySubclasses(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     // TODO(johnniwinther): move this to ClassSet?
     if (cls == commonElements.objectClass) return true;
     ClassSet classSet = _classSets[cls];
     if (classSet == null) {
       // Vacuously true.
       return true;
     }
     return classSet.hasOnlyInstantiatedSubclasses;
   }
 
   @override
   ClassEntity getLubOfInstantiatedSubclasses(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return commonElements.jsJavaScriptObjectClass;
     }
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls];
     return hierarchy != null
         ? hierarchy.getLubOfInstantiatedSubclasses()
         : null;
   }
 
   @override
   ClassEntity getLubOfInstantiatedSubtypes(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return commonElements.jsJavaScriptObjectClass;
     }
     ClassSet classSet = _classSets[cls];
     return classSet != null ? classSet.getLubOfInstantiatedSubtypes() : null;
   }
 
   Set<ClassEntity> _commonContainedClasses(ClassEntity cls1, ClassQuery query1,
       ClassEntity cls2, ClassQuery query2) {
     Iterable<ClassEntity> xSubset = _containedSubset(cls1, query1);
@@ skipping 23 matching lines @@
   /// Returns `true` if any live class that mixes in [cls] implements [type].
   bool hasAnySubclassOfMixinUseThatImplements(
       ClassEntity cls, ClassEntity type) {
     return mixinUsesOf(cls)
         .any((use) => hasAnySubclassThatImplements(use, type));
   }
 
   /// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass
   /// of a mixin application of [y].
   bool everySubtypeIsSubclassOfOrMixinUseOf(ClassEntity x, ClassEntity y) {
-    assert(_checkClass(x));
-    assert(_checkClass(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(ClassEntity superclass, ClassEntity type) {
-    assert(_checkClass(superclass));
+    assert(checkClass(superclass));
     Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   /// Returns whether a [selector] call on an instance of [cls]
   /// will hit a method at runtime, and not go through [noSuchMethod].
   bool hasConcreteMatch(ClassEntity cls, Selector selector,
       {ClassEntity stopAtSuperclass});
 
@@ skipping 44 matching lines @@
       return false;
     }
   }
 
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassEntity> commonSupertypesOf(Iterable<ClassEntity> classes) {
     Iterator<ClassEntity> iterator = classes.iterator;
     if (!iterator.moveNext()) return const <ClassEntity>[];
 
     ClassEntity cls = iterator.current;
-    assert(_checkInvariants(cls));
-    OrderedTypeSet typeSet = _getOrderedTypeSet(cls);
+    assert(checkInvariants(cls));
+    OrderedTypeSet typeSet = getOrderedTypeSet(cls);
     if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
 
     int depth = typeSet.maxDepth;
     Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
     do {
       ClassEntity otherClass = iterator.current;
-      assert(_checkInvariants(otherClass));
-      OrderedTypeSet otherTypeSet = _getOrderedTypeSet(otherClass);
+      assert(checkInvariants(otherClass));
+      OrderedTypeSet otherTypeSet = getOrderedTypeSet(otherClass);
       otherTypeSets = otherTypeSets.prepend(otherTypeSet);
       if (otherTypeSet.maxDepth < depth) {
         depth = otherTypeSet.maxDepth;
       }
     } while (iterator.moveNext());
 
     List<ClassEntity> commonSupertypes = <ClassEntity>[];
     OUTER:
     for (Link<InterfaceType> link = typeSet[depth];
         link.head.element != commonElements.objectClass;
         link = link.tail) {
       ClassEntity cls = link.head.element;
       for (Link<OrderedTypeSet> link = otherTypeSets;
           !link.isEmpty;
           link = link.tail) {
-        if (link.head.asInstanceOf(cls, _getHierarchyDepth(cls)) == null) {
+        if (link.head.asInstanceOf(cls, getHierarchyDepth(cls)) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
     commonSupertypes.add(commonElements.objectClass);
     return commonSupertypes;
   }
 
   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 <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((ClassEntity each) {
-      bool containsSuperclass = common.contains(_getSuperClass(each));
+      bool containsSuperclass = common.contains(getSuperClass(each));
       // 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 (ClassEntity interface in _getInterfaces(each)) {
+      for (ClassEntity interface in getInterfaces(each)) {
         if (common.contains(interface)) return false;
       }
       return true;
     });
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<ClassEntity> mixinUsesOf(ClassEntity cls) {
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassEntity, List<ClassEntity>>();
       for (ClassEntity mixin in _mixinUses.keys) {
         List<ClassEntity> uses = <ClassEntity>[];
 
         void addLiveUse(ClassEntity mixinApplication) {
           if (isInstantiated(mixinApplication)) {
             uses.add(mixinApplication);
-          } else if (_isNamedMixinApplication(mixinApplication)) {
+          } else if (isNamedMixinApplication(mixinApplication)) {
             Set<ClassEntity> next = _mixinUses[mixinApplication];
             if (next != null) {
               next.forEach(addLiveUse);
             }
           }
         }
 
         _mixinUses[mixin].forEach(addLiveUse);
         if (uses.isNotEmpty) {
           _liveMixinUses[mixin] = uses;
         }
       }
     }
     Iterable<ClassEntity> uses = _liveMixinUses[cls];
     return uses != null ? uses : const <ClassEntity>[];
   }
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassEntity superclass, ClassEntity mixin) {
     return mixinUsesOf(mixin).any((ClassEntity each) {
       return isSubclassOf(each, superclass);
     });
   }
 
   /// Returns `true` if [cls] or any superclass mixes in [mixin].
   bool isSubclassOfMixinUseOf(ClassEntity cls, ClassEntity mixin) {
-    assert(_checkClass(cls));
-    assert(_checkClass(mixin));
+    assert(checkClass(cls));
+    assert(checkClass(mixin));
     if (isUsedAsMixin(mixin)) {
       ClassEntity current = cls;
       while (current != null) {
-        ClassEntity currentMixin = _getAppliedMixin(current);
+        ClassEntity currentMixin = getAppliedMixin(current);
         if (currentMixin == mixin) return true;
-        current = _getSuperClass(current);
+        current = getSuperClass(current);
       }
     }
     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(ClassEntity cls) {
-    assert(_checkClass(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(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     return _classSets[cls];
   }
 
   Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
   TypeMask computeReceiverType(Selector selector, TypeMask mask) {
     return _allFunctions.receiverType(selector, mask, this);
   }
 
   Iterable<MemberEntity> locateMembers(Selector selector, TypeMask mask) {
@@ skipping 63 matching lines @@
           sideEffects.setDependsOnSomething();
         }
       } else {
         sideEffects.add(getSideEffectsOfElement(e));
       }
     }
     return sideEffects;
   }
 
   SideEffects getSideEffectsOfElement(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     return _sideEffects.putIfAbsent(element, _makeSideEffects);
   }
 
   static _makeSideEffects() => new SideEffects();
 
   @override
   SideEffects getCurrentlyKnownSideEffects(Entity element) {
     return getSideEffectsOfElement(element);
   }
 
   void registerSideEffects(Entity element, SideEffects effects) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     if (_sideEffectsFreeElements.contains(element)) return;
     _sideEffects[element] = effects;
   }
 
   void registerSideEffectsFree(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     _sideEffects[element] = new SideEffects.empty();
     _sideEffectsFreeElements.add(element);
   }
 
   void addFunctionCalledInLoop(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     _functionsCalledInLoop.add(element);
   }
 
   bool isCalledInLoop(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     return _functionsCalledInLoop.contains(element);
   }
 
   void registerCannotThrow(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     _elementsThatCannotThrow.add(element);
   }
 
   bool getCannotThrow(Entity element) {
     return _elementsThatCannotThrow.contains(element);
   }
 
   void registerMightBePassedToApply(Entity element) {
     _functionsThatMightBePassedToApply.add(element);
   }
@@ skipping 35 matching lines @@
 }
 
 class ClosedWorldImpl extends ClosedWorldBase {
   ClosedWorldImpl(
       {CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
+      Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
-      Iterable<TypedefElement> allTypedefs,
+      Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
+            implementedClasses: implementedClasses,
             functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
-  bool _checkClass(ClassElement cls) => cls.isDeclaration;
+  bool checkClass(ClassElement cls) => cls.isDeclaration;
 
-  bool _checkEntity(Element element) => element.isDeclaration;
+  bool checkEntity(Element element) => element.isDeclaration;
 
-  bool _checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
+  bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     assert(cls.isDeclaration, failedAt(cls, '$cls must be the declaration.'));
     assert(cls.isResolved, failedAt(cls, '$cls must be resolved.'));
 
     // TODO(johnniwinther): Reinsert this or similar invariant. Currently
     // various call sites use uninstantiated classes for isSubtypeOf or
     // isSubclassOf. Some are valid, some are not. Work out better invariants
     // to catch the latter.
     // if (mustBeInstantiated) {
     //  assert(isInstantiated(cls), failedAt(cls, '$cls is not instantiated.'));
     // }
     return true;
   }
 
-  OrderedTypeSet _getOrderedTypeSet(ClassElement cls) =>
+  OrderedTypeSet getOrderedTypeSet(ClassElement cls) =>
       cls.allSupertypesAndSelf;
 
-  int _getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth;
+  int getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth;
 
-  ClassEntity _getSuperClass(ClassElement cls) => cls.superclass;
+  ClassEntity getSuperClass(ClassElement cls) => cls.superclass;
 
-  Iterable<ClassEntity> _getInterfaces(ClassElement cls) sync* {
+  Iterable<ClassEntity> getInterfaces(ClassElement cls) sync* {
     for (Link link = cls.interfaces; !link.isEmpty; link = link.tail) {
       yield link.head.element;
     }
   }
 
-  bool _isNamedMixinApplication(ClassElement cls) =>
-      cls.isNamedMixinApplication;
+  bool isNamedMixinApplication(ClassElement cls) => cls.isNamedMixinApplication;
 
-  ClassEntity _getAppliedMixin(ClassElement cls) {
+  ClassEntity getAppliedMixin(ClassElement cls) {
     if (cls.isMixinApplication) {
       MixinApplicationElement application = cls;
       return application.mixin;
     }
     return null;
   }
 
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Element element) {
     // Use [:implementation:] of [element]
@@ skipping 69 matching lines @@
 }
 
 class KernelClosedWorld extends ClosedWorldBase {
   KernelClosedWorld(
       {CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
+      Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
-      Iterable<TypedefElement> allTypedefs,
+      Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
+            implementedClasses: implementedClasses,
             functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
   @override
   bool hasConcreteMatch(ClassEntity cls, Selector selector,
       {ClassEntity stopAtSuperclass}) {
     throw new UnimplementedError('KernelClosedWorld.hasConcreteMatch');
   }
 
   @override
-  bool _isNamedMixinApplication(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._isNamedMixinApplication');
+  bool isNamedMixinApplication(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.isNamedMixinApplication');
   }
 
   @override
-  ClassEntity _getAppliedMixin(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getAppliedMixin');
+  ClassEntity getAppliedMixin(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.getAppliedMixin');
   }
 
   @override
-  Iterable<ClassEntity> _getInterfaces(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getInterfaces');
+  Iterable<ClassEntity> getInterfaces(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.getInterfaces');
   }
 
   @override
-  ClassEntity _getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getSuperClass');
+  ClassEntity getSuperClass(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.getSuperClass');
   }
 
   @override
-  int _getHierarchyDepth(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getHierarchyDepth');
+  int getHierarchyDepth(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.getHierarchyDepth');
   }
 
   @override
-  OrderedTypeSet _getOrderedTypeSet(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getOrderedTypeSet');
+  OrderedTypeSet getOrderedTypeSet(ClassEntity cls) {
+    throw new UnimplementedError('KernelClosedWorld.getOrderedTypeSet');
   }
 
   @override
-  bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) =>
+  bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) =>
       true;
 
   @override
-  bool _checkClass(ClassEntity cls) => true;
+  bool checkClass(ClassEntity cls) => true;
 
   @override
-  bool _checkEntity(Entity element) => true;
+  bool checkEntity(Entity element) => true;
 
   @override
   void registerClosureClass(ClassElement cls) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
 
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
     throw new UnimplementedError('KernelClosedWorld.hasElementIn');
   }
 }