Merge CoreTypes and CoreClasses into CommonElements.

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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
-import '../core_types.dart' show CoreTypes;
+import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show FunctionElementX;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
 import '../tokens/token.dart' show BeginGroupToken, Token;
 import '../tokens/token_constants.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
 import '../universe/use.dart' show StaticUse, TypeUse;
@@ skipping 67 matching lines @@
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(Compiler compiler, this.enableLiveTypeAnalysis)
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   Resolution get resolution => compiler.resolution;
 
   DiagnosticReporter get reporter => compiler.reporter;
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CommonElements get commonElements => compiler.commonElements;
 
   void onInstantiatedType(InterfaceType type) {
     if (_unusedClasses.remove(type.element)) {
       _registeredClasses.add(type.element);
     }
   }
 
   WorldImpact processNativeClasses(Iterable<LibraryElement> libraries) {
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     _processNativeClasses(impactBuilder, libraries);
@@ skipping 321 matching lines @@
       WorldImpactBuilder impactBuilder, NativeBehavior behavior, cause) {
     void registerInstantiation(InterfaceType type) {
       impactBuilder.registerTypeUse(new TypeUse.nativeInstantiation(type));
     }
 
     int unusedBefore = _unusedClasses.length;
     Set<ClassElement> matchingClasses = new Set<ClassElement>();
     for (var type in behavior.typesInstantiated) {
       if (type is SpecialType) {
         if (type == SpecialType.JsObject) {
-          registerInstantiation(compiler.coreTypes.objectType);
+          registerInstantiation(compiler.commonElements.objectType);
         }
         continue;
       }
       if (type is InterfaceType) {
-        if (type == coreTypes.intType) {
+        if (type == commonElements.intType) {
           registerInstantiation(type);
-        } else if (type == coreTypes.doubleType) {
+        } else if (type == commonElements.doubleType) {
           registerInstantiation(type);
-        } else if (type == coreTypes.numType) {
-          registerInstantiation(coreTypes.doubleType);
-          registerInstantiation(coreTypes.intType);
-        } else if (type == coreTypes.stringType) {
+        } else if (type == commonElements.numType) {
+          registerInstantiation(commonElements.doubleType);
+          registerInstantiation(commonElements.intType);
+        } else if (type == commonElements.stringType) {
           registerInstantiation(type);
-        } else if (type == coreTypes.nullType) {
+        } else if (type == commonElements.nullType) {
           registerInstantiation(type);
-        } else if (type == coreTypes.boolType) {
+        } else if (type == commonElements.boolType) {
           registerInstantiation(type);
         } else if (compiler.types.isSubtype(
             type, backend.backendClasses.listImplementation.rawType)) {
           registerInstantiation(type);
         }
         // TODO(johnniwinther): Improve spec string precision to handle type
         // arguments and implements relations that preserve generics. Currently
         // we cannot distinguish between `List`, `List<dynamic>`, and
         // `List<int>` and take all to mean `List<E>`; in effect not including
         // any native subclasses of generic classes.
@@ skipping 88 matching lines @@
   /**
    * Handles JS-calls, which can be an instantiation point for types.
    *
    * For example, the following code instantiates and returns native classes
    * that are `_DOMWindowImpl` or a subtype.
    *
    *     JS('_DOMWindowImpl', 'window')
    *
    */
   NativeBehavior resolveJsCall(Send node, ForeignResolver resolver) {
-    return NativeBehavior.ofJsCallSend(
-        node, reporter, compiler.parsingContext, compiler.coreTypes, resolver);
+    return NativeBehavior.ofJsCallSend(node, reporter, compiler.parsingContext,
+        compiler.commonElements, resolver);
   }
 
   /**
    * Handles JS-embedded global calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_EMBEDDED_GLOBAL('String', 'foo')
    *
    */
   NativeBehavior resolveJsEmbeddedGlobalCall(
       Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsEmbeddedGlobalCallSend(
-        node, reporter, compiler.coreTypes, resolver);
+        node, reporter, compiler.commonElements, resolver);
   }
 
   /**
    * Handles JS-compiler builtin calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_BUILTIN('String', 'int2string', 0)
    *
    */
   NativeBehavior resolveJsBuiltinCall(Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsBuiltinCallSend(
-        node, reporter, compiler.coreTypes, resolver);
+        node, reporter, compiler.commonElements, resolver);
   }
 }
 
 class NativeCodegenEnqueuer extends NativeEnqueuerBase {
   final CodeEmitterTask emitter;
 
   final Set<ClassElement> doneAddSubtypes = new Set<ClassElement>();
 
   NativeCodegenEnqueuer(Compiler compiler, this.emitter)
       : super(compiler, compiler.options.enableNativeLiveTypeAnalysis);
@@ skipping 54 matching lines @@
     List<Element> directSubtypes =
         emitter.directSubtypes.putIfAbsent(superclass, () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${_registeredClasses.length} native classes, '
         '${_unusedClasses.length} native classes omitted.');
   }
 }