Cleanup constant building in IrBuilder.

sdk/lib/_internal/compiler/implementation/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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 262 matching lines @@
   ///
   /// [isClosureVariable] marks whether [variableElement] is accessed from an
   /// inner function.
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue,
                              bool isClosureVariable: false}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
-      initialValue = makePrimConst(state.constantSystem.createNull());
-      add(new ir.LetPrim(initialValue));
+      initialValue = buildNullLiteral();
     }
     if (isClosureVariable) {
       add(new ir.SetClosureVariable(variableElement,
                                     initialValue,
                                     isDeclaration: true));
     } else {
       // In case a primitive was introduced for the initializer expression,
       // use this variable element to help derive a good name for it.
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
@@ skipping 15 matching lines @@
   }
 
   ir.Primitive continueWithExpression(ir.Expression build(ir.Continuation k)) {
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
     add(new ir.LetCont(k, expression));
     return v;
   }
 
-  ir.Constant makeConst(ConstantExpression exp) {
-    return new ir.Constant(exp);
-  }
-
-  ir.Constant makePrimConst(PrimitiveConstantValue value) {
-    return makeConst(new PrimitiveConstantExpression(value));
-  }
-
-  // TODO(johnniwinther): Build constants directly through [ConstExp] when these
-  // are created from analyzer2dart.
-  ir.Node buildPrimConst(PrimitiveConstantValue constant) {
+  /// Create a constant literal from [constant].
+  ir.Constant buildConstantLiteral(ConstantExpression constant) {
     assert(isOpen);
-    ir.Node prim = makePrimConst(constant);
+    ir.Constant prim = new ir.Constant(constant);
     add(new ir.LetPrim(prim));
     return prim;
   }
 
+  // Helper for building primitive literals.
+  ir.Constant _buildPrimitiveConstant(PrimitiveConstantValue constant) {
+    return buildConstantLiteral(new PrimitiveConstantExpression(constant));
+  }
+
   /// Create an integer literal.
   ir.Constant buildIntegerLiteral(int value) {
-    return buildPrimConst(state.constantSystem.createInt(value));
+    return _buildPrimitiveConstant(state.constantSystem.createInt(value));
   }
 
   /// Create an double literal.
   ir.Constant buildDoubleLiteral(double value) {
-    return buildPrimConst(state.constantSystem.createDouble(value));
+    return _buildPrimitiveConstant(state.constantSystem.createDouble(value));
   }
 
   /// Create an bool literal.
   ir.Constant buildBooleanLiteral(bool value) {
-    return buildPrimConst(state.constantSystem.createBool(value));
+    return _buildPrimitiveConstant(state.constantSystem.createBool(value));
   }
 
   /// Create an null literal.
   ir.Constant buildNullLiteral() {
-    return buildPrimConst(state.constantSystem.createNull());
+    return _buildPrimitiveConstant(state.constantSystem.createNull());
   }
 
   /// Create a string literal.
   ir.Constant buildStringLiteral(String value) {
-    return buildPrimConst(
+    return _buildPrimitiveConstant(
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a get access of [local].
   ir.Primitive buildLocalGet(Element local) {
     assert(isOpen);
     return environment.lookup(local);
   }
 
   /// Create a get access of the static [element].
@@ skipping 15 matching lines @@
             receiver, selector, k, const <ir.Definition>[]));
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void ensureReturn() {
     if (!isOpen) return;
-    ir.Constant constant = makePrimConst(state.constantSystem.createNull());
-    add(new ir.LetPrim(constant));
+    ir.Constant constant = buildNullLiteral();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createParameter].
   ir.FunctionDefinition buildFunctionDefinition(
       FunctionElement element,
@@ skipping 47 matching lines @@
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn([ir.Primitive value]) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
-      value = makePrimConst(state.constantSystem.createNull());
-      add(new ir.LetPrim(value));
+      value = buildNullLiteral();
     }
     add(new ir.InvokeContinuation(state.returnContinuation, [value]));
     _current = null;
   }
 
   // Build(BreakStatement L, C) = C[InvokeContinuation(...)]
   //
   // The continuation and arguments are filled in later after translating
   // the body containing the break.
   bool buildBreak(JumpTarget target) {
@@ skipping 24 matching lines @@
   ir.Primitive buildNegation(ir.Primitive condition) {
     // ! 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 trueConstant =
-        makePrimConst(state.constantSystem.createBool(true));
-    ir.Constant falseConstant =
-        makePrimConst(state.constantSystem.createBool(false));
+    ir.Constant makeBoolConstant(bool value) {
+      return new ir.Constant(new PrimitiveConstantExpression(
+          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]));
 
     add(new ir.LetCont(joinContinuation,
           new ir.LetCont(thenContinuation,
             new ir.LetCont(elseContinuation,
               new ir.Branch(new ir.IsTrue(condition),
@@ skipping 22 matching lines @@
     // appropriate constant and an invocation of the join-point continuation.
     IrBuilder emptyBuilder = new IrBuilder.delimited(this);
     // Dummy empty targets for right true and right false.  They hold
     // definitions of the appropriate constant and an invocation of the
     // join-point continuation.
     IrBuilder rightTrueBuilder = new IrBuilder.delimited(rightBuilder);
     IrBuilder rightFalseBuilder = new IrBuilder.delimited(rightBuilder);
 
     // If we don't evaluate the right subexpression, the value of the whole
     // expression is this constant.
-    ir.Constant leftBool = emptyBuilder.makePrimConst(
-        emptyBuilder.state.constantSystem.createBool(isLazyOr));
+    ir.Constant leftBool = emptyBuilder.buildBooleanLiteral(isLazyOr);
     // If we do evaluate the right subexpression, the value of the expression
     // is a true or false constant.
-    ir.Constant rightTrue = rightTrueBuilder.makePrimConst(
-        rightTrueBuilder.state.constantSystem.createBool(true));
-    ir.Constant rightFalse = rightFalseBuilder.makePrimConst(
-        rightFalseBuilder.state.constantSystem.createBool(false));
-    emptyBuilder.add(new ir.LetPrim(leftBool));
-    rightTrueBuilder.add(new ir.LetPrim(rightTrue));
-    rightFalseBuilder.add(new ir.LetPrim(rightFalse));
+    ir.Constant rightTrue = rightTrueBuilder.buildBooleanLiteral(true);
+    ir.Constant rightFalse = rightFalseBuilder.buildBooleanLiteral(false);
 
     // Treat the result values as named values in the environment, so they
     // will be treated as arguments to the join-point continuation.
     assert(environment.length == emptyBuilder.environment.length);
     assert(environment.length == rightTrueBuilder.environment.length);
     assert(environment.length == rightFalseBuilder.environment.length);
     emptyBuilder.environment.extend(null, leftBool);
     rightTrueBuilder.environment.extend(null, rightTrue);
     rightFalseBuilder.environment.extend(null, rightFalse);
 
@@ skipping 138 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }