Add toStructuredText to ConstantExpression and align method names with 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'
@@ skipping 60 matching lines @@
   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],
   /// [SyntheticConstantValue], [InterceptorConstantValue] the unparse is
   /// descriptive only.
-  String unparse();
+  String toDartText();
 
   /// Returns a structured representation of this constant suited for debugging.
-  String toStructuredString();
+  String toStructuredText();
 
   String toString() {
-    assertDebugMode("Use Constant.unparse() or Constant.toStructuredString() "
-        "instead of Constant.toString().");
-    return toStructuredString();
+    assertDebugMode("Use ConstantValue.toDartText() or "
+        "ConstantValue.toStructuredText() "
+        "instead of ConstantValue.toString().");
+    return toStructuredText();
   }
 }
 
 class FunctionConstantValue extends ConstantValue {
   FunctionElement 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);
   }
 
   DartType getType(CoreTypes types) => element.type;
 
   int get hashCode => (17 * element.hashCode) & 0x7fffffff;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitFunction(this, arg);
 
-  String unparse() {
+  String toDartText() {
     if (element.isStatic) {
       return '${element.enclosingClass.name}.${element.name}';
     } else {
       return '${element.name}';
     }
   }
 
-  String toStructuredString() {
-    return 'FunctionConstant(${unparse()})';
+  String toStructuredText() {
+    return 'FunctionConstant(${toDartText()})';
   }
 }
 
 abstract class PrimitiveConstantValue extends ConstantValue {
   get primitiveValue;
 
   const PrimitiveConstantValue();
 
   bool get isPrimitive => true;
 
   bool operator ==(var other) {
     if (other is! PrimitiveConstantValue) return false;
     PrimitiveConstantValue otherPrimitive = other;
     // We use == instead of 'identical' so that DartStrings compare correctly.
     return primitiveValue == otherPrimitive.primitiveValue;
   }
 
   int get hashCode => throw new UnsupportedError('PrimitiveConstant.hashCode');
 
   // Primitive constants don't have dependencies.
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   DartString toDartString();
 
   /// This value in Dart syntax.
-  String unparse() => primitiveValue.toString();
+  String toDartText() => primitiveValue.toString();
 }
 
 class NullConstantValue extends PrimitiveConstantValue {
   /** The value a Dart null is compiled to in JavaScript. */
   static const String JsNull = "null";
 
   factory NullConstantValue() => const NullConstantValue._internal();
 
   const NullConstantValue._internal();
 
   bool get isNull => true;
 
   get primitiveValue => null;
 
   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';
+  String toStructuredText() => 'NullConstant';
 }
 
 abstract class NumConstantValue extends PrimitiveConstantValue {
   const NumConstantValue();
 
   num get primitiveValue;
 
   bool get isNum => true;
 }
 
@@ skipping 60 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);
 
-  String toStructuredString() => 'IntConstant(${unparse()})';
+  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) {
       return const DoubleConstantValue._internal(double.INFINITY);
@@ skipping 41 matching lines @@
   }
 
   int get hashCode => primitiveValue.hashCode;
 
   DartString toDartString() {
     return new DartString.literal(primitiveValue.toString());
   }
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDouble(this, arg);
 
-  String toStructuredString() => 'DoubleConstant(${unparse()})';
+  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);
 
-  String toStructuredString() => 'BoolConstant(${unparse()})';
+  String toStructuredText() => 'BoolConstant(${toDartText()})';
 }
 
 class TrueConstantValue extends BoolConstantValue {
   factory TrueConstantValue() => const TrueConstantValue._internal();
 
   const TrueConstantValue._internal() : super._internal();
 
   bool get isTrue => true;
 
   bool get primitiveValue => true;
@@ skipping 56 matching lines @@
         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 toDartText() => '"${primitiveValue.slowToString()}"';
 
-  String toStructuredString() => 'StringConstant(${unparse()})';
+  String toStructuredText() => 'StringConstant(${toDartText()})';
 }
 
 abstract class ObjectConstantValue extends ConstantValue {
   final InterfaceType type;
 
   ObjectConstantValue(this.type);
 
   bool get isObject => true;
 
   DartType getType(CoreTypes types) => type;
@@ skipping 19 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);
 
-  String unparse() => '$representedType';
+  String toDartText() => '$representedType';
 
-  String toStructuredString() => 'TypeConstant(${representedType})';
+  String toStructuredText() => 'TypeConstant(${representedType})';
 }
 
 class ListConstantValue extends ObjectConstantValue {
   final List<ConstantValue> entries;
   final int hashCode;
 
   ListConstantValue(InterfaceType type, List<ConstantValue> entries)
       : this.entries = entries,
         hashCode = Hashing.listHash(entries, Hashing.objectHash(type)),
         super(type);
@@ skipping 12 matching lines @@
     }
     return true;
   }
 
   List<ConstantValue> getDependencies() => entries;
 
   int get length => entries.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitList(this, arg);
 
-  String unparse() {
+  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].unparse());
+      sb.write(entries[i].toDartText());
     }
     sb.write(']');
     return sb.toString();
   }
 
-  String toStructuredString() {
+  String toStructuredText() {
     StringBuffer sb = new StringBuffer();
     sb.write('ListConstant(');
     _unparseTypeArguments(sb);
     sb.write('[');
     for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(', ');
-      sb.write(entries[i].toStructuredString());
+      sb.write(entries[i].toStructuredText());
     }
     sb.write('])');
     return sb.toString();
   }
 }
 
 class MapConstantValue extends ObjectConstantValue {
   final List<ConstantValue> keys;
   final List<ConstantValue> values;
   final int hashCode;
@@ skipping 35 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);
 
-  String unparse() {
+  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].unparse());
+      sb.write(keys[i].toDartText());
       sb.write(':');
-      sb.write(values[i].unparse());
+      sb.write(values[i].toDartText());
     }
     sb.write('}');
     return sb.toString();
   }
 
-  String toStructuredString() {
+  String toStructuredText() {
     StringBuffer sb = new StringBuffer();
     sb.write('MapConstant(');
     _unparseTypeArguments(sb);
     sb.write('{');
     for (int i = 0; i < length; i++) {
       if (i > 0) sb.write(', ');
-      sb.write(keys[i].toStructuredString());
+      sb.write(keys[i].toStructuredText());
       sb.write(': ');
-      sb.write(values[i].toStructuredString());
+      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 DartType dispatchedType;
@@ skipping 10 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();
 
-  String unparse() {
+  String toDartText() {
     return 'interceptor($dispatchedType)';
   }
 
-  String toStructuredString() {
+  String toStructuredText() {
     return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
   }
 }
 
 class SyntheticConstantValue extends ConstantValue {
   final payload;
   final kind;
 
   SyntheticConstantValue(this.kind, this.payload);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
     return other is SyntheticConstantValue && payload == other.payload;
   }
 
   get hashCode => payload.hashCode * 17 + kind.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitSynthetic(this, arg);
   }
 
   DartType getType(CoreTypes types) => const DynamicType();
 
-  String unparse() => 'synthetic($kind, $payload)';
+  String toDartText() => 'synthetic($kind, $payload)';
 
-  String toStructuredString() => 'SyntheticConstant($kind, $payload)';
+  String toStructuredText() => 'SyntheticConstant($kind, $payload)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   final Map<FieldElement, ConstantValue> fields;
   final int hashCode;
 
   ConstructedConstantValue(
       InterfaceType type, Map<FieldElement, ConstantValue> fields)
       : this.fields = fields,
         hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
@@ skipping 16 matching lines @@
     }
     return true;
   }
 
   List<ConstantValue> getDependencies() => fields.values.toList();
 
   accept(ConstantValueVisitor visitor, arg) {
     return visitor.visitConstructed(this, arg);
   }
 
-  String unparse() {
+  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('=');
-      sb.write(value.unparse());
+      sb.write(value.toDartText());
       i++;
     });
     sb.write(')');
     return sb.toString();
   }
 
-  String toStructuredString() {
+  String toStructuredText() {
     StringBuffer sb = new StringBuffer();
     sb.write('ConstructedConstant(');
     sb.write(type);
     sb.write('(');
     int i = 0;
     fields.forEach((FieldElement field, ConstantValue value) {
       if (i > 0) sb.write(',');
       sb.write(field.name);
       sb.write('=');
-      sb.write(value.toStructuredString());
+      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 {
@@ skipping 11 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);
 
-  String unparse() => 'deferred(${referenced.unparse()})';
+  String toDartText() => 'deferred(${referenced.toDartText()})';
 
-  String toStructuredString() => 'DeferredConstant($referenced)';
+  String toStructuredText() => 'DeferredConstant($referenced)';
 }
 
 /// 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) {
     // TODO(johnniwinther): Should this be part of the visiting?
   }
 
   @override
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   @override
   DartType getType(CoreTypes types) => const DynamicType();
 
   @override
-  String toStructuredString() => 'NonConstant';
+  String toStructuredText() => 'NonConstant';
 
   @override
-  String unparse() => '>>non-constant<<';
+  String toDartText() => '>>non-constant<<';
 }