Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/cps_ir/constant_propagation.dart

 // Copyright (c) 2014, 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.
 
 part of dart2js.optimizers;
 
 /**
  * Propagates constants throughout the IR, and replaces branches with fixed
  * jumps as well as side-effect free expressions with known constant results.
  * Should be followed by the [ShrinkingReducer] pass.
@@ skipping 59 matching lines @@
                              void unlink()) {
     _ConstnessLattice cell = node2value[node];
     if (cell == null || !cell.isConstant) {
       return null;
     }
 
     assert(continuation.parameters.length == 1);
 
     // Set up the replacement structure.
 
-    values.PrimitiveConstant primitiveConstant = cell.constant;
-    ConstExp constExp = new PrimitiveConstExp(primitiveConstant);
+    PrimitiveConstantValue primitiveConstant = cell.constant;
+    ConstantExpression constExp =
+        new PrimitiveConstantExpression(primitiveConstant);
     Constant constant = new Constant(constExp);
     LetPrim letPrim = new LetPrim(constant);
     InvokeContinuation invoke =
         new InvokeContinuation(continuation, <Definition>[constant]);
 
     invoke.parent = constant.parent = letPrim;
     letPrim.body = invoke;
 
     // Replace the method invocation.
 
@@ skipping 269 matching lines @@
     } else if (lhs.isNonConst) {
       setValues(_ConstnessLattice.NonConst);
       return;
     } else if (!node.selector.isOperator) {
       // TODO(jgruber): Handle known methods on constants such as String.length.
       setValues(_ConstnessLattice.NonConst);
       return;
     }
 
     // Calculate the resulting constant if possible.
-    values.Constant result;
+    ConstantValue result;
     String opname = node.selector.name;
     if (node.selector.argumentCount == 0) {
       // Unary operator.
 
       if (opname == "unary-") {
         opname = "-";
       }
       dart2js.UnaryOperation operation = constantSystem.lookupUnary(opname);
       if (operation != null) {
         result = operation.fold(lhs.constant);
@@ skipping 56 matching lines @@
       }
       Constant constant = ref.definition;
       return constant != null && constant.value.isString;
     });
 
     assert(cont.parameters.length == 1);
     if (allStringConstants) {
       // All constant, we can concatenate ourselves.
       Iterable<String> allStrings = node.arguments.map((Reference ref) {
         Constant constant = ref.definition;
-        values.StringConstant stringConstant = constant.value;
-        return stringConstant.value.slowToString();
+        StringConstantValue stringConstant = constant.value;
+        return stringConstant.primitiveValue.slowToString();
       });
       LiteralDartString dartString = new LiteralDartString(allStrings.join());
-      values.Constant constant = new values.StringConstant(dartString);
+      ConstantValue constant = new StringConstantValue(dartString);
       setValues(new _ConstnessLattice(constant));
     } else {
       setValues(_ConstnessLattice.NonConst);
     }
   }
 
   void visitBranch(Branch node) {
     IsTrue isTrue = node.condition;
     _ConstnessLattice conditionCell = getValue(isTrue.value.definition);
 
     if (conditionCell.isUnknown) {
       return;  // And come back later.
     } else if (conditionCell.isNonConst) {
       setReachable(node.trueContinuation.definition);
       setReachable(node.falseContinuation.definition);
     } else if (conditionCell.isConstant &&
         !(conditionCell.constant.isBool)) {
       // Treat non-bool constants in condition as non-const since they result
       // in type errors in checked mode.
       // TODO(jgruber): Default to false in unchecked mode.
       setReachable(node.trueContinuation.definition);
       setReachable(node.falseContinuation.definition);
       setValue(isTrue.value.definition, _ConstnessLattice.NonConst);
     } else if (conditionCell.isConstant &&
         conditionCell.constant.isBool) {
-      values.BoolConstant boolConstant = conditionCell.constant;
+      BoolConstantValue boolConstant = conditionCell.constant;
       setReachable((boolConstant.isTrue) ?
           node.trueContinuation.definition : node.falseContinuation.definition);
     }
   }
 
   void visitTypeOperator(TypeOperator node) {
     Continuation cont = node.continuation.definition;
     setReachable(cont);
 
     void setValues(_ConstnessLattice updateValue) {
       setValue(node, updateValue);
       Parameter returnValue = cont.parameters[0];
       setValue(returnValue, updateValue);
     }
 
     if (node.operator != "is") {
       // TODO(jgruber): Add support for `as` casts.
       setValues(_ConstnessLattice.NonConst);
     }
 
     _ConstnessLattice cell = getValue(node.receiver.definition);
     if (cell.isUnknown) {
       return;  // And come back later.
     } else if (cell.isNonConst) {
       setValues(_ConstnessLattice.NonConst);
     } else if (node.type.kind == types.TypeKind.INTERFACE) {
       // Receiver is a constant, perform is-checks at compile-time.
 
       types.InterfaceType checkedType = node.type;
-      values.Constant constant = cell.constant;
+      ConstantValue constant = cell.constant;
       types.DartType constantType = constant.computeType(compiler);
 
       _ConstnessLattice result = _ConstnessLattice.NonConst;
       if (constant.isNull &&
           checkedType.element != compiler.nullClass &&
           checkedType.element != compiler.objectClass) {
         // `(null is Type)` is true iff Type is in { Null, Object }.
-        result = new _ConstnessLattice(new values.FalseConstant());
+        result = new _ConstnessLattice(new FalseConstantValue());
       } else {
         // Otherwise, perform a standard subtype check.
         result = new _ConstnessLattice(
             constantSystem.isSubtype(compiler, constantType, checkedType)
-            ? new values.TrueConstant()
-            : new values.FalseConstant());
+            ? new TrueConstantValue()
+            : new FalseConstantValue());
       }
 
       setValues(result);
     }
   }
 
   void visitSetClosureVariable(SetClosureVariable node) {
     setReachable(node.body);
   }
 
@@ skipping 22 matching lines @@
   void visitThis(This node) {
     setValue(node, _ConstnessLattice.NonConst);
   }
 
   void visitReifyTypeVar(ReifyTypeVar node) {
     setValue(node, _ConstnessLattice.NonConst);
   }
 
   void visitCreateFunction(CreateFunction node) {
     setReachable(node.definition);
-    values.Constant constant =
-        new values.FunctionConstant(node.definition.element);
+    ConstantValue constant =
+        new FunctionConstantValue(node.definition.element);
     setValue(node, new _ConstnessLattice(constant));
   }
 
   void visitGetClosureVariable(GetClosureVariable node) {
     setValue(node, _ConstnessLattice.NonConst);
   }
 
   void visitParameter(Parameter node) {
     if (node.parent is FunctionDefinition) {
       // Functions may escape and thus their parameters must be initialized to
@@ skipping 30 matching lines @@
 /// Represents the constant-state of a variable at some point in the program.
 /// UNKNOWN: may be some as yet undetermined constant.
 /// CONSTANT: is a constant as stored in the local field.
 /// NONCONST: not a constant.
 class _ConstnessLattice {
   static const int UNKNOWN  = 0;
   static const int CONSTANT = 1;
   static const int NONCONST = 2;
 
   final int kind;
-  final values.Constant constant;
+  final ConstantValue constant;
 
   static final _ConstnessLattice Unknown =
       new _ConstnessLattice._internal(UNKNOWN, null);
   static final _ConstnessLattice NonConst =
       new _ConstnessLattice._internal(NONCONST, null);
 
   _ConstnessLattice._internal(this.kind, this.constant);
   _ConstnessLattice(this.constant) : kind = CONSTANT {
     assert(this.constant != null);
   }
@@ skipping 28 matching lines @@
       return that;
     }
 
     if (this.constant == that.constant) {
       return this;
     }
 
     return NonConst;
   }
 }