Use elements/types in constants/values

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 '../common.dart';
 import '../core_types.dart';
 import '../elements/elements.dart' show Entity;
 import '../elements/entities.dart';
-import '../elements/resolution_types.dart';
+import '../elements/types.dart';
 import '../tree/dartstring.dart';
 import '../util/util.dart' show Hashing;
 
 enum ConstantValueKind {
   FUNCTION,
   NULL,
   INT,
   DOUBLE,
   BOOL,
   STRING,
@@ skipping 53 matching lines @@
   bool get isDummy => false;
 
   bool get isNaN => false;
   bool get isMinusZero => false;
   bool get isZero => false;
   bool get isOne => false;
   bool get isPositiveInfinity => false;
   bool get isNegativeInfinity => false;
 
   // TODO(johnniwinther): Replace with a 'type' getter.
-  ResolutionDartType getType(CommonElements types);
+  DartType getType(CommonElements 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.
   ///
@@ skipping 11 matching lines @@
     assertDebugMode("Use ConstantValue.toDartText() or "
         "ConstantValue.toStructuredText() "
         "instead of ConstantValue.toString().");
     return toStructuredText();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
   final FunctionEntity element;
   // TODO(johnniwinther): Should the type be derived from [element].
-  final ResolutionFunctionType type;
+  final FunctionType type;
 
   FunctionConstantValue(this.element, this.type);
 
   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);
   }
 
-  ResolutionDartType getType(CommonElements types) => type;
+  DartType getType(CommonElements types) => type;
 
   int get hashCode => (17 * element.hashCode) & 0x7fffffff;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitFunction(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.FUNCTION;
 
   String toDartText() {
     if (element.enclosingClass != null) {
       return '${element.enclosingClass.name}.${element.name}';
@@ skipping 37 matching lines @@
   static const String JsNull = "null";
 
   const factory NullConstantValue() = NullConstantValue._internal;
 
   const NullConstantValue._internal();
 
   bool get isNull => true;
 
   get primitiveValue => null;
 
-  ResolutionDartType getType(CommonElements types) => types.nullType;
+  DartType getType(CommonElements 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);
 
   ConstantValueKind get kind => ConstantValueKind.NULL;
 
@@ skipping 51 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;
 
-  ResolutionDartType getType(CommonElements types) => types.intType;
+  DartType getType(CommonElements 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 40 matching lines @@
   bool get isMinusZero => primitiveValue == 0.0 && primitiveValue.isNegative;
 
   bool get isZero => primitiveValue == 0.0;
 
   bool get isOne => primitiveValue == 1.0;
 
   bool get isPositiveInfinity => primitiveValue == double.INFINITY;
 
   bool get isNegativeInfinity => primitiveValue == -double.INFINITY;
 
-  ResolutionDartType getType(CommonElements types) => types.doubleType;
+  DartType getType(CommonElements 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 16 matching lines @@
 
 abstract class BoolConstantValue extends PrimitiveConstantValue {
   factory BoolConstantValue(value) {
     return value ? new TrueConstantValue() : new FalseConstantValue();
   }
 
   const BoolConstantValue._internal();
 
   bool get isBool => true;
 
-  ResolutionDartType getType(CommonElements types) => types.boolType;
+  DartType getType(CommonElements types) => types.boolType;
 
   BoolConstantValue negate();
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitBool(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.BOOL;
 
   String toStructuredText() => 'BoolConstant(${toDartText()})';
 }
 
@@ skipping 47 matching lines @@
   // DartString.
   StringConstantValue(DartString value)
       : this.primitiveValue = value,
         this.hashCode = value.slowToString().hashCode;
 
   StringConstantValue.fromString(String value)
       : this(new DartString.literal(value));
 
   bool get isString => true;
 
-  ResolutionDartType getType(CommonElements types) => types.stringType;
+  DartType getType(CommonElements types) => types.stringType;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
     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);
 
   ConstantValueKind get kind => ConstantValueKind.STRING;
 
   // TODO(johnniwinther): Ensure correct escaping.
   String toDartText() => '"${primitiveValue.slowToString()}"';
 
   String toStructuredText() => 'StringConstant(${toDartText()})';
 }
 
 abstract class ObjectConstantValue extends ConstantValue {
-  final ResolutionInterfaceType type;
+  final InterfaceType type;
 
   ObjectConstantValue(this.type);
 
   bool get isObject => true;
 
-  ResolutionDartType getType(CommonElements types) => type;
+  DartType getType(CommonElements types) => type;
 
   void _unparseTypeArguments(StringBuffer sb) {
     if (!type.treatAsRaw) {
       sb.write('<');
       sb.write(type.typeArguments.join(', '));
       sb.write('>');
     }
   }
 }
 
 class TypeConstantValue extends ObjectConstantValue {
   /// The user type that this constant represents.
-  final ResolutionDartType representedType;
+  final DartType representedType;
 
-  TypeConstantValue(this.representedType, ResolutionInterfaceType type)
-      : super(type);
+  TypeConstantValue(this.representedType, InterfaceType type) : super(type);
 
   bool get isType => true;
 
   bool operator ==(other) {
     return other is TypeConstantValue &&
         representedType == other.representedType;
   }
 
   int get hashCode => representedType.hashCode * 13;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitType(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.TYPE;
 
   String toDartText() => '$representedType';
 
   String toStructuredText() => 'TypeConstant(${representedType})';
 }
 
 class ListConstantValue extends ObjectConstantValue {
   final List<ConstantValue> entries;
   final int hashCode;
 
-  ListConstantValue(ResolutionInterfaceType type, List<ConstantValue> entries)
+  ListConstantValue(InterfaceType type, List<ConstantValue> entries)
       : this.entries = entries,
         hashCode = Hashing.listHash(entries, Hashing.objectHash(type)),
         super(type);
 
   bool get isList => true;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
     if (other is! ListConstantValue) return false;
     ListConstantValue otherList = other;
@@ skipping 39 matching lines @@
     return sb.toString();
   }
 }
 
 class MapConstantValue extends ObjectConstantValue {
   final List<ConstantValue> keys;
   final List<ConstantValue> values;
   final int hashCode;
   Map<ConstantValue, ConstantValue> _lookupMap;
 
-  MapConstantValue(ResolutionInterfaceType type, List<ConstantValue> keys,
-      List<ConstantValue> values)
+  MapConstantValue(
+      InterfaceType type, List<ConstantValue> keys, List<ConstantValue> values)
       : this.keys = keys,
         this.values = values,
         this.hashCode = Hashing.listHash(
             values, Hashing.listHash(keys, Hashing.objectHash(type))),
         super(type) {
     assert(keys.length == values.length);
   }
 
   bool get isMap => true;
 
@@ skipping 54 matching lines @@
       sb.write(keys[i].toStructuredText());
       sb.write(': ');
       sb.write(values[i].toStructuredText());
     }
     sb.write('})');
     return sb.toString();
   }
 }
 
 class InterceptorConstantValue extends ConstantValue {
-  /// The type for which this interceptor holds the methods.  The constant
-  /// is a dispatch table for this type.
-  final ResolutionDartType dispatchedType;
+  /// The class for which this interceptor holds the methods.  The constant
+  /// is a dispatch table for this class.
+  final ClassEntity cls;
 
-  InterceptorConstantValue(this.dispatchedType);
+  InterceptorConstantValue(this.cls);
 
   bool get isInterceptor => true;
 
   bool operator ==(other) {
-    return other is InterceptorConstantValue &&
-        dispatchedType == other.dispatchedType;
+    return other is InterceptorConstantValue && cls == other.cls;
   }
 
-  int get hashCode => dispatchedType.hashCode * 43;
+  int get hashCode => cls.hashCode * 43;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitInterceptor(this, arg);
   }
 
-  ResolutionDartType getType(CommonElements types) =>
-      const ResolutionDynamicType();
+  DartType getType(CommonElements types) => types.dynamicType;
 
   ConstantValueKind get kind => ConstantValueKind.INTERCEPTOR;
 
   String toDartText() {
-    return 'interceptor($dispatchedType)';
+    return 'interceptor($cls)';
   }
 
   String toStructuredText() {
-    return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
+    return 'InterceptorConstant(${cls.name})';
   }
 }
 
 class SyntheticConstantValue extends ConstantValue {
   final payload;
   final valueKind;
 
   SyntheticConstantValue(this.valueKind, this.payload);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
     return other is SyntheticConstantValue && payload == other.payload;
   }
 
   get hashCode => payload.hashCode * 17 + valueKind.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitSynthetic(this, arg);
   }
 
-  ResolutionDartType getType(CommonElements types) =>
-      const ResolutionDynamicType();
+  DartType getType(CommonElements types) => types.dynamicType;
 
   ConstantValueKind get kind => ConstantValueKind.SYNTHETIC;
 
   String toDartText() => 'synthetic($valueKind, $payload)';
 
   String toStructuredText() => 'SyntheticConstant($valueKind, $payload)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   // TODO(johnniwinther): Make [fields] private to avoid misuse of the map
   // ordering and mutability.
   final Map<FieldEntity, ConstantValue> fields;
   final int hashCode;
 
   ConstructedConstantValue(
-      ResolutionInterfaceType type, Map<FieldEntity, ConstantValue> fields)
+      InterfaceType type, Map<FieldEntity, ConstantValue> fields)
       : this.fields = fields,
         hashCode = Hashing.unorderedMapHash(fields, Hashing.objectHash(type)),
         super(type) {
     assert(type != null);
     assert(!fields.containsValue(null));
   }
 
   bool get isConstructedObject => true;
 
   bool operator ==(var otherVar) {
@@ skipping 12 matching lines @@
   List<ConstantValue> getDependencies() => fields.values.toList();
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitConstructed(this, arg);
   }
 
   ConstantValueKind get kind => ConstantValueKind.CONSTRUCTED;
 
   String toDartText() {
     StringBuffer sb = new StringBuffer();
-    sb.write(type.name);
+    sb.write(type.element.name);
     _unparseTypeArguments(sb);
     sb.write('(');
     int i = 0;
     fields.forEach((FieldEntity field, ConstantValue value) {
       if (i > 0) sb.write(',');
       sb.write(field.name);
       sb.write('=');
       sb.write(value.toDartText());
       i++;
     });
@@ skipping 34 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);
 
-  ResolutionDartType getType(CommonElements types) => referenced.getType(types);
+  DartType getType(CommonElements types) => referenced.getType(types);
 
   ConstantValueKind get kind => ConstantValueKind.DEFERRED;
 
   String toDartText() => 'deferred(${referenced.toDartText()})';
 
   String toStructuredText() {
     return 'DeferredConstant(${referenced.toStructuredText()})';
   }
 }
 
 /// A constant value resulting from a non constant or erroneous constant
 /// expression.
 // TODO(johnniwinther): Expand this to contain the error kind.
 class NonConstantValue extends ConstantValue {
   bool get isConstant => false;
 
   @override
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitNonConstant(this, arg);
   }
 
   @override
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   @override
-  ResolutionDartType getType(CommonElements types) =>
-      const ResolutionDynamicType();
+  DartType getType(CommonElements types) => types.dynamicType;
 
   ConstantValueKind get kind => ConstantValueKind.NON_CONSTANT;
 
   @override
   String toStructuredText() => 'NonConstant';
 
   @override
   String toDartText() => '>>non-constant<<';
 }