Add CoreTypes interface.

pkg/compiler/lib/src/constants/values.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.constants.values;
 
+import '../core_types.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart'
-    show assertDebugMode,
-         Compiler;
+    show assertDebugMode;
 import '../elements/elements.dart'
     show ClassElement,
          Element,
          FunctionElement,
          PrefixElement;
 import '../tree/tree.dart' hide unparse;
 import '../types/types.dart' as ti show TypeMask;
 import '../util/util.dart' show SMI_MASK;
 
 abstract class ConstantValueVisitor<R, A> {
@@ skipping 36 matching lines @@
   bool get isType => false;
   bool get isInterceptor => false;
   bool get isDummy => false;
 
   bool get isNaN => false;
   bool get isMinusZero => false;
   bool get isZero => false;
   bool get isOne => false;
 
   // TODO(johnniwinther): Replace with a 'type' getter.
-  DartType computeType(Compiler compiler);
+  DartType getType(CoreTypes types);
 
   List<ConstantValue> getDependencies();
 
   accept(ConstantValueVisitor visitor, arg);
 
   /// The value of this constant in Dart syntax, if possible.
   ///
   /// For [ConstructedConstantValue]s there is no way to create a valid const
   /// expression from the value so the unparse of these is best effort.
   ///
   /// For the synthetic constants, [DeferredConstantValue],
   /// [DummyConstantValue], [InterceptorConstantValue] the unparse is
   /// descriptive only.
   String unparse();
 
   /// Returns a structured representation of this constant suited for debugging.
   String toStructuredString();
 
   String toString() {
     assertDebugMode("Use Constant.unparse() or Constant.toStructuredString() "
                     "instead of Constant.toString().");
     return toStructuredString();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
-  Element element;
+  FunctionElement element;
 
-  FunctionConstantValue(this.element);
+  FunctionConstantValue(this.element) {
+    assert(element.type != null);
+  }
 
   bool get isFunction => true;
 
   bool operator ==(var other) {
     if (other is !FunctionConstantValue) return false;
     return identical(other.element, element);
   }
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   DartString toDartString() {
     return new DartString.literal(element.name);
   }
 
-  // TODO(johnniwinther): remove computeType.
-  DartType computeType(Compiler compiler) => element.computeType(compiler);
+  DartType getType(CoreTypes types) => element.type;
 
   int get hashCode => (17 * element.hashCode) & 0x7fffffff;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitFunction(this, arg);
 
   String unparse() {
     if (element.isStatic) {
       return '${element.enclosingClass.name}.${element.name}';
     } else {
       return '${element.name}';
@@ skipping 35 matching lines @@
   static const String JsNull = "null";
 
   factory NullConstantValue() => const NullConstantValue._internal();
 
   const NullConstantValue._internal();
 
   bool get isNull => true;
 
   get primitiveValue => null;
 
-  DartType computeType(Compiler compiler) {
-    return compiler.nullClass.computeType(compiler);
-  }
+  DartType getType(CoreTypes types) => types.nullType;
 
   // The magic constant has no meaning. It is just a random value.
   int get hashCode => 785965825;
 
   DartString toDartString() => const LiteralDartString("null");
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitNull(this, arg);
 
   String toStructuredString() => 'NullConstant';
 }
@@ skipping 35 matching lines @@
   bool isUInt31() => primitiveValue >= 0 && primitiveValue < (1 << 31);
 
   bool isUInt32() => primitiveValue >= 0 && primitiveValue < (1 << 32);
 
   bool isPositive() => primitiveValue >= 0;
 
   bool get isZero => primitiveValue == 0;
 
   bool get isOne => primitiveValue == 1;
 
-  DartType computeType(Compiler compiler) {
-    return compiler.intClass.rawType;
-  }
+  DartType getType(CoreTypes types) => types.intType;
 
   // We have to override the equality operator so that ints and doubles are
   // treated as separate constants.
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
     if (other is !IntConstantValue) return false;
     IntConstantValue otherInt = other;
     return primitiveValue == otherInt.primitiveValue;
   }
@@ skipping 34 matching lines @@
 
   bool get isNaN => primitiveValue.isNaN;
 
   // We need to check for the negative sign since -0.0 == 0.0.
   bool get isMinusZero => primitiveValue == 0.0 && primitiveValue.isNegative;
 
   bool get isZero => primitiveValue == 0.0;
 
   bool get isOne => primitiveValue == 1.0;
 
-  DartType computeType(Compiler compiler) {
-    return compiler.doubleClass.rawType;
-  }
+  DartType getType(CoreTypes types) => types.doubleType;
 
   bool operator ==(var other) {
     if (other is !DoubleConstantValue) return false;
     DoubleConstantValue otherDouble = other;
     double otherValue = otherDouble.primitiveValue;
     if (primitiveValue == 0.0 && otherValue == 0.0) {
       return primitiveValue.isNegative == otherValue.isNegative;
     } else if (primitiveValue.isNaN) {
       return otherValue.isNaN;
     } else {
@@ skipping 14 matching lines @@
 
 abstract class BoolConstantValue extends PrimitiveConstantValue {
   factory BoolConstantValue(value) {
     return value ? new TrueConstantValue() : new FalseConstantValue();
   }
 
   const BoolConstantValue._internal();
 
   bool get isBool => true;
 
-  DartType computeType(Compiler compiler) {
-    return compiler.boolClass.rawType;
-  }
+  DartType getType(CoreTypes types) => types.boolType;
 
   BoolConstantValue negate();
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitBool(this, arg);
 
   String toStructuredString() => 'BoolConstant(${unparse()})';
 }
 
 class TrueConstantValue extends BoolConstantValue {
   factory TrueConstantValue() => const TrueConstantValue._internal();
@@ skipping 42 matching lines @@
 
   // TODO(floitsch): cache StringConstants.
   // TODO(floitsch): compute hashcode without calling toString() on the
   // DartString.
   StringConstantValue(DartString value)
       : this.primitiveValue = value,
         this.hashCode = value.slowToString().hashCode;
 
   bool get isString => true;
 
-  DartType computeType(Compiler compiler) {
-    return compiler.stringClass.rawType;
-  }
+  DartType getType(CoreTypes types) => types.stringType;
 
   bool operator ==(var other) {
     if (other is !StringConstantValue) return false;
     StringConstantValue otherString = other;
     return hashCode == otherString.hashCode &&
            primitiveValue == otherString.primitiveValue;
   }
 
   DartString toDartString() => primitiveValue;
 
   int get length => primitiveValue.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitString(this, arg);
 
   // TODO(johnniwinther): Ensure correct escaping.
   String unparse() => '"${primitiveValue.slowToString()}"';
 
   String toStructuredString() => 'StringConstant(${unparse()})';
 }
 
 abstract class ObjectConstantValue extends ConstantValue {
   final InterfaceType type;
 
   ObjectConstantValue(this.type);
 
   bool get isObject => true;
 
-  DartType computeType(Compiler compiler) => type;
+  DartType getType(CoreTypes types) => type;
 
   void _unparseTypeArguments(StringBuffer sb) {
     if (!type.treatAsRaw) {
       sb.write('<');
       sb.write(type.typeArguments.join(', '));
       sb.write('>');
     }
   }
 }
 
@@ skipping 183 matching lines @@
   }
 
   int get hashCode => dispatchedType.hashCode * 43;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitInterceptor(this, arg);
   }
 
-  DartType computeType(Compiler compiler) => const DynamicType();
+  DartType getType(CoreTypes types) => const DynamicType();
 
   String unparse() {
     return 'interceptor($dispatchedType)';
   }
 
   String toStructuredString() {
     return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
   }
 }
 
 // TODO(johnniwinther): Remove this class.
 class DummyConstantValue extends ConstantValue {
   final ti.TypeMask typeMask;
 
   DummyConstantValue(this.typeMask);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
     return other is DummyConstantValue
         && typeMask == other.typeMask;
   }
 
   get hashCode => typeMask.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDummy(this, arg);
 
-  DartType computeType(Compiler compiler) => const DynamicType();
+  DartType getType(CoreTypes types) => const DynamicType();
 
   String unparse() => 'dummy($typeMask)';
 
   String toStructuredString() => 'DummyConstant($typeMask)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   final List<ConstantValue> fields;
   final int hashCode;
 
@@ skipping 95 matching lines @@
         && referenced == other.referenced
         && prefix == other.prefix;
   }
 
   get hashCode => (referenced.hashCode * 17 + prefix.hashCode) & 0x3fffffff;
 
   List<ConstantValue> getDependencies() => <ConstantValue>[referenced];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDeferred(this, arg);
 
-  DartType computeType(Compiler compiler) => referenced.computeType(compiler);
+  DartType getType(CoreTypes types) => referenced.getType(types);
 
   String unparse() => 'deferred(${referenced.unparse()})';
 
   String toStructuredString() => 'DeferredConstant($referenced)';
 }