Merge CoreTypes and CoreClasses into CommonElements.

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';
-import 'core_types.dart' show CoreTypes, CoreClasses, CommonElements;
+import 'core_types.dart' show CommonElements;
 import 'dart_types.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MixinApplicationElement,
         TypedefElement,
         FieldElement;
 import 'js_backend/backend.dart' show JavaScriptBackend;
@@ skipping 14 matching lines @@
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
 /// it, what functions are called, what classes are allocated, which native
 /// JavaScript types are touched, what language features are used, and so on.
 /// This precise knowledge about what's live in the program is later used in
 /// optimizations and other compiler decisions during code generation.
 abstract class ClosedWorld implements World {
   /// Access to core classes used by the backend.
   BackendClasses get backendClasses;
 
-  /// Access to core classes used in the Dart language.
-  CoreClasses get coreClasses;
-
-  CoreTypes get coreTypes;
-
   CommonElements get commonElements;
 
   CommonMasks get commonMasks;
 
   ConstantSystem get constantSystem;
 
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassElement cls);
 
   /// Returns `true` if [cls] is directly instantiated. This means that at
@@ skipping 327 matching lines @@
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
-  final CoreTypes coreTypes;
-
   final ResolutionWorldBuilder _resolverWorld;
 
   bool get isClosed => true;
 
   ClosedWorldImpl(
       {JavaScriptBackend backend,
       this.commonElements,
-      this.coreTypes,
       ResolutionWorldBuilder resolverWorld,
       FunctionSetBuilder functionSetBuilder,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassElement, Set<MixinApplicationElement>> mixinUses,
       Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses,
       Map<ClassElement, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassElement, ClassSet> classSets})
       : this._backend = backend,
         this._resolverWorld = resolverWorld,
         this._allTypedefs = allTypedefs,
@@ skipping 10 matching lines @@
   final List<Map<ClassElement, TypeMask>> _canonicalizedTypeMasks =
       new List<Map<ClassElement, TypeMask>>.filled(8, null);
 
   FunctionSet get allFunctions => _allFunctions;
 
   CommonMasks get commonMasks {
     assert(isClosed);
     return _commonMasks;
   }
 
-  CoreClasses get coreClasses => commonElements;
-
   ConstantSystem get constantSystem => _backend.constantSystem;
 
   TypeMask getCachedMask(ClassElement base, int flags, TypeMask createMask()) {
     Map<ClassElement, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassElement, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
   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 == coreClasses.objectClass) return true;
-    if (x == coreClasses.objectClass) return false;
+    if (y == commonElements.objectClass) return true;
+    if (x == commonElements.objectClass) return false;
     if (x.asInstanceOf(y) != null) return true;
-    if (y != coreClasses.functionClass) return false;
+    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 == coreClasses.objectClass) return true;
-    if (x == coreClasses.objectClass) return false;
+    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);
@@ skipping 176 matching lines @@
   /// implements [cls].
   bool hasAnyStrictSubtype(ClassElement cls) {
     return strictSubtypeCount(cls) > 0;
   }
 
   /// Returns `true` if all directly instantiated classes that implement [cls]
   /// extend it.
   bool hasOnlySubclasses(ClassElement cls) {
     assert(isClosed);
     // TODO(johnniwinther): move this to ClassSet?
-    if (cls == coreClasses.objectClass) return true;
+    if (cls == commonElements.objectClass) return true;
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       // Vacuously true.
       return true;
     }
     return classSet.hasOnlyInstantiatedSubclasses;
   }
 
   @override
   ClassElement getLubOfInstantiatedSubclasses(ClassElement cls) {
@@ skipping 36 matching lines @@
       OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
       otherTypeSets = otherTypeSets.prepend(otherTypeSet);
       if (otherTypeSet.maxDepth < depth) {
         depth = otherTypeSet.maxDepth;
       }
     } while (iterator.moveNext());
 
     List<ClassElement> commonSupertypes = <ClassElement>[];
     OUTER:
     for (Link<DartType> link = typeSet[depth];
-        link.head.element != coreClasses.objectClass;
+        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) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
-    commonSupertypes.add(coreClasses.objectClass);
+    commonSupertypes.add(commonElements.objectClass);
     return commonSupertypes;
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls) {
     assert(isClosed);
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassElement, List<MixinApplicationElement>>();
       for (ClassElement mixin in _mixinUses.keys) {
         List<MixinApplicationElement> uses = <MixinApplicationElement>[];
@@ skipping 212 matching lines @@
   Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
   @override
   String dump([ClassElement cls]) {
     StringBuffer sb = new StringBuffer();
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
-    getClassHierarchyNode(coreClasses.objectClass)
+    getClassHierarchyNode(commonElements.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 
   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);
@@ skipping 120 matching lines @@
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
 }