Add kind to 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 '../tree/dartstring.dart';
 import '../util/util.dart' show Hashing;
 
+enum ConstantValueKind {
+  FUNCTION,
+  NULL,
+  INT,
+  DOUBLE,
+  BOOL,
+  STRING,
+  LIST,
+  MAP,
+  CONSTRUCTED,
+  TYPE,
+  INTERCEPTOR,
+  SYNTHETIC,
+  DEFERRED,
+  NON_CONSTANT,
+}
+
 abstract class ConstantValueVisitor<R, A> {
   const ConstantValueVisitor();
 
   R visitFunction(FunctionConstantValue constant, A arg);
   R visitNull(NullConstantValue constant, A arg);
   R visitInt(IntConstantValue constant, A arg);
   R visitDouble(DoubleConstantValue constant, A arg);
   R visitBool(BoolConstantValue constant, A arg);
   R visitString(StringConstantValue constant, A arg);
   R visitList(ListConstantValue constant, A arg);
@@ skipping 52 matching lines @@
   /// expression from the value so the unparse of these is best effort.
   ///
   /// For the synthetic constants, [DeferredConstantValue],
   /// [SyntheticConstantValue], [InterceptorConstantValue] the unparse is
   /// descriptive only.
   String toDartText();
 
   /// Returns a structured representation of this constant suited for debugging.
   String toStructuredText();
 
+  ConstantValueKind get kind;
+
   String toString() {
     assertDebugMode("Use ConstantValue.toDartText() or "
         "ConstantValue.toStructuredText() "
         "instead of ConstantValue.toString().");
     return toStructuredText();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
   FunctionElement element;
@@ skipping 14 matching lines @@
   DartString toDartString() {
     return new DartString.literal(element.name);
   }
 
   DartType getType(CoreTypes types) => element.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) {
       return '${element.enclosingClass.name}.${element.name}';
     } else {
       return '${element.name}';
     }
   }
 
   String toStructuredText() {
     return 'FunctionConstant(${toDartText()})';
@@ skipping 39 matching lines @@
 
   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);
 
+  ConstantValueKind get kind => ConstantValueKind.NULL;
+
   String toStructuredText() => 'NullConstant';
 }
 
 abstract class NumConstantValue extends PrimitiveConstantValue {
   const NumConstantValue();
 
   num get primitiveValue;
 
   bool get isNum => true;
 }
@@ skipping 61 matching lines @@
   }
 
   int get hashCode => primitiveValue & Hashing.SMI_MASK;
 
   DartString toDartString() {
     return new DartString.literal(primitiveValue.toString());
   }
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitInt(this, arg);
 
+  ConstantValueKind get kind => ConstantValueKind.INT;
+
   String toStructuredText() => 'IntConstant(${toDartText()})';
 }
 
 class DoubleConstantValue extends NumConstantValue {
   final double primitiveValue;
 
   factory DoubleConstantValue(double value) {
     if (value.isNaN) {
       return const DoubleConstantValue._internal(double.NAN);
     } else if (value == double.INFINITY) {
@@ skipping 42 matching lines @@
   }
 
   int get hashCode => primitiveValue.hashCode;
 
   DartString toDartString() {
     return new DartString.literal(primitiveValue.toString());
   }
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDouble(this, arg);
 
+  ConstantValueKind get kind => ConstantValueKind.DOUBLE;
+
   String toStructuredText() => 'DoubleConstant(${toDartText()})';
 }
 
 abstract class BoolConstantValue extends PrimitiveConstantValue {
   factory BoolConstantValue(value) {
     return value ? new TrueConstantValue() : new FalseConstantValue();
   }
 
   const BoolConstantValue._internal();
 
   bool get isBool => true;
 
   DartType getType(CoreTypes types) => types.boolType;
 
   BoolConstantValue negate();
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitBool(this, arg);
 
+  ConstantValueKind get kind => ConstantValueKind.BOOL;
+
   String toStructuredText() => 'BoolConstant(${toDartText()})';
 }
 
 class TrueConstantValue extends BoolConstantValue {
   factory TrueConstantValue() => const TrueConstantValue._internal();
 
   const TrueConstantValue._internal() : super._internal();
 
   bool get isTrue => true;
 
@@ skipping 56 matching lines @@
     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 InterfaceType type;
 
   ObjectConstantValue(this.type);
@@ skipping 23 matching lines @@
     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(InterfaceType type, List<ConstantValue> entries)
@@ skipping 15 matching lines @@
     }
     return true;
   }
 
   List<ConstantValue> getDependencies() => entries;
 
   int get length => entries.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitList(this, arg);
 
+  ConstantValueKind get kind => ConstantValueKind.LIST;
+
   String toDartText() {
     StringBuffer sb = new StringBuffer();
     _unparseTypeArguments(sb);
     sb.write('[');
     for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(',');
       sb.write(entries[i].toDartText());
     }
     sb.write(']');
     return sb.toString();
@@ skipping 55 matching lines @@
   int get length => keys.length;
 
   ConstantValue lookup(ConstantValue key) {
     var lookupMap = _lookupMap ??=
         new Map<ConstantValue, ConstantValue>.fromIterables(keys, values);
     return lookupMap[key];
   }
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitMap(this, arg);
 
+  ConstantValueKind get kind => ConstantValueKind.MAP;
+
   String toDartText() {
     StringBuffer sb = new StringBuffer();
     _unparseTypeArguments(sb);
     sb.write('{');
     for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(',');
       sb.write(keys[i].toDartText());
       sb.write(':');
       sb.write(values[i].toDartText());
     }
@@ skipping 34 matching lines @@
   int get hashCode => dispatchedType.hashCode * 43;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitInterceptor(this, arg);
   }
 
   DartType getType(CoreTypes types) => const DynamicType();
 
+  ConstantValueKind get kind => ConstantValueKind.INTERCEPTOR;
+
   String toDartText() {
     return 'interceptor($dispatchedType)';
   }
 
   String toStructuredText() {
     return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
   }
 }
 
 class SyntheticConstantValue extends ConstantValue {
   final payload;
-  final kind;
+  final valueKind;
 
-  SyntheticConstantValue(this.kind, this.payload);
+  SyntheticConstantValue(this.valueKind, this.payload);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
     return other is SyntheticConstantValue && payload == other.payload;
   }
 
-  get hashCode => payload.hashCode * 17 + kind.hashCode;
+  get hashCode => payload.hashCode * 17 + valueKind.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitSynthetic(this, arg);
   }
 
   DartType getType(CoreTypes types) => const DynamicType();
 
-  String toDartText() => 'synthetic($kind, $payload)';
+  ConstantValueKind get kind => ConstantValueKind.SYNTHETIC;
 
-  String toStructuredText() => 'SyntheticConstant($kind, $payload)';
+  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 int hashCode;
 
   ConstructedConstantValue(
       InterfaceType type, Map<FieldElement, ConstantValue> fields)
@@ skipping 18 matching lines @@
     }
     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) {
       if (i > 0) sb.write(',');
       sb.write(field.name);
       sb.write('=');
@@ skipping 39 matching lines @@
   }
 
   get hashCode => (referenced.hashCode * 17 + prefix.hashCode) & 0x3fffffff;
 
   List<ConstantValue> getDependencies() => <ConstantValue>[referenced];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDeferred(this, arg);
 
   DartType getType(CoreTypes 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
   DartType getType(CoreTypes types) => const DynamicType();
 
+  ConstantValueKind get kind => ConstantValueKind.NON_CONSTANT;
+
   @override
   String toStructuredText() => 'NonConstant';
 
   @override
   String toDartText() => '>>non-constant<<';
 }