Rename Constant to ConstantValue and ConstExp to ConstantExpression.

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 PrimitiveConstant;
+import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../source_file.dart';
 import '../tree/tree.dart' as ast;
 import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
 
@@ skipping 276 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(ConstExp exp) {
+  ir.Constant makeConst(ConstantExpression exp) {
     return new ir.Constant(exp);
   }
 
-  ir.Constant makePrimConst(PrimitiveConstant value) {
-    return makeConst(new PrimitiveConstExp(value));
+  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(PrimitiveConstant constant) {
+  ir.Node buildPrimConst(PrimitiveConstantValue constant) {
     assert(isOpen);
     ir.Node prim = makePrimConst(constant);
     add(new ir.LetPrim(prim));
     return prim;
   }
 
   /// Create an integer literal.
   ir.Constant buildIntegerLiteral(int value) {
     return buildPrimConst(constantSystem.createInt(value));
   }
@@ skipping 46 matching lines @@
     _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,
       List<ConstDeclaration> constants,
-      List<ConstExp> defaults) {
+      List<ConstantExpression> defaults) {
     if (!element.isAbstract) {
       ensureReturn();
       return new ir.FunctionDefinition(
           element, returnContinuation, _parameters, _root, constants, defaults);
     } else {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, constants.isEmpty,
           message: "Local constants for abstract method $element: $constants"));
       return new ir.FunctionDefinition.abstract(
@@ skipping 137 matching lines @@
     closureLocals.visit(function);
 
     _root = _current = null;
 
     FunctionSignature signature = element.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameterElement) {
       createParameter(parameterElement,
                       isClosureVariable: isClosureVariable(parameterElement));
     });
 
-    List<ConstExp> defaults = new List<ConstExp>();
+    List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     visit(function.body);
     return buildFunctionDefinition(element, localConstants, defaults);
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
@@ skipping 582 matching lines @@
     return null;
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
-        ConstExp value = getConstantForVariable(element);
+        ConstantExpression value = getConstantForVariable(element);
         localConstants.add(new ConstDeclaration(element, value));
       }
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
         ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
@@ skipping 100 matching lines @@
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
     assert(isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
     assert(isOpen);
     return translateConstant(node);
   }
 
-  ConstExp getConstantForNode(ast.Node node) {
-    ConstExp constant =
+  ConstantExpression getConstantForNode(ast.Node node) {
+    ConstantExpression constant =
         compiler.backend.constantCompilerTask.compileNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
-  ConstExp getConstantForVariable(VariableElement element) {
-    ConstExp constant =
+  ConstantExpression getConstantForVariable(VariableElement element) {
+    ConstantExpression constant =
         compiler.backend.constants.getConstantForVariable(element);
     assert(invariant(element, constant != null,
             message: 'No constant computed for $element'));
     return constant;
   }
 
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     assert(isOpen);
     if (node.isConst) {
       return translateConstant(node);
@@ skipping 568 matching lines @@
     var it = node.parts.iterator;
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
     return continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
-  ir.Primitive translateConstant(ast.Node node, [ConstExp constant]) {
+  ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
     ir.Primitive primitive = makeConst(constant);
     add(new ir.LetPrim(primitive));
     return primitive;
   }
 
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
@@ skipping 80 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }