Add CoreClasses

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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.
 
 part of native;
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
@@ skipping 80 matching lines @@
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(this.world, Compiler compiler, this.enableLiveTypeAnalysis)
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   Resolution get resolution => compiler.resolution;
 
   DiagnosticReporter get reporter => compiler.reporter;
+  CoreTypes get coreTypes => compiler.coreTypes;
 
   void processNativeClasses(Iterable<LibraryElement> libraries) {
     if (compiler.hasIncrementalSupport) {
       // Since [Set.add] returns bool if an element was added, this restricts
       // [libraries] to ones that haven't already been processed. This saves
       // time during incremental compiles.
       libraries = libraries.where(processedLibraries.add);
     }
     libraries.forEach(processNativeClassesInLibrary);
     if (backend.isolateHelperLibrary != null) {
@@ skipping 353 matching lines @@
       if (matchedTypeConstraints.contains(type)) continue;
       matchedTypeConstraints.add(type);
       if (type is SpecialType) {
         if (type == SpecialType.JsObject) {
           backend.registerInstantiatedType(
               compiler.coreTypes.objectType, world, registry);
         }
         continue;
       }
       if (type is InterfaceType) {
-        if (type.element == compiler.intClass) {
+        if (type == coreTypes.intType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (type.element == compiler.doubleClass) {
+        } else if (type == coreTypes.doubleType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (type.element == compiler.numClass) {
+        } else if (type == coreTypes.numType) {
           backend.registerInstantiatedType(
-              compiler.coreTypes.doubleType, world, registry);
+              coreTypes.doubleType, world, registry);
           backend.registerInstantiatedType(
-              compiler.coreTypes.intType, world, registry);
-        } else if (type.element == compiler.stringClass) {
+              coreTypes.intType, world, registry);
+        } else if (type == coreTypes.stringType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (type.element == compiler.nullClass) {
+        } else if (type == coreTypes.nullType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (type.element == compiler.boolClass) {
+        } else if (type == coreTypes.boolType) {
           backend.registerInstantiatedType(type, world, registry);
         } else if (compiler.types.isSubtype(
                       type, backend.listImplementation.rawType)) {
           backend.registerInstantiatedType(type, world, registry);
         }
       }
       assert(type is DartType);
       enqueueUnusedClassesMatching(
           (nativeClass) => compiler.types.isSubtype(nativeClass.thisType, type),
           cause,
@@ skipping 182 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }