Add toStructuredText to ConstantExpression and align method names with ConstantValue

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, 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.expressions;
 
 import '../common.dart';
 import '../constants/constant_system.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
@@ skipping 64 matching lines @@
 
   /// Compute the [ConstantValue] for this expression using the [environment]
   /// and the [constantSystem].
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem);
 
   /// Returns the type of this constant expression, if it is independent of the
   /// environment values.
   DartType getKnownType(CoreTypes coreTypes) => null;
 
-  String getText() {
+  /// Returns a text string resembling the Dart code creating this constant.
+  String toDartText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
   }
 
+  /// Returns a text string showing the structure of this constant.
+  String toStructuredText() {
+    StringBuffer sb = new StringBuffer();
+    _createStructuredText(sb);
+    return sb.toString();
+  }
+
+  /// Writes the structure of the constant into [sb].
+  void _createStructuredText(StringBuffer sb);
+
   int _computeHashCode();
 
   int get hashCode {
     if (_hashCode == null) {
       _hashCode = _computeHashCode();
     }
     return _hashCode;
   }
 
   bool _equals(ConstantExpression other);
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! ConstantExpression) return false;
     if (kind != other.kind) return false;
     if (hashCode != other.hashCode) return false;
     return _equals(other);
   }
 
   String toString() {
-    assertDebugMode('Use ConstantExpression.getText() instead of '
+    assertDebugMode('Use ConstantExpression.toDartText() or '
+        'ConstantExpression.toStructuredText() instead of '
         'ConstantExpression.toString()');
-    return getText();
+    return toDartText();
   }
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousConstantExpression extends ConstantExpression {
   ConstantExpressionKind get kind => ConstantExpressionKind.ERRONEOUS;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     // Do nothing. This is an error.
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     // TODO(johnniwinther): Use non-constant values for errors.
     return new NonConstantValue();
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Erroneous()');
+  }
+
+  @override
   int _computeHashCode() => 13;
 
   @override
   bool _equals(ErroneousConstantExpression other) => true;
 }
 
 // TODO(johnniwinther): Avoid the need for this class.
 class SyntheticConstantExpression extends ConstantExpression {
   final SyntheticConstantValue value;
 
   SyntheticConstantExpression(this.value);
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return value;
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Synthetic(value=${value.toStructuredText()})');
+  }
+
+  @override
   int _computeHashCode() => 13 * value.hashCode;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     throw "unsupported";
   }
 
   @override
   bool _equals(SyntheticConstantExpression other) {
     return value == other.value;
   }
@@ skipping 13 matching lines @@
 
   BoolConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BOOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBool(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Bool(value=${primitiveValue})');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createBool(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
@@ skipping 10 matching lines @@
 
   IntConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.INT;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitInt(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Int(value=${primitiveValue})');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createInt(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 17 * primitiveValue.hashCode;
 
   @override
   bool _equals(IntConstantExpression other) {
@@ skipping 10 matching lines @@
 
   DoubleConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DOUBLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDouble(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Double(value=${primitiveValue})');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createDouble(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 19 * primitiveValue.hashCode;
 
   @override
   bool _equals(DoubleConstantExpression other) {
@@ skipping 10 matching lines @@
 
   StringConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitString(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('String(value=${primitiveValue})');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createString(new DartString.literal(primitiveValue));
   }
 
   @override
   int _computeHashCode() => 23 * primitiveValue.hashCode;
 
   @override
   bool _equals(StringConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.stringType;
 }
 
 /// Null literal constant.
 class NullConstantExpression extends PrimitiveConstantExpression {
   NullConstantExpression();
 
   ConstantExpressionKind get kind => ConstantExpressionKind.NULL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitNull(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Null()');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createNull();
   }
 
   get primitiveValue => null;
 
   @override
   int _computeHashCode() => 29;
 
@@ skipping 11 matching lines @@
 
   ListConstantExpression(this.type, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.LIST;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitList(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('List(type=$type,values=[');
+    String delimiter = '';
+    for (ConstantExpression value in values) {
+      sb.write(delimiter);
+      value._createStructuredText(sb);
+      delimiter = ',';
+    }
+    sb.write('])');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createList(type,
         values.map((v) => v.evaluate(environment, constantSystem)).toList());
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ListConstantExpression(
         type, values.map((v) => v.apply(arguments)).toList());
   }
@@ skipping 29 matching lines @@
 
   MapConstantExpression(this.type, this.keys, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.MAP;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Map(type=$type,entries=[');
+    for (int index = 0; index < keys.length; index++) {
+      if (index > 0) {
+        sb.write(',');
+      }
+      keys[index]._createStructuredText(sb);
+      sb.write('->');
+      values[index]._createStructuredText(sb);
+    }
+    sb.write('])');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createMap(
         environment.compiler,
         type,
         keys.map((k) => k.evaluate(environment, constantSystem)).toList(),
         values.map((v) => v.evaluate(environment, constantSystem)).toList());
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
@@ skipping 39 matching lines @@
     assert(type.element == target.enclosingClass);
     assert(!arguments.contains(null));
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONSTRUCTED;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
 
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Constructored(type=$type,constructor=$target,'
+        'callStructure=$callStructure,arguments=[');
+    String delimiter = '';
+    for (ConstantExpression value in arguments) {
+      sb.write(delimiter);
+      value._createStructuredText(sb);
+      delimiter = ',';
+    }
+    sb.write('])');
+  }
+
   Map<FieldElement, ConstantExpression> computeInstanceFields() {
     return target.constantConstructor
         .computeInstanceFields(arguments, callStructure);
   }
 
   InterfaceType computeInstanceType() {
     return target.constantConstructor.computeInstanceType(type);
   }
 
   ConstructedConstantExpression apply(NormalizedArguments arguments) {
@@ skipping 40 matching lines @@
   final List<ConstantExpression> expressions;
 
   ConcatenateConstantExpression(this.expressions);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONCATENATE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConcatenate(this, context);
   }
 
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Concatenate(expressions=[');
+    String delimiter = '';
+    for (ConstantExpression value in expressions) {
+      sb.write(delimiter);
+      value._createStructuredText(sb);
+      delimiter = ',';
+    }
+    sb.write('])');
+  }
+
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ConcatenateConstantExpression(
         expressions.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     DartString accumulator;
     for (ConstantExpression expression in expressions) {
@@ skipping 48 matching lines @@
 
   SymbolConstantExpression(this.name);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.SYMBOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitSymbol(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Symbol(name=$name)');
+  }
+
+  @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(SymbolConstantExpression other) {
     return name == other.name;
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
@@ skipping 14 matching lines @@
     assert(type is GenericType || type is DynamicType);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.TYPE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitType(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Type(type=$type)');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createType(environment.compiler, type);
   }
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
@@ skipping 10 matching lines @@
 
   VariableConstantExpression(this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitVariable(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Variable(element=$element)');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return element.constant.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(VariableConstantExpression other) {
     return element == other.element;
   }
 }
 
 /// Reference to a top-level or static function.
 class FunctionConstantExpression extends ConstantExpression {
   final FunctionElement element;
 
   FunctionConstantExpression(this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.FUNCTION;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitFunction(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Function(element=$element)');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return new FunctionConstantValue(element);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
@@ skipping 14 matching lines @@
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BINARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBinary(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Binary(left=');
+    left._createStructuredText(sb);
+    sb.write(',op=$operator,right=');
+    right._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.lookupBinary(operator).fold(
         left.evaluate(environment, constantSystem),
         right.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BinaryConstantExpression(
         left.apply(arguments), operator, right.apply(arguments));
@@ skipping 95 matching lines @@
 
   IdenticalConstantExpression(this.left, this.right);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.IDENTICAL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIdentical(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Identical(left=');
+    left._createStructuredText(sb);
+    sb.write(',right=');
+    right._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.identity.fold(
         left.evaluate(environment, constantSystem),
         right.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IdenticalConstantExpression(
         left.apply(arguments), right.apply(arguments));
@@ skipping 24 matching lines @@
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.UNARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitUnary(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Unary(op=$operator,expression=');
+    expression._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem
         .lookupUnary(operator)
         .fold(expression.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new UnaryConstantExpression(operator, expression.apply(arguments));
   }
@@ skipping 28 matching lines @@
 
   StringLengthConstantExpression(this.expression);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING_LENGTH;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringLength(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('StringLength(expression=');
+    expression._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     ConstantValue value = expression.evaluate(environment, constantSystem);
     if (value.isString) {
       StringConstantValue stringValue = value;
       return constantSystem.createInt(stringValue.primitiveValue.length);
     }
     return new NonConstantValue();
   }
 
@@ skipping 24 matching lines @@
   final ConstantExpression falseExp;
 
   ConditionalConstantExpression(this.condition, this.trueExp, this.falseExp);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONDITIONAL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConditional(this, context);
   }
 
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Conditional(condition=');
+    condition._createStructuredText(sb);
+    sb.write(',true=');
+    trueExp._createStructuredText(sb);
+    sb.write(',false=');
+    falseExp._createStructuredText(sb);
+    sb.write(')');
+  }
+
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ConditionalConstantExpression(condition.apply(arguments),
         trueExp.apply(arguments), falseExp.apply(arguments));
   }
 
   int get precedence => 3;
 
   @override
   int _computeHashCode() {
     return 13 * condition.hashCode +
@@ skipping 42 matching lines @@
   PositionalArgumentReference(this.index);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.POSITIONAL_REFERENCE;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitPositional(this, context);
   }
 
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Positional(index=$index)');
+  }
+
   ConstantExpression apply(NormalizedArguments arguments) {
     return arguments.getPositionalArgument(index);
   }
 
   @override
   int _computeHashCode() => 13 * index.hashCode;
 
   @override
   bool _equals(PositionalArgumentReference other) => index == other.index;
 
@@ skipping 11 matching lines @@
   NamedArgumentReference(this.name);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.NAMED_REFERENCE;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitNamed(this, context);
   }
 
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Named(name=$name)');
+  }
+
   ConstantExpression apply(NormalizedArguments arguments) {
     return arguments.getNamedArgument(name);
   }
 
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(NamedArgumentReference other) => name == other.name;
 
@@ skipping 30 matching lines @@
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.BOOL_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBoolFromEnvironment(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('bool.fromEnvironment(name=');
+    name._createStructuredText(sb);
+    sb.write(',defaultValue=');
+    defaultValue._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createBool(false);
     }
@@ skipping 30 matching lines @@
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.INT_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIntFromEnvironment(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('int.fromEnvironment(name=');
+    name._createStructuredText(sb);
+    sb.write(',defaultValue=');
+    defaultValue._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createNull();
     }
@@ skipping 32 matching lines @@
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.STRING_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringFromEnvironment(this, context);
   }
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('String.fromEnvironment(name=');
+    name._createStructuredText(sb);
+    sb.write(',defaultValue=');
+    defaultValue._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createNull();
     }
@@ skipping 23 matching lines @@
 /// For example `lib.C`.
 class DeferredConstantExpression extends ConstantExpression {
   final ConstantExpression expression;
   final PrefixElement prefix;
 
   DeferredConstantExpression(this.expression, this.prefix);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DEFERRED;
 
   @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('Deferred(prefix=$prefix,expression=');
+    expression._createStructuredText(sb);
+    sb.write(')');
+  }
+
+  @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return expression.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() {
     return 13 * expression.hashCode;
   }
 
@@ skipping 311 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }