Remove ConstantExpression.value

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 451 matching lines @@
     return irBuilder.buildNullConstant();
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildDartStringConstant(node.dartString);
   }
 
   ConstantExpression getConstantForNode(ast.Node node) {
     ConstantExpression constant =
-        compiler.backend.constants.getConstantForNode(node, elements);
+        irBuilder.state.constants.getConstantForNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
   ConstantExpression getConstantForVariable(VariableElement element) {
     ConstantExpression constant =
-        compiler.backend.constants.getConstantForVariable(element);
+        irBuilder.state.constants.getConstantForVariable(element);
     assert(invariant(element, constant != null,
             message: 'No constant computed for $element'));
     return constant;
   }
 
+  /// Builds a constant pulling the value from the constant environment.
+  // TODO(johnniwinther): Remove this when [IrBuilder.buildConstant] only takes
+  // a [ConstantExpression].
+  ir.Primitive buildConstant(ConstantExpression expression) {
+    return irBuilder.buildConstant(expression,
+        irBuilder.state.constants.getConstantValue(expression));
+  }
+
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     InterfaceType type = elements.getType(node);
     return irBuilder.buildListLiteral(type, values);
   }
 
   ir.Primitive visitLiteralMap(ast.LiteralMap node) {
@@ skipping 74 matching lines @@
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
       ast.Node node,
       ConstantExpression constant, _) {
-    return irBuilder.buildConstant(constant);
+    return buildConstant(constant);
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
   ir.Primitive handleDynamicGet(
@@ skipping 16 matching lines @@
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicGet(target, selector)));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
-    return irBuilder.buildConstant(constant);
+    return buildConstant(constant);
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
       ast.Send node,
       LocalVariableElement element,
       _) {
     return element.isConst
-        ? irBuilder.buildConstant(getConstantForVariable(element))
+        ? buildConstant(getConstantForVariable(element))
         : irBuilder.buildLocalVariableGet(element);
   }
 
   @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
     return irBuilder.buildLocalVariableGet(element);
   }
@@ skipping 286 matching lines @@
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildConstant(constant);
+    ir.Primitive target = buildConstant(constant);
     return translateCallInvoke(target, arguments, callStructure);
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
@@ skipping 316 matching lines @@
     return irBuilder.buildStaticSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
-        getValue: () => irBuilder.buildConstant(constant),
+        getValue: () => buildConstant(constant),
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.Send node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
@@ skipping 222 matching lines @@
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
     return irBuilder.buildStringConcatenation(arguments);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    return irBuilder.buildConstant(getConstantForNode(node));
+    return buildConstant(getConstantForNode(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
   ir.Primitive buildStaticNoSuchMethod(
@@ skipping 724 matching lines @@
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
         sourceInformationBuilder.forContext(context));
     return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
   }
 
   JsIrBuilder getBuilderFor(Element element) {
     return new JsIrBuilder(
         new GlobalProgramInformation(compiler),
-        compiler.backend.constantSystem,
+        compiler.backend.constants,
         element);
   }
 
   /// Builds the IR for a given constructor.
   ///
   /// 1. Computes the type held in all own or "inherited" type variables.
   /// 2. Evaluates all own or inherited field initializers.
   /// 3. Creates the object and assigns its fields and runtime type.
   /// 4. Calls constructor body and super constructor bodies.
   /// 5. Returns the created object.
@@ skipping 535 matching lines @@
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     return buildStaticFieldGet(field, src);
   }
 
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
     ConstantExpression constant =
         backend.constants.getConstantForVariable(field);
     if (constant != null && !field.isAssignable) {
-      return irBuilder.buildConstant(constant);
+      return buildConstant(constant);
     } else if (backend.constants.lazyStatics.contains(field)) {
       return irBuilder.buildStaticFieldLazyGet(field, src);
     } else {
       return irBuilder.buildStaticFieldGet(field, src);
     }
   }
 }
 
 /// Perform simple post-processing on the initial CPS-translated root term.
 ///
@@ skipping 54 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }