Remove JavaScriptBackend from ClosedWorldBase

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;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
         MixinApplicationElement,
         TypedefElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
-import 'js_backend/backend.dart' show JavaScriptBackend;
+import 'js_backend/backend_usage.dart' show BackendUsage;
 import 'js_backend/interceptor_data.dart' show InterceptorData;
 import 'js_backend/native_data.dart' show NativeData;
 import 'ordered_typeset.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
 import 'universe/function_set.dart' show FunctionSet, FunctionSetBuilder;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
 import 'universe/world_builder.dart' show ResolutionWorldBuilder;
 import 'util/util.dart' show Link;
@@ skipping 325 matching lines @@
 abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
   void registerClass(ClassEntity cls);
 
   void registerUsedElement(MemberEntity element);
   void registerTypedef(TypedefElement typedef);
 
-  ClosedWorld closeWorld(DiagnosticReporter reporter);
+  ClosedWorld closeWorld();
 
   /// Returns an iterable over all mixin applications that mixin [cls].
   Iterable<ClassEntity> allMixinUsesOf(ClassEntity cls);
 }
 
 /// Enum values defining subset of classes included in queries.
 enum ClassQuery {
   /// Only the class itself is included.
   EXACT,
 
   /// The class and all subclasses (transitively) are included.
   SUBCLASS,
 
   /// The class and all classes that implement or subclass it (transitively)
   /// are included.
   SUBTYPE,
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
-  final JavaScriptBackend _backend;
-  InterceptorData get interceptorData => _backend.interceptorData;
+  final ConstantSystem constantSystem;
+  final NativeData nativeData;
+  final InterceptorData interceptorData;
+  final BackendUsage _backendUsage;
+
   FunctionSet _allFunctions;
 
   final Iterable<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
@@ skipping 13 matching lines @@
 
   final Set<Entity> _functionsThatMightBePassedToApply = new Set<Entity>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
   ClosedWorldBase(
-      {JavaScriptBackend backend,
-      this.commonElements,
+      {this.commonElements,
+      this.constantSystem,
+      this.nativeData,
+      this.interceptorData,
+      BackendUsage backendUsage,
       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._backendUsage = backendUsage,
         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<ClassEntity, TypeMask>> _canonicalizedTypeMasks =
       new List<Map<ClassEntity, TypeMask>>.filled(8, null);
 
   FunctionSet get allFunctions => _allFunctions;
 
   CommonMasks get commonMasks {
     return _commonMasks;
   }
 
-  ConstantSystem get constantSystem => _backend.constantSystem;
-
   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 _checkClass(ClassEntity cls);
 
   bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true});
 
+  OrderedTypeSet _getOrderedTypeSet(ClassEntity cls);
+
+  int _getHierarchyDepth(ClassEntity cls);
+
+  ClassEntity _getSuperClass(ClassEntity cls);
+
+  Iterable<ClassEntity> _getInterfaces(ClassEntity cls);
+
+  ClassEntity _getAppliedMixin(ClassEntity cls);
+
+  bool _isNamedMixinApplication(ClassEntity cls);
+
   @override
   bool isInstantiated(ClassEntity cls) {
     assert(_checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
 
   @override
   bool isDirectlyInstantiated(ClassEntity cls) {
     assert(_checkClass(cls));
@@ skipping 320 matching lines @@
       return subclassesNeedNoSuchMethod(node);
     } else {
       if (subclassesNeedNoSuchMethod(node)) return true;
       for (ClassHierarchyNode subtypeNode in classSet.subtypeNodes) {
         if (subclassesNeedNoSuchMethod(subtypeNode)) return true;
       }
       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);
+    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);
+      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) {
+          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));
+      // 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)) {
+        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)) {
+            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));
+    if (isUsedAsMixin(mixin)) {
+      ClassEntity current = cls;
+      while (current != null) {
+        ClassEntity currentMixin = _getAppliedMixin(cls);
+        if (currentMixin == mixin) return true;
+        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));
     return _classHierarchyNodes[cls];
   }
 
@@ skipping 19 matching lines @@
   }
 
   MemberEntity locateSingleElement(Selector selector, TypeMask mask) {
     mask ??= commonMasks.dynamicType;
     return mask.locateSingleElement(selector, this);
   }
 
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
     bool canReachAll = true;
     if (mask != null) {
-      canReachAll = _backend.backendUsage.isInvokeOnUsed &&
+      canReachAll = _backendUsage.isInvokeOnUsed &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
     return canReachAll ? commonMasks.dynamicType : mask;
   }
 
   bool fieldNeverChanges(MemberEntity element) {
     if (!element.isField) return false;
     if (nativeData.isNativeMember(element)) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
@@ skipping 97 matching lines @@
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Entity element) {
     return getMightBePassedToApply(element);
   }
 }
 
 class ClosedWorldImpl extends ClosedWorldBase {
   ClosedWorldImpl(
-      {JavaScriptBackend backend,
-      CommonElements commonElements,
+      {CommonElements commonElements,
+      ConstantSystem constantSystem,
+      NativeData nativeData,
+      InterceptorData interceptorData,
+      BackendUsage backendUsage,
       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})
       : super(
-            backend: backend,
             commonElements: commonElements,
+            constantSystem: constantSystem,
+            nativeData: nativeData,
+            interceptorData: interceptorData,
+            backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
             functionSetBuilder: functionSetBuilder,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
   bool _checkClass(ClassElement cls) => cls.isDeclaration;
+
   bool _checkEntity(Element element) => element.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. 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.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
                  message: '$cls is not instantiated.'))*/
         ;
   }
 
-  /// Returns an iterable over the common supertypes of the [classes].
-  Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes) {
-    Iterator<ClassElement> iterator = classes.iterator;
-    if (!iterator.moveNext()) return const <ClassElement>[];
+  OrderedTypeSet _getOrderedTypeSet(ClassElement cls) =>
+      cls.allSupertypesAndSelf;
 
-    ClassElement cls = iterator.current;
-    assert(_checkInvariants(cls));
-    OrderedTypeSet typeSet = cls.allSupertypesAndSelf;
-    if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
+  int _getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth;
 
-    int depth = typeSet.maxDepth;
-    Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
-    do {
-      ClassElement otherClass = iterator.current;
-      assert(_checkInvariants(otherClass));
-      OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
-      otherTypeSets = otherTypeSets.prepend(otherTypeSet);
-      if (otherTypeSet.maxDepth < depth) {
-        depth = otherTypeSet.maxDepth;
-      }
-    } while (iterator.moveNext());
+  ClassEntity _getSuperClass(ClassElement cls) => cls.superclass;
 
-    List<ClassElement> commonSupertypes = <ClassElement>[];
-    OUTER:
-    for (Link<InterfaceType> link = typeSet[depth];
-        link.head.element != commonElements.objectClass;
-        link = link.tail) {
-      ClassElement cls = link.head.element;
-      for (Link<OrderedTypeSet> link = otherTypeSets;
-          !link.isEmpty;
-          link = link.tail) {
-        if (link.head.asInstanceOf(cls, cls.hierarchyDepth) == null) {
-          continue OUTER;
-        }
-      }
-      commonSupertypes.add(cls);
+  Iterable<ClassEntity> _getInterfaces(ClassElement cls) sync* {
+    for (Link link = cls.interfaces; !link.isEmpty; link = link.tail) {
+      yield link.head.element;
     }
-    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((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;
-    });
-  }
+  bool _isNamedMixinApplication(ClassElement cls) =>
+      cls.isNamedMixinApplication;
 
-  /// 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 (ClassElement mixin in _mixinUses.keys) {
-        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;
-        }
-      }
+  ClassEntity _getAppliedMixin(ClassElement cls) {
+    if (cls.isMixinApplication) {
+      MixinApplicationElement application = cls;
+      return application.mixin;
     }
-    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((ClassElement each) {
-      return each.isSubclassOf(superclass);
-    });
-  }
-
-  /// Returns `true` if [cls] or any superclass mixes in [mixin].
-  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;
+    return null;
   }
 
   @override
   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;
@@ skipping 68 matching lines @@
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return super.getSideEffectsOfElement(element);
   }
 }
+
+class KernelClosedWorld extends ClosedWorldBase {
+  KernelClosedWorld(
+      {CommonElements commonElements,
+      ConstantSystem constantSystem,
+      NativeData nativeData,
+      InterceptorData interceptorData,
+      BackendUsage backendUsage,
+      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})
+      : super(
+            commonElements: commonElements,
+            constantSystem: constantSystem,
+            nativeData: nativeData,
+            interceptorData: interceptorData,
+            backendUsage: backendUsage,
+            resolutionWorldBuilder: resolutionWorldBuilder,
+            functionSetBuilder: functionSetBuilder,
+            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
+  String dump([ClassEntity cls]) {
+    throw new UnimplementedError('KernelClosedWorld.dump');
+  }
+
+  @override
+  bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
+    throw new UnimplementedError('KernelClosedWorld.hasElementIn');
+  }
+}