Add CoreClasses

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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.resolution.class_hierarchy;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
+import '../core_types.dart' show
+    CoreClasses,
+    CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     BaseClassElementX,
     ErroneousElementX,
     MixinApplicationElementX,
     SynthesizedConstructorElementX,
     TypeVariableElementX;
 import '../ordered_typeset.dart' show
     OrderedTypeSet,
@@ skipping 22 matching lines @@
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
 
   TypeDefinitionVisitor(Compiler compiler,
                         TypeDeclarationElement element,
                         ResolutionRegistry registry)
       : this.enclosingElement = element,
         scope = Scope.buildEnclosingScope(element),
         super(compiler, registry);
 
-  DartType get objectType => compiler.objectClass.rawType;
+  DartType get objectType => compiler.coreTypes.objectType;
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     Setlet<String> nameSet = new Setlet<String>();
     // Resolve the bounds of type variables.
     Iterator<DartType> types = element.typeVariables.iterator;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       types.moveNext();
@@ skipping 304 matching lines @@
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     Node node = mixinApplication.parseNode(resolution.parsing);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, compiler.compilationFailed));
       supertype = mixinApplication.supertype;
-      assert(invariant(node, supertype.element == compiler.objectClass));
+      assert(invariant(node, supertype.isObject));
     } else {
       mixinApplication.supertype = supertype;
     }
 
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
     Link<DartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(namedMixinApplication.interfaces,
                             namedMixinApplication.superclass)
@@ skipping 187 matching lines @@
 
       addAllSupertypes(allSupertypes, supertype);
       for (Link<DartType> interfaces = cls.interfaces;
            !interfaces.isEmpty;
            interfaces = interfaces.tail) {
         addAllSupertypes(allSupertypes, interfaces.head);
       }
       allSupertypes.add(compiler, cls.computeType(resolution));
       cls.allSupertypesAndSelf = allSupertypes.toTypeSet();
     } else {
-      assert(identical(cls, compiler.objectClass));
+      assert(cls == compiler.coreClasses.objectClass);
       cls.allSupertypesAndSelf =
           new OrderedTypeSet.singleton(cls.computeType(resolution));
     }
   }
 
   /**
    * Adds [type] and all supertypes of [type] to [allSupertypes] while
    * substituting type variables.
    */
   void addAllSupertypes(OrderedTypeSetBuilder allSupertypes,
                         InterfaceType type) {
     ClassElement classElement = type.element;
     Link<DartType> supertypes = classElement.allSupertypes;
     assert(invariant(element, supertypes != null,
         message: "Supertypes not computed on $classElement "
                  "during resolution of $element"));
     while (!supertypes.isEmpty) {
       DartType supertype = supertypes.head;
       allSupertypes.add(compiler, supertype.substByContext(type));
       supertypes = supertypes.tail;
     }
   }
 
   isBlackListed(DartType type) {
     LibraryElement lib = element.library;
+    CoreTypes coreTypes = compiler.coreTypes;
     return
       !identical(lib, compiler.coreLibrary) &&
       !compiler.backend.isBackendLibrary(lib) &&
       (type.isDynamic ||
-       identical(type.element, compiler.boolClass) ||
-       identical(type.element, compiler.numClass) ||
-       identical(type.element, compiler.intClass) ||
-       identical(type.element, compiler.doubleClass) ||
-       identical(type.element, compiler.stringClass) ||
-       identical(type.element, compiler.nullClass));
+       type == coreTypes.boolType ||
+       type == coreTypes.numType ||
+       type == coreTypes.intType ||
+       type == coreTypes.doubleType ||
+       type == coreTypes.stringType ||
+       type == coreTypes.nullType);
   }
 }
 
 class ClassSupertypeResolver extends CommonResolverVisitor {
   Scope context;
   ClassElement classElement;
 
   ClassSupertypeResolver(Compiler compiler, ClassElement cls)
     : context = Scope.buildEnclosingScope(cls),
       this.classElement = cls,
       super(compiler);
 
+  CoreClasses get coreClasses => compiler.coreClasses;
+
   void loadSupertype(ClassElement element, Node from) {
     if (!element.isResolved) {
       compiler.resolver.loadSupertypes(element, from);
       element.ensureResolved(resolution);
     }
   }
 
   void visitNodeList(NodeList node) {
     if (node != null) {
       for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
         link.head.accept(this);
       }
     }
   }
 
   void visitClassNode(ClassNode node) {
     if (node.superclass == null) {
-      if (!identical(classElement, compiler.objectClass)) {
-        loadSupertype(compiler.objectClass, node);
+      if (classElement != coreClasses.objectClass) {
+        loadSupertype(coreClasses.objectClass, node);
       }
     } else {
       node.superclass.accept(this);
     }
     visitNodeList(node.interfaces);
   }
 
   void visitEnum(Enum node) {
-    loadSupertype(compiler.objectClass, node);
+    loadSupertype(coreClasses.objectClass, node);
   }
 
   void visitMixinApplication(MixinApplication node) {
     node.superclass.accept(this);
     visitNodeList(node.mixins);
   }
 
   void visitNamedMixinApplication(NamedMixinApplication node) {
     node.superclass.accept(this);
     visitNodeList(node.mixins);
@@ skipping 30 matching lines @@
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(
           node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE,
           {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }