Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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.compile_time_constant_evaluator;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 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 ConstantVariableMixin;
 import 'resolution/operators.dart';
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'tree/tree.dart';
 import 'universe/call_structure.dart' show CallStructure;
 import 'util/util.dart' show Link;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
@@ skipping 125 matching lines @@
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables = new Set<VariableElement>();
 
   final Map<ConstantExpression, ConstantValue> constantValueMap =
       <ConstantExpression, ConstantValue>{};
 
   ConstantCompilerBase(this.compiler, this.constantSystem);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CommonElements get commonElements => compiler.commonElements;
 
   @override
   @deprecated
   ConstantValue getConstantValueForVariable(VariableElement element) {
     ConstantExpression constant = initialVariableValues[element.declaration];
     // TODO(johnniwinther): Support eager evaluation of the constant.
     return constant != null ? getConstantValue(constant) : null;
   }
 
   ConstantExpression compileConstant(VariableElement element) {
@@ skipping 92 matching lines @@
             } else {
               assert(elementType is MethodTypeVariableType);
               reporter.reportErrorMessage(
                   node, MessageKind.TYPE_VARIABLE_FROM_METHOD_NOT_REIFIED);
             }
           } else {
             // We need to throw an exception at runtime.
             expression = null;
           }
         } else {
-          DartType constantType = value.getType(coreTypes);
+          DartType constantType = value.getType(commonElements);
           if (!constantSystem.isSubtype(
               compiler.types, constantType, elementType)) {
             if (isConst) {
               reporter.reportErrorMessage(node, MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               expression = null;
             }
@@ skipping 114 matching lines @@
   final Compiler compiler;
 
   Element get context => elements.analyzedElement;
 
   CompileTimeConstantEvaluator(this.handler, this.elements, this.compiler,
       {bool isConst: false})
       : this.isEvaluatingConstant = isConst;
 
   ConstantSystem get constantSystem => handler.constantSystem;
   Resolution get resolution => compiler.resolution;
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CommonElements get commonElements => compiler.commonElements;
   DiagnosticReporter get reporter => compiler.reporter;
 
   AstConstant evaluate(Node node) {
     // TODO(johnniwinther): should there be a visitErrorNode?
     if (node is ErrorNode) return new ErroneousAstConstant(context, node);
     AstConstant result = node.accept(this);
     assert(invariant(node, !isEvaluatingConstant || result != null,
         message: "No AstConstant computed for the node."));
     return result;
   }
@@ skipping 166 matching lines @@
           new DartString.concat(accumulator, partStringValue.primitiveValue);
     }
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression(subexpressions),
         constantSystem.createString(accumulator));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
-    InterfaceType type = coreTypes.symbolType;
+    InterfaceType type = commonElements.symbolType;
     String text = node.slowNameString;
     List<AstConstant> arguments = <AstConstant>[
       new AstConstant(context, node, new StringConstantExpression(text),
           constantSystem.createString(new LiteralDartString(text)))
     ];
     ConstructorElement constructor = compiler.commonElements.symbolConstructor;
     AstConstant constant = createConstructorInvocation(
         node, type, constructor, CallStructure.ONE_ARG,
         normalizedArguments: arguments);
     return new AstConstant(
@@ skipping 195 matching lines @@
           folded);
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null || condition.isError) {
       return condition;
     } else if (!condition.value.isBool) {
-      DartType conditionType = condition.value.getType(coreTypes);
+      DartType conditionType = condition.value.getType(commonElements);
       if (isEvaluatingConstant) {
         reporter.reportErrorMessage(node.condition, MessageKind.NOT_ASSIGNABLE,
-            {'fromType': conditionType, 'toType': coreTypes.boolType});
+            {'fromType': conditionType, 'toType': commonElements.boolType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || thenExpression.isError) {
       return thenExpression;
     }
     if (elseExpression == null || elseExpression.isError) {
@@ skipping 174 matching lines @@
       List<AstConstant> concreteArguments) {
     var firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
       return reportNotCompileTimeConstant(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
     }
 
     if (!firstArgument.isString) {
-      DartType type = defaultValue.getType(coreTypes);
+      DartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type, 'toType': coreTypes.stringType});
+          {'fromType': type, 'toType': commonElements.stringType});
     }
 
     if (constructor.isIntFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isInt)) {
-      DartType type = defaultValue.getType(coreTypes);
+      DartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type, 'toType': coreTypes.intType});
+          {'fromType': type, 'toType': commonElements.intType});
     }
 
     if (constructor.isBoolFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isBool)) {
-      DartType type = defaultValue.getType(coreTypes);
+      DartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type, 'toType': coreTypes.boolType});
+          {'fromType': type, 'toType': commonElements.boolType});
     }
 
     if (constructor.isStringFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isString)) {
-      DartType type = defaultValue.getType(coreTypes);
+      DartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': type, 'toType': coreTypes.stringType});
+          {'fromType': type, 'toType': commonElements.stringType});
     }
 
     String name = firstArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
       if (concreteArguments.length > 1) {
@@ skipping 149 matching lines @@
         reporter.internalError(send, "Local variable without value.");
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(TypedElement element, AstConstant constant) {
     if (compiler.options.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
-      DartType constantType = constant.value.getType(coreTypes);
+      DartType constantType = constant.value.getType(commonElements);
       if (!constantSystem.isSubtype(
           compiler.types, constantType, elementType)) {
         reporter.withCurrentElement(constant.element, () {
           reporter.reportErrorMessage(constant.node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
@@ skipping 220 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }