Remove ConstantExpression.value

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 '../constants/constant_system.dart';
 import '../dart2jslib.dart' show assertDebugMode, Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
@@ skipping 243 matching lines @@
 ///
 /// There is no one-to-one mapping between [ConstantExpression] and
 /// [ConstantValue], because different expressions can denote the same constant.
 /// For instance, multiple `const` constructors may be used to create the same
 /// object, and different `const` variables may hold the same value.
 abstract class ConstantExpression {
   int _hashCode;
 
   ConstantExpressionKind get kind;
 
-  /// Returns the value of this constant expression.
-  // TODO(johnniwinther): Replace this with an evaluation method that takes
-  // a constant system and an environment.
-  ConstantValue get value;
-
   // TODO(johnniwinther): Unify precedence handled between constants, front-end
   // and back-end.
   int get precedence => 16;
 
   accept(ConstantExpressionVisitor visitor, [context]);
 
   /// Substitute free variables using arguments.
   ConstantExpression apply(NormalizedArguments arguments) => this;
 
   /// Compute the [ConstantValue] for this expression using the [environment]
@@ skipping 28 matching lines @@
 
   String toString() {
     assertDebugMode('Use ConstantExpression.getText() instead of '
                     'ConstantExpression.toString()');
     return getText();
   }
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousConstantExpression extends ConstantExpression {
-  final PrimitiveConstantValue value = new NullConstantValue();
-
   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 value;
+    return new NonConstantValue();
   }
 
   @override
   int _computeHashCode() => 13;
 
   @override
   bool _equals(ErroneousConstantExpression other) => true;
 }
 
 /// A boolean, int, double, string, or null constant.
 abstract class PrimitiveConstantExpression extends ConstantExpression {
-  final PrimitiveConstantValue value;
-
-  PrimitiveConstantExpression(this.value);
-
   /// The primitive value of this contant expression.
   get primitiveValue;
 }
 
 /// Boolean literal constant.
 class BoolConstantExpression extends PrimitiveConstantExpression {
   final bool primitiveValue;
 
-  BoolConstantExpression(this.primitiveValue,
-                         PrimitiveConstantValue value) : super(value);
+  BoolConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BOOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBool(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.createBool(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// Integer literal constant.
 class IntConstantExpression extends PrimitiveConstantExpression {
   final int primitiveValue;
 
-  IntConstantExpression(this.primitiveValue,
-                        PrimitiveConstantValue value) : super(value);
+  IntConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.INT;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitInt(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.createInt(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 17 * primitiveValue.hashCode;
 
   @override
   bool _equals(IntConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// Double literal constant.
 class DoubleConstantExpression extends PrimitiveConstantExpression {
   final double primitiveValue;
 
-  DoubleConstantExpression(this.primitiveValue,
-                           PrimitiveConstantValue value) : super(value);
+  DoubleConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DOUBLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDouble(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.createDouble(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 19 * primitiveValue.hashCode;
 
   @override
   bool _equals(DoubleConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// String literal constant.
 class StringConstantExpression extends PrimitiveConstantExpression {
   final String primitiveValue;
 
-  StringConstantExpression(this.primitiveValue,
-                           PrimitiveConstantValue value) : super(value);
+  StringConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitString(this, context);
   }
 
   @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;
   }
 }
 
 /// Null literal constant.
 class NullConstantExpression extends PrimitiveConstantExpression {
-  NullConstantExpression(PrimitiveConstantValue value) : super(value);
+  NullConstantExpression();
 
   ConstantExpressionKind get kind => ConstantExpressionKind.NULL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitNull(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.createNull();
   }
 
   get primitiveValue => null;
 
   @override
   int _computeHashCode() => 29;
 
   @override
   bool _equals(NullConstantExpression other) => true;
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
-  final ListConstantValue value;
   final InterfaceType type;
   final List<ConstantExpression> values;
 
-  ListConstantExpression(this.value, this.type, this.values);
+  ListConstantExpression(this.type, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.LIST;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitList(this, context);
   }
 
   @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(null, type,
-        values.map((v) => v.apply(arguments)).toList());
+    return new ListConstantExpression(
+        type, values.map((v) => v.apply(arguments)).toList());
   }
 
   @override
   int _computeHashCode() {
     int hashCode = 13 * type.hashCode + 17 * values.length;
     for (ConstantExpression value in values) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
 
   @override
   bool _equals(ListConstantExpression other) {
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 }
 
 /// Literal map constant.
 class MapConstantExpression extends ConstantExpression {
-  final MapConstantValue value;
   final InterfaceType type;
   final List<ConstantExpression> keys;
   final List<ConstantExpression> values;
 
-  MapConstantExpression(this.value, this.type, this.keys, this.values);
+  MapConstantExpression(this.type, this.keys, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.MAP;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
 
   @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) {
-    return new MapConstantExpression(null, type,
+    return new MapConstantExpression(
+        type,
         keys.map((k) => k.apply(arguments)).toList(),
         values.map((v) => v.apply(arguments)).toList());
   }
 
   @override
   int _computeHashCode() {
     int hashCode = 13 * type.hashCode + 17 * values.length;
     for (ConstantExpression value in values) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
 
   @override
   bool _equals(MapConstantExpression other) {
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (keys[i] != other.keys[i]) return false;
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final InterfaceType type;
   final ConstructorElement target;
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpression(
-      this.value,
       this.type,
       this.target,
       this.callStructure,
       this.arguments) {
     assert(type.element == target.enclosingClass);
     assert(!arguments.contains(null));
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONSTRUCTED;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
 
   Map<FieldElement, ConstantExpression> computeInstanceFields() {
     return target.constantConstructor.computeInstanceFields(
         arguments, callStructure);
   }
 
   InterfaceType computeInstanceType() {
     return target.constantConstructor.computeInstanceType(type);
   }
 
   ConstructedConstantExpression apply(NormalizedArguments arguments) {
-    return new ConstructedConstantExpression(null,
+    return new ConstructedConstantExpression(
         type, target, callStructure,
         this.arguments.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     Map<FieldElement, ConstantValue> fieldValues =
         <FieldElement, ConstantValue>{};
     computeInstanceFields().forEach(
@@ skipping 22 matching lines @@
     if (callStructure != other.callStructure) return false;
     for (int i = 0; i < arguments.length; i++) {
       if (arguments[i] != other.arguments[i]) return false;
     }
     return true;
   }
 }
 
 /// String literal with juxtaposition and/or interpolations.
 class ConcatenateConstantExpression extends ConstantExpression {
-  final StringConstantValue value;
   final List<ConstantExpression> expressions;
 
-  ConcatenateConstantExpression(this.value, this.expressions);
+  ConcatenateConstantExpression(this.expressions);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONCATENATE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConcatenate(this, context);
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
-    return new ConcatenateConstantExpression(null,
+    return new ConcatenateConstantExpression(
         expressions.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     DartString accumulator;
     for (ConstantExpression expression in expressions) {
       ConstantValue value = expression.evaluate(environment, constantSystem);
       DartString valueString;
@@ skipping 32 matching lines @@
     if (expressions.length != other.expressions.length) return false;
     for (int i = 0; i < expressions.length; i++) {
       if (expressions[i] != other.expressions[i]) return false;
     }
     return true;
   }
 }
 
 /// Symbol literal.
 class SymbolConstantExpression extends ConstantExpression {
-  final ConstructedConstantValue value;
   final String name;
 
-  SymbolConstantExpression(this.value, this.name);
+  SymbolConstantExpression(this.name);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.SYMBOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitSymbol(this, context);
   }
 
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(SymbolConstantExpression other) {
     return name == other.name;
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     // TODO(johnniwinther): Implement this.
     throw new UnsupportedError('SymbolConstantExpression.evaluate');
   }
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
-  final TypeConstantValue value;
   /// Either [DynamicType] or a raw [GenericType].
   final DartType type;
 
-  TypeConstantExpression(this.value, this.type) {
+  TypeConstantExpression(this.type) {
     assert(type is GenericType || type is DynamicType);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.TYPE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitType(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.createType(environment.compiler, type);
   }
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
 }
 
 /// Reference to a constant local, top-level, or static variable.
 class VariableConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final VariableElement element;
 
-  VariableConstantExpression(this.value, this.element);
+  VariableConstantExpression(this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitVariable(this, context);
   }
 
   @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 FunctionConstantValue value;
   final FunctionElement element;
 
-  FunctionConstantExpression(this.value, this.element);
+  FunctionConstantExpression(this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.FUNCTION;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitFunction(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return new FunctionConstantValue(element);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
 }
 
 /// A constant binary expression like `a * b`.
 class BinaryConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression left;
   final BinaryOperator operator;
   final ConstantExpression right;
 
-  BinaryConstantExpression(this.value, this.left, this.operator, this.right) {
+  BinaryConstantExpression(this.left, this.operator, this.right) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BINARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBinary(this, context);
   }
 
   @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(
-        value,
         left.apply(arguments),
         operator,
         right.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
   @override
   int _computeHashCode() {
     return 13 * operator.hashCode +
@@ skipping 26 matching lines @@
     BinaryOperatorKind.GT: 7,
     BinaryOperatorKind.LT: 7,
     BinaryOperatorKind.GTEQ: 7,
     BinaryOperatorKind.LTEQ: 7,
     BinaryOperatorKind.MOD: 13,
   };
 }
 
 /// A constant identical invocation like `identical(a, b)`.
 class IdenticalConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression left;
   final ConstantExpression right;
 
-  IdenticalConstantExpression(this.value, this.left, this.right);
+  IdenticalConstantExpression(this.left, this.right);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.IDENTICAL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIdentical(this, context);
   }
 
   @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(
-        value,
         left.apply(arguments),
         right.apply(arguments));
   }
 
   int get precedence => 15;
 
   @override
   int _computeHashCode() {
     return 17 * left.hashCode +
            19 * right.hashCode;
   }
 
   @override
   bool _equals(IdenticalConstantExpression other) {
     return left == other.left &&
            right == other.right;
   }
 }
 
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final UnaryOperator operator;
   final ConstantExpression expression;
 
-  UnaryConstantExpression(this.value, this.operator, this.expression) {
+  UnaryConstantExpression(this.operator, this.expression) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.UNARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitUnary(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return constantSystem.lookupUnary(operator).fold(
         expression.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new UnaryConstantExpression(
-        value,
         operator,
         expression.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
   @override
   int _computeHashCode() {
     return 13 * operator.hashCode +
            17 * expression.hashCode;
   }
 
   @override
   bool _equals(UnaryConstantExpression other) {
     return operator == other.operator &&
            expression == other.expression;
   }
 
   static const Map<UnaryOperatorKind, int> PRECEDENCE_MAP = const {
     UnaryOperatorKind.NOT: 14,
     UnaryOperatorKind.COMPLEMENT: 14,
     UnaryOperatorKind.NEGATE: 14,
   };
 }
 
 
 /// A string length constant expression like `a.length`.
 class StringLengthConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression expression;
 
-  StringLengthConstantExpression(this.value, this.expression);
+  StringLengthConstantExpression(this.expression);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING_LENGTH;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringLength(this, context);
   }
 
   @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();
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
-    return new StringLengthConstantExpression(
-        value,
-        expression.apply(arguments));
+    return new StringLengthConstantExpression(expression.apply(arguments));
   }
 
   int get precedence => 15;
 
   @override
   int _computeHashCode() {
     return 23 * expression.hashCode;
   }
 
   @override
   bool _equals(StringLengthConstantExpression other) {
     return expression == other.expression;
   }
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
-  ConditionalConstantExpression(this.value,
-                                this.condition,
+  ConditionalConstantExpression(this.condition,
                                 this.trueExp,
                                 this.falseExp);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONDITIONAL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConditional(this, context);
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ConditionalConstantExpression(
-        value,
         condition.apply(arguments),
         trueExp.apply(arguments),
         falseExp.apply(arguments));
   }
 
   int get precedence => 3;
 
   @override
   int _computeHashCode() {
     return 13 * condition.hashCode +
@@ skipping 34 matching lines @@
   PositionalArgumentReference(this.index);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.POSITIONAL_REFERENCE;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitPositional(this, context);
   }
 
-  ConstantValue get value {
-    throw new UnsupportedError('PositionalArgumentReference.value');
-  }
-
   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);
   }
 
-  ConstantValue get value {
-    throw new UnsupportedError('NamedArgumentReference.value');
-  }
-
   ConstantExpression apply(NormalizedArguments arguments) {
     return arguments.getNamedArgument(name);
   }
 
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(NamedArgumentReference other) => name == other.name;
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     throw new UnsupportedError('NamedArgumentReference.evaluate');
   }
 }
 
 abstract class FromEnvironmentConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression name;
   final ConstantExpression defaultValue;
 
-  FromEnvironmentConstantExpression(this.value, this.name, this.defaultValue);
+  FromEnvironmentConstantExpression(this.name, this.defaultValue);
 
   @override
   int _computeHashCode() {
     return 13 * name.hashCode +
            17 * defaultValue.hashCode;
   }
 
   @override
   bool _equals(FromEnvironmentConstantExpression other) {
     return name == other.name &&
            defaultValue == other.defaultValue;
   }
 }
 
 /// A `const bool.fromEnvironment` constant.
 class BoolFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   BoolFromEnvironmentConstantExpression(
-      ConstantValue value,
       ConstantExpression name,
       ConstantExpression defaultValue)
-      : super(value, name, defaultValue);
+      : super(name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.BOOL_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBoolFromEnvironment(this, context);
   }
 
   @override
@@ skipping 18 matching lines @@
       return constantSystem.createBool(true);
     } else if (text == 'false') {
       return constantSystem.createBool(false);
     } else {
       return defaultConstantValue;
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BoolFromEnvironmentConstantExpression(
-        null,
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A `const int.fromEnvironment` constant.
 class IntFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   IntFromEnvironmentConstantExpression(
-      ConstantValue value,
       ConstantExpression name,
       ConstantExpression defaultValue)
-      : super(value, name, defaultValue);
+      : super(name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.INT_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIntFromEnvironment(this, context);
   }
 
   @override
@@ skipping 20 matching lines @@
     }
     if (value == null) {
       return defaultConstantValue;
     } else {
       return constantSystem.createInt(value);
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IntFromEnvironmentConstantExpression(
-        null,
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A `const String.fromEnvironment` constant.
 class StringFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   StringFromEnvironmentConstantExpression(
-      ConstantValue value,
       ConstantExpression name,
       ConstantExpression defaultValue)
-      : super(value, name, defaultValue);
+      : super(name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.STRING_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringFromEnvironment(this, context);
   }
 
   @override
@@ skipping 16 matching lines @@
         nameStringConstantValue.primitiveValue.slowToString());
     if (text == null) {
       return defaultConstantValue;
     } else {
       return constantSystem.createString(new DartString.literal(text));
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new StringFromEnvironmentConstantExpression(
-        null,
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A constant expression referenced with a deferred prefix.
 /// For example `lib.C`.
 class DeferredConstantExpression extends ConstantExpression {
-  final ConstantValue value;
   final ConstantExpression expression;
   final PrefixElement prefix;
 
-  DeferredConstantExpression(this.value, this.expression, this.prefix);
+  DeferredConstantExpression(this.expression, this.prefix);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DEFERRED;
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return expression.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() {
     return 13 * expression.hashCode;
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new DeferredConstantExpression(
-        value, expression.apply(arguments), prefix);
+        expression.apply(arguments), prefix);
   }
 
   @override
   bool _equals(DeferredConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDeferred(this, context);
@@ skipping 170 matching lines @@
       sb.write(exp.callStructure.namedArguments[index]);
       sb.write(': ');
       visit(exp.arguments[namedOffset + index]);
       needsComma = true;
     }
     sb.write(')');
   }
 
   @override
   void visitConcatenate(ConcatenateConstantExpression exp, [_]) {
-    sb.write(exp.value.unparse());
+    sb.write('"');
+    for (ConstantExpression expression in exp.expressions) {
+      if (expression.kind == ConstantExpressionKind.STRING) {
+        StringConstantExpression string = expression;
+        // TODO(johnniwinther): Ensure correct escaping.
+        sb.write('${string.primitiveValue}');
+      } else {
+        sb.write(r"${");
+        visit(expression);
+        sb.write("}");
+      }
+
+    }
+    sb.write('"');
   }
 
   @override
   void visitSymbol(SymbolConstantExpression exp, [_]) {
     sb.write('#');
     sb.write(exp.name);
   }
 
   @override
   void visitType(TypeConstantExpression exp, [_]) {
@@ skipping 106 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }