Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
@@ skipping 405 matching lines @@
   ir.Procedure get runtimeTypeToString =>
       kernel.functions[_backend.helpers.runtimeTypeToString];
 
   ir.Procedure get createRuntimeType =>
       kernel.functions[_backend.helpers.createRuntimeType];
 
   TypeMask get createRuntimeTypeReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.createRuntimeType, _globalInferenceResults);
 
-  ir.Class get objectClass => kernel.classes[_compiler.coreClasses.objectClass];
+  ir.Class get objectClass =>
+      kernel.classes[_compiler.commonElements.objectClass];
 
   ir.Procedure get currentIsolate =>
       kernel.functions[_backend.helpers.currentIsolate];
 
   ir.Procedure get callInIsolate =>
       kernel.functions[_backend.helpers.callInIsolate];
 
   bool isInForeignLibrary(ir.Member member) =>
       _backend.isForeign(getElement(member));
 
@@ skipping 35 matching lines @@
   }
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
   DartType getDartTypeOfListLiteral(ir.ListLiteral list) {
     ast.Node node = getNodeOrNull(list);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(list);
-    return _compiler.coreTypes.listType(getDartType(list.typeArgument));
+    return _compiler.commonElements.listType(getDartType(list.typeArgument));
   }
 
   DartType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
     ast.Node node = getNodeOrNull(literal);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(literal);
-    return _compiler.coreTypes
+    return _compiler.commonElements
         .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
   }
 
   DartType getFunctionReturnType(ir.FunctionNode node) {
     return getDartType(node.returnType);
   }
 
   /// Computes the function type corresponding the signature of [node].
   FunctionType getFunctionType(ir.FunctionNode node) {
     DartType returnType = getFunctionReturnType(node);
@@ skipping 112 matching lines @@
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
       return new native.NativeBehavior();
     }
 
     return native.NativeBehavior.ofJsCall(
         specString,
         codeString,
         _typeLookup(resolveAsRaw: true),
         CURRENT_ELEMENT_SPANNABLE,
         reporter,
-        _compiler.coreTypes);
+        _compiler.commonElements);
   }
 
   /// Computes the [native.NativeBehavior] for a call to the [JS_BUILTIN] function.
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForJsBuiltinCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
       return new native.NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
       return new native.NativeBehavior();
     }
     String specString = _getStringArgument(node, 0);
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new native.NativeBehavior();
     }
     return native.NativeBehavior.ofJsBuiltinCall(
         specString,
         _typeLookup(resolveAsRaw: true),
         CURRENT_ELEMENT_SPANNABLE,
         reporter,
-        _compiler.coreTypes);
+        _compiler.commonElements);
   }
 
   /// Computes the [native.NativeBehavior] for a call to the [JS_EMBEDDED_GLOBAL]
   /// function.
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global expression has no type.");
@@ skipping 14 matching lines @@
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new native.NativeBehavior();
     }
     return native.NativeBehavior.ofJsEmbeddedGlobalCall(
         specString,
         _typeLookup(resolveAsRaw: true),
         CURRENT_ELEMENT_SPANNABLE,
         reporter,
-        _compiler.coreTypes);
+        _compiler.commonElements);
   }
 
   /// Returns `true` is [node] has a `@Native(...)` annotation.
   // TODO(johnniwinther): Cache this for later use.
   bool isNative(ir.Class node) {
     for (ir.Expression annotation in node.annotations) {
       if (annotation is ir.ConstructorInvocation) {
         ConstructorElement target = getElement(annotation.target).declaration;
         if (target.enclosingClass ==
             _compiler.commonElements.nativeAnnotationClass) {
@@ skipping 176 matching lines @@
     astAdapter.reporter.internalError(
         CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
     return null;
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }