Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/resolution/enum_creator.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.
 
 library dart2js.resolution.enum_creator;
 
 import '../common.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';
 import '../tokens/keyword.dart' show Keyword;
 import '../tokens/precedence.dart';
 import '../tokens/precedence_constants.dart' as Precedence;
 import '../tokens/token.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 
@@ skipping 173 matching lines @@
 ///       static const A b = const A(0);
 ///       static const A c = const A(1);
 ///
 ///       static const List<A> values = const <A>[b, c];
 ///     }
 ///
 // TODO(johnniwinther): Avoid creating synthesized ASTs for enums when SSA is
 // removed.
 class EnumCreator {
   final DiagnosticReporter reporter;
-  final CoreTypes coreTypes;
+  final CommonElements commonElements;
   final EnumClassElementX enumClass;
 
-  EnumCreator(this.reporter, this.coreTypes, this.enumClass);
+  EnumCreator(this.reporter, this.commonElements, this.enumClass);
 
   void createMembers() {
     Enum node = enumClass.node;
     InterfaceType enumType = enumClass.thisType;
     AstBuilder builder = new AstBuilder(enumClass.position.charOffset);
 
-    InterfaceType intType = coreTypes.intType;
-    InterfaceType stringType = coreTypes.stringType;
+    InterfaceType intType = commonElements.intType;
+    InterfaceType stringType = commonElements.stringType;
 
     EnumFieldElementX addInstanceMember(String name, InterfaceType type) {
       Identifier identifier = builder.identifier(name);
       VariableList variableList =
           new VariableList(builder.modifiers(isFinal: true));
       variableList.type = type;
       EnumFieldElementX variable = new EnumFieldElementX(
           identifier, enumClass, variableList, identifier);
       enumClass.addMember(variable, reporter);
       return variable;
@@ skipping 50 matching lines @@
 
       EnumConstantElementX field = new EnumConstantElementX(
           name, enumClass, variableList, definition, initializer, index);
       enumValues.add(field);
       enumClass.addMember(field, reporter);
       index++;
     }
 
     VariableList valuesVariableList =
         new VariableList(builder.modifiers(isStatic: true, isConst: true));
-    valuesVariableList.type = coreTypes.listType(enumType);
+    valuesVariableList.type = commonElements.listType(enumType);
 
     Identifier valuesIdentifier = builder.identifier('values');
     // TODO(johnniwinther): Add type argument.
     Expression initializer =
         builder.listLiteral(valueReferences, isConst: true);
 
     Node definition = builder.createDefinition(valuesIdentifier, initializer);
 
     EnumFieldElementX valuesVariable = new EnumFieldElementX(valuesIdentifier,
         enumClass, valuesVariableList, definition, initializer);
@@ skipping 14 matching lines @@
     EnumMethodElementX toString = new EnumMethodElementX(
         'toString', enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature =
         new FunctionSignatureX(type: new FunctionType(toString, stringType));
     toString.functionSignature = toStringSignature;
     enumClass.addMember(toString, reporter);
 
     enumClass.enumValues = enumValues;
   }
 }