Remove ConstantExpression.value

pkg/compiler/lib/src/compile_time_constants.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.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'dart_types.dart';
 import 'dart2jslib.dart' show Compiler, CompilerTask, MessageKind, WorldImpact, invariant;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show FunctionElementX;
 import 'helpers/helpers.dart';
 import 'resolution/resolution.dart';
 import 'resolution/operators.dart';
 import 'tree/tree.dart';
 import 'util/util.dart' show Link;
 import 'universe/universe.dart' show CallStructure;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
+  /// The [ConstantSystem] used by this environment.
+  ConstantSystem get constantSystem;
+
+  /// Returns the constant value computed for [expression].
+  // TODO(johnniwinther): Support directly evaluation of [expression].
+  ConstantValue getConstantValue(ConstantExpression expression);
+
+  /// Returns the constant value for the initializer of [element].
+  ConstantValue getConstantValueForVariable(VariableElement element);
+
   /// Returns the constant for the initializer of [element].
   ConstantExpression getConstantForVariable(VariableElement element);
 }
 
 /// A class that can compile and provide constants for variables, nodes and
 /// metadata.
 abstract class ConstantCompiler extends ConstantEnvironment {
   /// Compiles the compile-time constant for the initializer of [element], or
   /// reports an error if the initializer is not a compile-time constant.
   ///
@@ skipping 31 matching lines @@
   ///
   /// The returned constant is always of the frontend interpretation.
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
                                      TreeElements elements);
 }
 
 /// A [BackendConstantEnvironment] provides access to constants needed for
 /// backend implementation.
 abstract class BackendConstantEnvironment extends ConstantEnvironment {
+  /// Returns the compile-time constant value associated with [node].
+  ///
+  /// Depending on implementation, the constant might be stored in [elements].
+  ConstantValue getConstantValueForNode(Node node, TreeElements elements);
+
   /// Returns the compile-time constant associated with [node].
   ///
   /// Depending on implementation, the constant might be stored in [elements].
   ConstantExpression getConstantForNode(Node node, TreeElements elements);
 
   /// Returns the compile-time constant value of [metadata].
-  ConstantExpression getConstantForMetadata(MetadataAnnotation metadata);
+  ConstantValue getConstantValueForMetadata(MetadataAnnotation metadata);
 }
 
 /// Interface for the task that compiles the constant environments for the
 /// frontend and backend interpretation of compile-time constants.
 abstract class ConstantCompilerTask extends CompilerTask
     implements ConstantCompiler {
   ConstantCompilerTask(Compiler compiler) : super(compiler);
+
+  /// Copy all cached constant values from [task].
+  ///
+  /// This is a hack to support reuse cached compilers in memory_compiler.
+  // TODO(johnniwinther): Remove this when values are computed from the
+  // expressions.
+  void copyConstantValues(ConstantCompilerTask task);
 }
 
 /**
  * The [ConstantCompilerBase] is provides base implementation for compilation of
  * compile-time constants for both the Dart and JavaScript interpretation of
  * constants. It keeps track of compile-time constants for initializations of
  * global and static fields, and default values of optional parameters.
  */
 abstract class ConstantCompilerBase implements ConstantCompiler {
   final Compiler compiler;
@@ skipping 10 matching lines @@
    * May contain default parameter values of optional arguments.
    *
    * Invariant: The keys in this map are declarations.
    */
   final Map<VariableElement, ConstantExpression> initialVariableValues =
       new Map<VariableElement, ConstantExpression>();
 
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables = new Set<VariableElement>();
 
+  final Map<ConstantExpression, ConstantValue> constantValueMap =
+      <ConstantExpression, ConstantValue>{};
+
   ConstantCompilerBase(this.compiler, this.constantSystem);
 
+  @override
+  ConstantValue getConstantValueForVariable(VariableElement element) {
+    return getConstantValue(initialVariableValues[element.declaration]);
+  }
+
+  @override
   ConstantExpression getConstantForVariable(VariableElement element) {
     return initialVariableValues[element.declaration];
   }
 
   ConstantExpression compileConstant(VariableElement element) {
     return compileVariable(element, isConst: true);
   }
 
   ConstantExpression compileVariable(VariableElement element,
                                      {bool isConst: false}) {
@@ skipping 20 matching lines @@
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(VariableElement element,
                                                     TreeElements definitions,
                                                     {bool isConst: false}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
         compiler.reportError(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
-        return new ErroneousConstantExpression();
+        ConstantExpression expression = new ErroneousConstantExpression();
+        constantValueMap[expression] = constantSystem.createNull();
+        return expression;
       }
       return null;
     }
     pendingVariables.add(element);
 
     Expression initializer = element.initializer;
-    ConstantExpression value;
+    ConstantExpression expression;
     if (initializer == null) {
       // No initial value.
-      value = new NullConstantExpression(new NullConstantValue());
+      expression = new NullConstantExpression();
+      constantValueMap[expression] = constantSystem.createNull();
     } else {
-      value = compileNodeWithDefinitions(
+      expression = compileNodeWithDefinitions(
           initializer, definitions, isConst: isConst);
       if (compiler.enableTypeAssertions &&
-          value != null &&
+          expression != null &&
           element.isField) {
         DartType elementType = element.type;
-        if (elementType.isMalformed && !value.value.isNull) {
+        ConstantValue value = getConstantValue(expression);
+        if (elementType.isMalformed && !value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
             compiler.reportError(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
-            value = null;
+            expression = null;
           }
         } else {
-          DartType constantType = value.value.getType(compiler.coreTypes);
+          DartType constantType = value.getType(compiler.coreTypes);
           if (!constantSystem.isSubtype(compiler.types,
                                         constantType, elementType)) {
             if (isConst) {
               compiler.reportError(
                   node, MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
-              value = null;
+              expression = null;
             }
           }
         }
       }
     }
-    if (value != null) {
-      initialVariableValues[element.declaration] = value;
+    if (expression != null) {
+      initialVariableValues[element.declaration] = expression;
     } else {
       assert(invariant(element, !isConst,
              message: "Variable $element does not compile to a constant."));
     }
     pendingVariables.remove(element);
-    return value;
+    return expression;
   }
 
   ConstantExpression compileNodeWithDefinitions(Node node,
                                                 TreeElements definitions,
                                                 {bool isConst: true}) {
     assert(node != null);
     CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
         this, definitions, compiler, isConst: isConst);
     AstConstant constant = evaluator.evaluate(node);
-    return constant != null ? constant.expression : null;
+    if (constant != null) {
+      constantValueMap[constant.expression] = constant.value;
+      return constant.expression;
+    }
+    return null;
+  }
+
+  ConstantValue getConstantValue(ConstantExpression expression) {
+    return constantValueMap[expression];
   }
 
   ConstantExpression compileNode(Node node, TreeElements elements,
                                  {bool enforceConst: true}) {
     return compileNodeWithDefinitions(node, elements, isConst: enforceConst);
   }
 
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
                                      TreeElements elements) {
@@ skipping 14 matching lines @@
 /// [ConstantCompiler] that uses the Dart semantics for the compile-time
 /// constant evaluation.
 class DartConstantCompiler extends ConstantCompilerBase {
   DartConstantCompiler(Compiler compiler)
       : super(compiler, const DartConstantSystem());
 
   ConstantExpression getConstantForNode(Node node, TreeElements definitions) {
     return definitions.getConstant(node);
   }
 
-  ConstantExpression getConstantForMetadata(MetadataAnnotation metadata) {
-    return metadata.constant;
-  }
-
   ConstantExpression compileNodeWithDefinitions(Node node,
                                                 TreeElements definitions,
                                                 {bool isConst: true}) {
     ConstantExpression constant = definitions.getConstant(node);
     if (constant != null) {
       return constant;
     }
     constant =
         super.compileNodeWithDefinitions(node, definitions, isConst: isConst);
     if (constant != null) {
@@ skipping 33 matching lines @@
     assert(result != null);
     return result;
   }
 
   AstConstant visitNode(Node node) {
     return signalNotCompileTimeConstant(node);
   }
 
   AstConstant visitLiteralBool(LiteralBool node) {
     return new AstConstant(
-        context, node, new BoolConstantExpression(
-            node.value,
-            constantSystem.createBool(node.value)));
+        context,
+        node,
+        new BoolConstantExpression(node.value),
+        constantSystem.createBool(node.value));
   }
 
   AstConstant visitLiteralDouble(LiteralDouble node) {
     return new AstConstant(
-        context, node, new DoubleConstantExpression(
-            node.value,
-            constantSystem.createDouble(node.value)));
+        context,
+        node,
+        new DoubleConstantExpression(node.value),
+        constantSystem.createDouble(node.value));
   }
 
   AstConstant visitLiteralInt(LiteralInt node) {
     return new AstConstant(
-        context, node, new IntConstantExpression(
-            node.value,
-            constantSystem.createInt(node.value)));
+        context,
+        node,
+        new IntConstantExpression(node.value),
+        constantSystem.createInt(node.value));
   }
 
   AstConstant visitLiteralList(LiteralList node) {
     if (!node.isConst)  {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> argumentExpressions = <ConstantExpression>[];
     List<ConstantValue> argumentValues = <ConstantValue>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       AstConstant argument = evaluateConstant(link.head);
       if (argument == null) {
         return null;
       }
       argumentExpressions.add(argument.expression);
       argumentValues.add(argument.value);
     }
     DartType type = elements.getType(node);
     return new AstConstant(
-        context, node, new ListConstantExpression(
-            constantSystem.createList(type, argumentValues),
-            type,
-            argumentExpressions));
+        context,
+        node,
+        new ListConstantExpression(type, argumentExpressions),
+        constantSystem.createList(type, argumentValues));
   }
 
   AstConstant visitLiteralMap(LiteralMap node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> keyExpressions = <ConstantExpression>[];
+    List<ConstantExpression> valueExpressions = <ConstantExpression>[];
     List<ConstantValue> keyValues = <ConstantValue>[];
-    Map<ConstantValue, ConstantExpression> map =
-        new Map<ConstantValue, ConstantExpression>();
+    Map<ConstantValue, ConstantValue> map = <ConstantValue, ConstantValue>{};
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       LiteralMapEntry entry = link.head;
       AstConstant key = evaluateConstant(entry.key);
       if (key == null) {
         return null;
       }
-      if (!map.containsKey(key.value)) {
-        keyExpressions.add(key.expression);
-        keyValues.add(key.value);
-      } else {
-        compiler.reportWarning(entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
-      }
       AstConstant value = evaluateConstant(entry.value);
       if (value == null) {
         return null;
       }
-      map[key.value] = value.expression;
+      if (!map.containsKey(key.value)) {
+        keyValues.add(key.value);
+      } else {
+        compiler.reportWarning(entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
+      }
+      keyExpressions.add(key.expression);
+      valueExpressions.add(value.expression);
+      map[key.value] = value.value;
     }
-    List<ConstantExpression> valueExpressions = map.values.toList();
     InterfaceType type = elements.getType(node);
     return new AstConstant(
-        context, node, new MapConstantExpression(
-            constantSystem.createMap(compiler, type, keyValues,
-                valueExpressions.map((e) => e.value).toList()),
+        context,
+        node,
+        new MapConstantExpression(
             type,
             keyExpressions,
-            valueExpressions));
+            valueExpressions),
+        constantSystem.createMap(
+            compiler, type, keyValues, map.values.toList()));
   }
 
   AstConstant visitLiteralNull(LiteralNull node) {
     return new AstConstant(
-        context, node, new NullConstantExpression(
-            constantSystem.createNull()));
+        context,
+        node,
+        new NullConstantExpression(),
+        constantSystem.createNull());
   }
 
   AstConstant visitLiteralString(LiteralString node) {
     return new AstConstant(
-        context, node, new StringConstantExpression(
-            node.dartString.slowToString(),
-            constantSystem.createString(node.dartString)));
+        context,
+        node,
+        new StringConstantExpression(node.dartString.slowToString()),
+        constantSystem.createString(node.dartString));
   }
 
   AstConstant visitStringJuxtaposition(StringJuxtaposition node) {
     AstConstant left = evaluate(node.first);
     AstConstant right = evaluate(node.second);
     if (left == null || right == null) return null;
     StringConstantValue leftValue = left.value;
     StringConstantValue rightValue = right.value;
     return new AstConstant(
-        context, node, new ConcatenateConstantExpression(
-            constantSystem.createString(
-                new DartString.concat(
-                    leftValue.primitiveValue, rightValue.primitiveValue)),
-            [left.expression, right.expression]));
+        context,
+        node,
+        new ConcatenateConstantExpression([left.expression, right.expression]),
+        constantSystem.createString(
+            new DartString.concat(
+                leftValue.primitiveValue, rightValue.primitiveValue)));
   }
 
   AstConstant visitStringInterpolation(StringInterpolation node) {
     List<ConstantExpression> subexpressions = <ConstantExpression>[];
     AstConstant initialString = evaluate(node.string);
     if (initialString == null) {
       return null;
     }
     subexpressions.add(initialString.expression);
     StringConstantValue initialStringValue = initialString.value;
@@ skipping 20 matching lines @@
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       AstConstant partString = evaluate(part.string);
       if (partString == null) return null;
       subexpressions.add(partString.expression);
       StringConstantValue partStringValue = partString.value;
       accumulator =
           new DartString.concat(accumulator, partStringValue.primitiveValue);
     };
     return new AstConstant(
-        context, node, new ConcatenateConstantExpression(
-          constantSystem.createString(accumulator),
-          subexpressions));
+        context,
+        node,
+        new ConcatenateConstantExpression(subexpressions),
+        constantSystem.createString(accumulator));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
     InterfaceType type = compiler.symbolClass.rawType;
     String text = node.slowNameString;
     List<AstConstant> arguments =
-        <AstConstant>[new AstConstant(context, node,
-          new StringConstantExpression(
-              text,
-              constantSystem.createString(new LiteralDartString(text))))];
+        <AstConstant>[new AstConstant(
+            context,
+            node,
+            new StringConstantExpression(text),
+            constantSystem.createString(new LiteralDartString(text)))];
     ConstructorElement constructor = compiler.symbolConstructor;
     AstConstant constant = createConstructorInvocation(
         node, type, constructor, CallStructure.ONE_ARG,
         normalizedArguments: arguments);
     return new AstConstant(
-        context, node, new SymbolConstantExpression(constant.value, text));
+        context, node, new SymbolConstantExpression(text), constant.value);
   }
 
-  ConstantExpression makeTypeConstant(DartType elementType) {
-    return new TypeConstantExpression(
-        constantSystem.createType(compiler, elementType), elementType);
+  ConstantValue makeTypeConstant(DartType elementType) {
+    return constantSystem.createType(compiler, elementType);
   }
 
   /// Returns true if the prefix of the send resolves to a deferred import
   /// prefix.
   bool isDeferredUse(Send send) {
     if (send == null) return false;
     return compiler.deferredLoadTask
         .deferredPrefixElement(send, elements) != null;
   }
 
   AstConstant visitIdentifier(Identifier node) {
     Element element = elements[node];
     if (Elements.isClass(element) || Elements.isTypedef(element)) {
       TypeDeclarationElement typeDeclarationElement = element;
       DartType type = typeDeclarationElement.rawType;
-      return new AstConstant(element, node, makeTypeConstant(type));
+      return new AstConstant(element, node,
+          new TypeConstantExpression(type), makeTypeConstant(type));
     }
     return signalNotCompileTimeConstant(node);
   }
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
-      ConstantExpression result;
-
+      AstConstant result;
       if (Elements.isStaticOrTopLevelFunction(element)) {
         FunctionElementX function = element;
         function.computeType(compiler);
-        result = new FunctionConstantExpression(
-            new FunctionConstantValue(function), function);
+        result = new AstConstant(
+            context,
+            send,
+            new FunctionConstantExpression(function),
+            new FunctionConstantValue(function));
       } else if (Elements.isStaticOrTopLevelField(element)) {
         ConstantExpression elementExpression;
         if (element.isConst) {
           elementExpression = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
           elementExpression = handler.compileVariable(element);
         }
         if (elementExpression != null) {
-          result =
-              new VariableConstantExpression(elementExpression.value, element);
+          result = new AstConstant(
+              context,
+              send,
+              new VariableConstantExpression(element),
+              handler.getConstantValue(elementExpression));
         }
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
-        result = makeTypeConstant(elements.getTypeLiteralType(send));
+        DartType elementType = elements.getTypeLiteralType(send);
+        result = new AstConstant(
+            context,
+            send,
+            new TypeConstantExpression(elementType),
+            makeTypeConstant(elementType));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
             DartString string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
-            result =
-                new StringLengthConstantExpression(length, left.expression);
+            result = new AstConstant(
+                context,
+                send,
+                new StringLengthConstantExpression(left.expression),
+                length);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable
                  && element.isConst) {
         ConstantExpression variableExpression =
             handler.compileConstant(element);
         if (variableExpression != null) {
-          result = new VariableConstantExpression(variableExpression.value,
-                                                  element);
+          result = new AstConstant(
+              context,
+              send,
+              new VariableConstantExpression(element),
+              handler.getConstantValue(variableExpression));
         }
       }
       if (result == null) {
         return signalNotCompileTimeConstant(send);
       }
       if (isDeferredUse(send)) {
         if (isEvaluatingConstant) {
           error(send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
         }
         PrefixElement prefix = compiler.deferredLoadTask
             .deferredPrefixElement(send, elements);
-        result = new DeferredConstantExpression(
-            new DeferredConstantValue(result.value, prefix),
-            result,
-            prefix);
+        result = new AstConstant(
+            context,
+            send,
+            new DeferredConstantExpression(
+                result.expression,
+                prefix),
+            new DeferredConstantValue(result.value, prefix));
         compiler.deferredLoadTask
             .registerConstantDeferredUse(result.value, prefix);
       }
-      return new AstConstant(context, send, result);
+      return result;
     } else if (send.isCall) {
       if (element == compiler.identicalFunction
           && send.argumentCount() == 2) {
         AstConstant left = evaluate(send.argumentsNode.nodes.head);
         AstConstant right = evaluate(send.argumentsNode.nodes.tail.head);
         if (left == null || right == null) {
           return null;
         }
         ConstantValue result =
             constantSystem.identity.fold(left.value, right.value);
         if (result != null) {
           return new AstConstant(
-              context, send, new IdenticalConstantExpression(result,
-                  left.expression, right.expression));
+              context,
+              send,
+              new IdenticalConstantExpression(
+                  left.expression, right.expression),
+              result);
         }
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       AstConstant receiverConstant = evaluate(send.receiver);
       if (receiverConstant == null) {
         return null;
       }
       Operator node = send.selector;
       UnaryOperator operator = UnaryOperator.parse(node.source);
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       if (operation == null) {
         compiler.internalError(send.selector, "Unexpected operator.");
       }
       ConstantValue folded = operation.fold(receiverConstant.value);
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
       return new AstConstant(
-          context, send, new UnaryConstantExpression(folded,
-              operator, receiverConstant.expression));
+          context,
+          send,
+          new UnaryConstantExpression(
+              operator, receiverConstant.expression),
+          folded);
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       AstConstant left = evaluate(send.receiver);
       AstConstant right = evaluate(send.argumentsNode.nodes.head);
       if (left == null || right == null) {
         return null;
       }
       ConstantValue leftValue = left.value;
       ConstantValue rightValue = right.value;
       Operator node = send.selector.asOperator();
@@ skipping 22 matching lines @@
             BinaryOperation operation = constantSystem.lookupBinary(operator);
             if (operation != null) {
               folded = operation.fold(leftValue, rightValue);
             }
         }
       }
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
       return new AstConstant(
-          context, send, new BinaryConstantExpression(folded,
-              left.expression, operator, right.expression));
+          context,
+          send,
+          new BinaryConstantExpression(
+              left.expression, operator, right.expression),
+          folded);
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null) {
       return null;
     } else if (!condition.value.isBool) {
       DartType conditionType = condition.value.getType(compiler.coreTypes);
       if (isEvaluatingConstant) {
         compiler.reportError(
             node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': compiler.boolClass.rawType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || elseExpression == null) {
       return null;
     }
     BoolConstantValue boolCondition = condition.value;
     return new AstConstant(
-        context, node, new ConditionalConstantExpression(
-            boolCondition.primitiveValue
-                ? thenExpression.value
-                : elseExpression.value,
+        context,
+        node,
+        new ConditionalConstantExpression(
             condition.expression,
             thenExpression.expression,
-            elseExpression.expression));
+            elseExpression.expression),
+        boolCondition.primitiveValue
+            ? thenExpression.value
+            : elseExpression.value);
   }
 
   AstConstant visitSendSet(SendSet node) {
     return signalNotCompileTimeConstant(node);
   }
 
   /**
    * Returns the normalized list of constant arguments that are passed to the
    * constructor including both the concrete arguments and default values for
    * omitted optional arguments.
    *
    * Invariant: [target] must be an implementation element.
    */
   List<AstConstant> evaluateArgumentsToConstructor(
       Node node,
       CallStructure callStructure,
       Link<Node> arguments,
       FunctionElement target,
       {AstConstant compileArgument(Node node)}) {
     assert(invariant(node, target.isImplementation));
 
     AstConstant compileDefaultValue(VariableElement element) {
       ConstantExpression constant = handler.compileConstant(element);
-      return new AstConstant.fromDefaultValue(element, constant);
+      return new AstConstant.fromDefaultValue(
+          element, constant, handler.getConstantValue(constant));
     }
     target.computeSignature(compiler);
 
     if (!callStructure.signatureApplies(target)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
       compiler.reportError(
           node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
@@ skipping 51 matching lines @@
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
     InterfaceType constructedType =
         constructor.computeEffectiveTargetType(type);
     ConstructorElement target = constructor.effectiveTarget;
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     ConstructorElement implementation = target.implementation;
 
     if (implementation.isErroneous) {
+      // TODO(johnniwinther): This should probably be an [ErroneousAstConstant].
       return new AstConstant(
-          context, node, new ConstructedConstantExpression(
-              new ConstructedConstantValue(
-                  constructedType, const <FieldElement, ConstantValue>{}),
+          context,
+          node,
+          new ConstructedConstantExpression(
               type,
               constructor,
               callStructure,
-              const <ConstantExpression>[]));
+              const <ConstantExpression>[]),
+          new ConstructedConstantValue(
+              constructedType, const <FieldElement, ConstantValue>{}));
     }
 
     List<AstConstant> concreteArguments;
     if (arguments != null) {
       Map<Node, AstConstant> concreteArgumentMap =
           <Node, AstConstant>{};
       for (Link<Node> link = arguments; !link.isEmpty; link = link.tail) {
         Node argument = link.head;
         NamedArgument namedArgument = argument.asNamedArgument();
         if (namedArgument != null) {
@@ skipping 86 matching lines @@
     AstConstant createEvaluatedConstant(ConstantValue value) {
 
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
       if (concreteArguments.length > 1) {
         defaultValue = concreteArguments[1].expression;
       }
       if (constructor == compiler.intEnvironment) {
         expression = new IntFromEnvironmentConstantExpression(
-            value, name, defaultValue);
+            name, defaultValue);
       } else if (constructor == compiler.boolEnvironment) {
         expression = new BoolFromEnvironmentConstantExpression(
-            value, name, defaultValue);
+            name, defaultValue);
       } else if (constructor == compiler.stringEnvironment) {
         expression = new StringFromEnvironmentConstantExpression(
-            value, name, defaultValue);
+            name, defaultValue);
       }
-      return new AstConstant(context, node, expression);
+      return new AstConstant(context, node, expression, value);
     }
 
     if (value == null) {
       return createEvaluatedConstant(defaultValue);
     } else if (constructor == compiler.intEnvironment) {
       int number = int.parse(value, onError: (_) => null);
       return createEvaluatedConstant(
           (number == null)
               ? defaultValue
               : constantSystem.createInt(number));
@@ skipping 22 matching lines @@
       InterfaceType constructedType,
       ConstructorElement target,
       CallStructure callStructure,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
       // This happens is case of cyclic redirection.
       assert(invariant(node, compiler.compilationFailed,
           message: "makeConstructedConstant can only be called with the "
                    "effective target: $constructor"));
-      return new AstConstant(
-          context, node, new ErroneousConstantExpression());
+      return new ErroneousAstConstant(context, node);
     }
     assert(invariant(node, callStructure.signatureApplies(constructor) ||
                      compiler.compilationFailed,
         message: "Call structure $callStructure does not apply to constructor "
                  "$constructor."));
 
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType, target, handler, compiler);
     evaluator.evaluateConstructorFieldValues(normalizedArguments);
     Map<FieldElement, AstConstant> fieldConstants =
         evaluator.buildFieldConstants(target.enclosingClass);
     Map<FieldElement, ConstantValue> fieldValues =
         <FieldElement, ConstantValue>{};
     fieldConstants.forEach((FieldElement field, AstConstant astConstant) {
       fieldValues[field] = astConstant.value;
     });
     return new AstConstant(
-        context, node, new ConstructedConstantExpression(
-            new ConstructedConstantValue(constructedType, fieldValues),
+        context,
+        node,
+        new ConstructedConstantExpression(
             type,
             constructor,
             callStructure,
-            concreteArguments.map((e) => e.expression).toList()));
+            concreteArguments.map((e) => e.expression).toList()),
+        new ConstructedConstantValue(constructedType, fieldValues));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node, MessageKind message) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     compiler.reportError(node, message);
   }
 
   AstConstant signalNotCompileTimeConstant(Node node,
       {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
     if (isEvaluatingConstant) {
       error(node, message);
 
       return new AstConstant(
-          null, node, new ErroneousConstantExpression());
+          context,
+          node,
+          new ErroneousConstantExpression(),
+          new NullConstantValue());
     }
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
   }
 }
 
@@ skipping 185 matching lines @@
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
     Map<FieldElement, AstConstant> fieldConstants =
         <FieldElement, AstConstant>{};
     classElement.implementation.forEachInstanceField(
         (ClassElement enclosing, FieldElement field) {
           AstConstant fieldValue = fieldValues[field];
           if (fieldValue == null) {
             // Use the default value.
+            ConstantExpression fieldExpression = handler.compileConstant(field);
             fieldValue = new AstConstant.fromDefaultValue(
-                field, handler.compileConstant(field));
+                field,
+                fieldExpression,
+                handler.getConstantValue(fieldExpression));
           }
           fieldConstants[field] = fieldValue;
         },
         includeSuperAndInjectedMembers: true);
     return fieldConstants;
   }
 }
 
 /// A constant created from the front-end AST.
 ///
 /// [element] and [node] point to the source location of the constant.
 /// [expression] holds the symbolic constant expression and [value] its constant
 /// value.
 ///
 /// This class differs from [ConstantExpression] in that it is coupled to the
 /// front-end AST whereas [ConstantExpression] is only coupled to the element
 /// model.
 class AstConstant {
   final Element element;
   final Node node;
   final ConstantExpression expression;
+  final ConstantValue value;
 
-  AstConstant(this.element, this.node, this.expression);
+  AstConstant(this.element, this.node, this.expression, this.value);
 
   factory AstConstant.fromDefaultValue(
       VariableElement element,
-      ConstantExpression constant) {
+      ConstantExpression constant,
+      ConstantValue value) {
     return new AstConstant(
         element,
         element.initializer != null ? element.initializer : element.node,
-        constant);
+        constant,
+        value);
   }
 
-  ConstantValue get value => expression.value;
-
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
-      : super(element, node, new ErroneousConstantExpression());
+      : super(element, node,
+          // TODO(johnniwinther): Return a [NonConstantValue] instead.
+          new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // TODO(johnniwinther): Avoid the need for this hack.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   WorldImpact worldImpact = compiler.analyzeElement(element.declaration);
   compiler.enqueuer.resolution.applyImpact(element.declaration, worldImpact);
   return element.resolvedAst.elements;
 }