Remove ConstantExpression.value

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
+import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
-import '../constants/values.dart' show PrimitiveConstantValue;
+import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
 import '../closure.dart' hide ClosureScope;
 import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder_task.dart' show DartCapturedVariables,
     GlobalProgramInformation;
@@ skipping 357 matching lines @@
   // `List` instead of `Link`.
   SubbuildFunction subbuildSequence(/*Iterable<N>*/ nodes) {
     return (IrBuilder builder) {
       return withBuilder(builder, () => builder.buildSequence(nodes, build));
     };
   }
 }
 
 /// Shared state between delimited IrBuilders within the same function.
 class IrBuilderSharedState {
-  final ConstantSystem constantSystem;
+  final BackendConstantEnvironment constants;
+
+  ConstantSystem get constantSystem => constants.constantSystem;
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
   ir.Parameter _thisParameter;
   ir.Parameter enclosingMethodThisParameter;
 
   final List<ir.Parameter> functionParameters = <ir.Parameter>[];
 
-  IrBuilderSharedState(this.constantSystem, this.currentElement);
+  IrBuilderSharedState(this.constants, this.currentElement);
 
   ir.Parameter get thisParameter => _thisParameter;
   void set thisParameter(ir.Parameter value) {
     assert(_thisParameter == null);
     _thisParameter = value;
   }
 }
 
 class ThisParameterLocal implements Local {
   final ExecutableElement executableContext;
@@ skipping 125 matching lines @@
   //
   // We do not pass contexts as arguments or return them.  Rather we use the
   // current context (root, current) as the visitor state and mutate current.
   // Visiting a statement returns null; visiting an expression returns the
   // primitive denoting its value.
 
   ir.Expression _root = null;
   ir.Expression _current = null;
 
   /// Initialize a new top-level IR builder.
-  void _init(ConstantSystem constantSystem, ExecutableElement currentElement) {
-    state = new IrBuilderSharedState(constantSystem, currentElement);
+  void _init(BackendConstantEnvironment constants,
+             ExecutableElement currentElement) {
+    state = new IrBuilderSharedState(constants, currentElement);
     environment = new Environment.empty();
     mutableVariables = <Local, ir.MutableVariable>{};
   }
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// Build a subterm that is not (yet) connected to the CPS term.  The
   /// delimited visitor has its own has its own context for building an IR
   /// expression, so the built expression is not plugged into the parent's
   /// context.  It has its own compile-time environment mapping local
@@ skipping 98 matching lines @@
                                 CallStructure callStructure,
                                 List<ir.Definition> arguments,
                                 {SourceInformation sourceInformation}) {
     Selector selector = callStructure.callSelector;
     return _buildInvokeDynamic(target, selector, arguments,
         sourceInformation: sourceInformation);
   }
 
 
   /// Create a [ir.Constant] from [constant] and add it to the CPS term.
-  ir.Constant buildConstant(ConstantExpression constant) {
+  // TODO(johnniwinther): Remove [value] when [ConstantValue] can be computed
+  // directly from [constant].
+  ir.Constant buildConstant(ConstantExpression constant, ConstantValue value) {
     assert(isOpen);
-    return addPrimitive(new ir.Constant(constant));
+    return addPrimitive(new ir.Constant(constant, value));
   }
 
   /// Create an integer constant and add it to the CPS term.
   ir.Constant buildIntegerConstant(int value) {
-    return buildConstant(new IntConstantExpression(
-        value,
-        state.constantSystem.createInt(value)));
+    return buildConstant(
+        new IntConstantExpression(value),
+        state.constantSystem.createInt(value));
   }
 
   /// Create a double constant and add it to the CPS term.
   ir.Constant buildDoubleConstant(double value) {
-    return buildConstant(new DoubleConstantExpression(
-        value,
-        state.constantSystem.createDouble(value)));
+    return buildConstant(
+        new DoubleConstantExpression(value),
+        state.constantSystem.createDouble(value));
   }
 
   /// Create a Boolean constant and add it to the CPS term.
   ir.Constant buildBooleanConstant(bool value) {
-    return buildConstant(new BoolConstantExpression(
-        value,
-        state.constantSystem.createBool(value)));
+    return buildConstant(
+        new BoolConstantExpression(value),
+        state.constantSystem.createBool(value));
   }
 
   /// Create a null constant and add it to the CPS term.
   ir.Constant buildNullConstant() {
-    return buildConstant(new NullConstantExpression(
-        state.constantSystem.createNull()));
+    return buildConstant(
+        new NullConstantExpression(),
+        state.constantSystem.createNull());
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildStringConstant(String value) {
-    return buildConstant(new StringConstantExpression(
-        value,
-        state.constantSystem.createString(new ast.DartString.literal(value))));
+    return buildConstant(
+        new StringConstantExpression(value),
+        state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildDartStringConstant(ast.DartString value) {
-    return buildConstant(new StringConstantExpression(
-        value.slowToString(),
-        state.constantSystem.createString(value)));
+    return buildConstant(
+        new StringConstantExpression(value.slowToString()),
+        state.constantSystem.createString(value));
   }
 
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
   ir.Primitive buildListLiteral(InterfaceType type,
                                 Iterable<ir.Primitive> values) {
     assert(isOpen);
     return addPrimitive(new ir.LiteralList(type, values.toList()));
   }
 
@@ skipping 1186 matching lines @@
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
     ir.Constant makeBoolConstant(bool value) {
-      return new ir.Constant(new BoolConstantExpression(
-          value,
-          state.constantSystem.createBool(value)));
+      return new ir.Constant(
+          new BoolConstantExpression(value),
+          state.constantSystem.createBool(value));
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
@@ skipping 114 matching lines @@
 ///
 /// Inner functions are represented by a [ClosureClassElement], and captured
 /// variables are boxed as necessary using [CreateBox], [GetField], [SetField].
 class JsIrBuilder extends IrBuilder {
   final JsIrBuilderSharedState jsState;
   final GlobalProgramInformation program;
 
   IrBuilder _makeInstance() => new JsIrBuilder._blank(program, jsState);
   JsIrBuilder._blank(this.program, this.jsState);
 
-  JsIrBuilder(this.program, ConstantSystem constantSystem,
+  JsIrBuilder(this.program, BackendConstantEnvironment constants,
       ExecutableElement currentElement)
       : jsState = new JsIrBuilderSharedState() {
-    _init(constantSystem, currentElement);
+    _init(constants, currentElement);
   }
 
   void enterInitializers() {
     assert(jsState.inInitializers == false);
     jsState.inInitializers = true;
   }
 
   void leaveInitializers() {
     assert(jsState.inInitializers == true);
     jsState.inInitializers = false;
@@ skipping 439 matching lines @@
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }