Use Entity instead of Element in ConstantValue

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 '../dart_types.dart';
-import '../elements/elements.dart'
-    show FieldElement, FunctionElement, PrefixElement;
+import '../elements/elements.dart' show Entity;
+import '../elements/entities.dart';
 import '../tree/dartstring.dart';
 import '../util/util.dart' show Hashing;
 
 enum ConstantValueKind {
   FUNCTION,
   NULL,
   INT,
   DOUBLE,
   BOOL,
   STRING,
@@ skipping 83 matching lines @@
 
   String toString() {
     assertDebugMode("Use ConstantValue.toDartText() or "
         "ConstantValue.toStructuredText() "
         "instead of ConstantValue.toString().");
     return toStructuredText();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
-  FunctionElement element;
+  final FunctionEntity element;
+  // TODO(johnniwinther): Should the type be derived from [element].
+  final FunctionType type;
 
-  FunctionConstantValue(this.element) {
-    assert(element.type != null);
-  }
+  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);
   }
 
-  DartType getType(CommonElements types) => element.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.isStatic) {
+    if (element.enclosingClass != null) {
       return '${element.enclosingClass.name}.${element.name}';
     } else {
       return '${element.name}';
     }
   }
 
   String toStructuredText() {
     return 'FunctionConstant(${toDartText()})';
   }
 }
@@ skipping 540 matching lines @@
   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<FieldElement, ConstantValue> fields;
+  final Map<FieldEntity, ConstantValue> fields;
   final int hashCode;
 
   ConstructedConstantValue(
-      InterfaceType type, Map<FieldElement, 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) {
     if (identical(this, otherVar)) return true;
     if (otherVar is! ConstructedConstantValue) return false;
     ConstructedConstantValue other = otherVar;
     if (hashCode != other.hashCode) return false;
     if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
-    for (FieldElement field in fields.keys) {
+    for (FieldEntity field in fields.keys) {
       if (fields[field] != other.fields[field]) return false;
     }
     return true;
   }
 
   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);
     _unparseTypeArguments(sb);
     sb.write('(');
     int i = 0;
-    fields.forEach((FieldElement field, ConstantValue value) {
+    fields.forEach((FieldEntity field, ConstantValue value) {
       if (i > 0) sb.write(',');
       sb.write(field.name);
       sb.write('=');
       sb.write(value.toDartText());
       i++;
     });
     sb.write(')');
     return sb.toString();
   }
 
   String toStructuredText() {
     StringBuffer sb = new StringBuffer();
     sb.write('ConstructedConstant(');
     sb.write(type);
     sb.write('(');
     int i = 0;
-    fields.forEach((FieldElement field, ConstantValue value) {
+    fields.forEach((FieldEntity field, ConstantValue value) {
       if (i > 0) sb.write(',');
       sb.write(field.name);
       sb.write('=');
       sb.write(value.toStructuredText());
       i++;
     });
     sb.write('))');
     return sb.toString();
   }
 }
 
 /// A reference to a constant in another output unit.
 /// Used for referring to deferred constants.
 class DeferredConstantValue extends ConstantValue {
   DeferredConstantValue(this.referenced, this.prefix);
 
   final ConstantValue referenced;
-  final PrefixElement prefix;
+  final Entity prefix;
 
   bool get isReference => true;
 
   bool operator ==(other) {
     return other is DeferredConstantValue &&
         referenced == other.referenced &&
         prefix == other.prefix;
   }
 
   get hashCode => (referenced.hashCode * 17 + prefix.hashCode) & 0x3fffffff;
@@ skipping 31 matching lines @@
   DartType getType(CommonElements types) => const DynamicType();
 
   ConstantValueKind get kind => ConstantValueKind.NON_CONSTANT;
 
   @override
   String toStructuredText() => 'NonConstant';
 
   @override
   String toDartText() => '>>non-constant<<';
 }