Support user class in compile_from_dill_test

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 59e009558ed7f1ed8909992d296181d3814a5329..ec66ad48f54b90c1647a193dbb02c7b6c41bb9e2 100644
--- a/pkg/compiler/lib/src/world.dart
+++ b/pkg/compiler/lib/src/world.dart
@@ -474,55 +474,55 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
     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;
   }
@@ -538,22 +538,32 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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));
-    return _classSets[y].hasSubtype(_classHierarchyNodes[x]);
+    assert(checkInvariants(x));
+    assert(checkInvariants(y, mustBeInstantiated: false));
+    ClassSet classSet = _classSets[y];
+    assert(
+        classSet != null,
+        failedAt(
+            y,
+            "No ClassSet for $y (${y.runtimeType}): "
+            "${dump(y)} : ${_classSets}"));
+    ClassHierarchyNode classHierarchyNode = _classHierarchyNodes[x];
+    assert(classHierarchyNode != null,
+        failedAt(x, "No ClassHierarchyNode for $x: ${dump(x)}"));
+    return classSet.hasSubtype(classHierarchyNode);
   }
 
   /// 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
@@ -563,7 +573,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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(
@@ -574,7 +584,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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;
@@ -584,7 +594,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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,
@@ -594,7 +604,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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(
@@ -605,7 +615,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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>[];
@@ -618,7 +628,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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>[];
@@ -631,7 +641,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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;
@@ -641,7 +651,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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,
@@ -651,7 +661,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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(
@@ -661,8 +671,8 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
 
   /// 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;
@@ -679,7 +689,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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;
@@ -694,7 +704,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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];
@@ -707,7 +717,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
 
   @override
   ClassEntity getLubOfInstantiatedSubclasses(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return commonElements.jsJavaScriptObjectClass;
     }
@@ -719,7 +729,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
 
   @override
   ClassEntity getLubOfInstantiatedSubtypes(ClassEntity cls) {
-    assert(_checkClass(cls));
+    assert(checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return commonElements.jsJavaScriptObjectClass;
     }
@@ -763,8 +773,8 @@ abstract class ClosedWorldBase 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(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) =>
@@ -773,7 +783,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
 
   /// 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);
@@ -838,16 +848,16 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
     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;
@@ -863,7 +873,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
       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;
         }
       }
@@ -884,7 +894,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
     // 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
@@ -898,7 +908,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
       // 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;
@@ -915,7 +925,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
         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);
@@ -943,14 +953,14 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
 
   /// 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;
@@ -962,7 +972,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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];
   }
 
@@ -972,7 +982,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   /// 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];
   }
 
@@ -1056,7 +1066,7 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   }
 
   SideEffects getSideEffectsOfElement(Entity element) {
-    assert(_checkEntity(element));
+    assert(checkEntity(element));
     return _sideEffects.putIfAbsent(element, _makeSideEffects);
   }
 
@@ -1068,29 +1078,29 @@ abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   }
 
   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);
   }
 
@@ -1166,11 +1176,11 @@ class ClosedWorldImpl extends ClosedWorldBase {
             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.'));
 
@@ -1184,23 +1194,22 @@ class ClosedWorldImpl extends ClosedWorldBase {
     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;
@@ -1281,88 +1290,3 @@ class ClosedWorldImpl extends ClosedWorldBase {
     return super.getSideEffectsOfElement(element);
   }
 }
-
-class KernelClosedWorld extends ClosedWorldBase {
-  KernelClosedWorld(
-      {CommonElements commonElements,
-      ConstantSystem constantSystem,
-      NativeData nativeData,
-      InterceptorData interceptorData,
-      BackendUsage backendUsage,
-      ResolutionWorldBuilder resolutionWorldBuilder,
-      FunctionSet functionSet,
-      Iterable<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,
-            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');
-  }
-
-  @override
-  ClassEntity _getAppliedMixin(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getAppliedMixin');
-  }
-
-  @override
-  Iterable<ClassEntity> _getInterfaces(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getInterfaces');
-  }
-
-  @override
-  ClassEntity _getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getSuperClass');
-  }
-
-  @override
-  int _getHierarchyDepth(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getHierarchyDepth');
-  }
-
-  @override
-  OrderedTypeSet _getOrderedTypeSet(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld._getOrderedTypeSet');
-  }
-
-  @override
-  bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) =>
-      true;
-
-  @override
-  bool _checkClass(ClassEntity cls) => true;
-
-  @override
-  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');
-  }
-}