Add CoreTypes interface.

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.
 
 part of dart2js;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// Returns the constant for the initializer of [element].
@@ skipping 144 matching lines @@
         if (elementType.isMalformed && !value.value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
             compiler.reportFatalError(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             value = null;
           }
         } else {
-          DartType constantType = value.value.computeType(compiler);
+          DartType constantType = value.value.getType(compiler.coreTypes);
           if (!constantSystem.isSubtype(compiler,
                                         constantType, elementType)) {
             if (isConst) {
               compiler.reportFatalError(
                   node, MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               value = null;
@@ skipping 302 matching lines @@
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (isDeferredUse(send)) {
         return signalNotCompileTimeConstant(send,
             message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
       }
       if (Elements.isStaticOrTopLevelFunction(element)) {
+        FunctionElementX function = element;
+        function.computeType(compiler);
         return new AstConstant(
             context, send, new FunctionConstantExpression(
-                new FunctionConstantValue(element),
-                element));
+                new FunctionConstantValue(function),
+                function));
       } else if (Elements.isStaticOrTopLevelField(element)) {
         ConstantExpression result;
         if (element.isConst) {
           result = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) {
           return new AstConstant(
               context, send,
@@ skipping 92 matching lines @@
               left.expression, op.source, right.expression));
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null) {
       return null;
     } else if (!condition.value.isBool) {
-      DartType conditionType = condition.value.computeType(compiler);
+      DartType conditionType = condition.value.getType(compiler.coreTypes);
       if (isEvaluatingConstant) {
         compiler.reportFatalError(
             node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': compiler.boolClass.rawType});
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || elseExpression == null) {
@@ skipping 110 matching lines @@
       var firstArgument = normalizedArguments[0].value;
       ConstantValue defaultValue = normalizedArguments[1].value;
 
       if (firstArgument.isNull) {
         compiler.reportFatalError(
             send.arguments.head, MessageKind.NULL_NOT_ALLOWED);
         return null;
       }
 
       if (!firstArgument.isString) {
-        DartType type = defaultValue.computeType(compiler);
+        DartType type = defaultValue.getType(compiler.coreTypes);
         compiler.reportFatalError(
             send.arguments.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.stringClass.rawType});
         return null;
       }
 
       if (constructor == compiler.intEnvironment &&
           !(defaultValue.isNull || defaultValue.isInt)) {
-        DartType type = defaultValue.computeType(compiler);
+        DartType type = defaultValue.getType(compiler.coreTypes);
         compiler.reportFatalError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.intClass.rawType});
         return null;
       }
 
       if (constructor == compiler.boolEnvironment &&
           !(defaultValue.isNull || defaultValue.isBool)) {
-        DartType type = defaultValue.computeType(compiler);
+        DartType type = defaultValue.getType(compiler.coreTypes);
         compiler.reportFatalError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.boolClass.rawType});
         return null;
       }
 
       if (constructor == compiler.stringEnvironment &&
           !(defaultValue.isNull || defaultValue.isString)) {
-        DartType type = defaultValue.computeType(compiler);
+        DartType type = defaultValue.getType(compiler.coreTypes);
         compiler.reportFatalError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.stringClass.rawType});
         return null;
       }
 
       String value =
           compiler.fromEnvironment(firstArgument.primitiveValue.slowToString());
 
       if (value == null) {
@@ skipping 127 matching lines @@
       return constant;
     }
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(Node node,
                             TypedElement element,
                             AstConstant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
-      DartType constantType = constant.value.computeType(compiler);
+      DartType constantType = constant.value.getType(compiler.coreTypes);
       if (!constantSystem.isSubtype(compiler, constantType, elementType)) {
         compiler.withCurrentElement(constant.element, () {
           compiler.reportFatalError(
               constant.node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
@@ skipping 168 matching lines @@
     return new AstConstant(
         element,
         element.initializer != null ? element.initializer : element.node,
         constant);
   }
 
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }