Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/ssa/value_range_analyzer.dart

 // Copyright (c) 2012, 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 ssa;
 
 
 class ValueRangeInfo {
   final ConstantSystem constantSystem;
 
@@ skipping 118 matching lines @@
 
   const IntValue(this.value, info) : super(info);
 
   Value operator +(other) {
     if (other.isZero) return this;
     if (other is !IntValue) return other + this;
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.add.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
-    return info.newIntValue(constant.value);
+    return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator -(other) {
     if (other.isZero) return this;
     if (other is !IntValue) return -other + this;
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.subtract.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
-    return info.newIntValue(constant.value);
+    return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator -() {
     if (isZero) return this;
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.negate.fold(
         constantSystem.createInt(value));
     if (!constant.isInt) return const UnknownValue();
-    return info.newIntValue(constant.value);
+    return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator &(other) {
     if (other is !IntValue) return const UnknownValue();
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.bitAnd.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
-    return info.newIntValue(constant.value);
+    return info.newIntValue(constant.primitiveValue);
   }
 
   Value min(other) {
     if (other is !IntValue) return other.min(this);
     return this.value < other.value ? this : other;
   }
 
   Value max(other) {
     if (other is !IntValue) return other.max(this);
     return this.value < other.value ? other : this;
@@ skipping 488 matching lines @@
 
     Range range = ranges[phi.inputs[0]];
     for (int i = 1; i < phi.inputs.length; i++) {
       range = range.union(ranges[phi.inputs[i]]);
     }
     return range;
   }
 
   Range visitConstant(HConstant hConstant) {
     if (!hConstant.isInteger(compiler)) return info.newUnboundRange();
-    Constant constant = hConstant.constant;
-    NumConstant constantNum;
-    if (constant is DeferredConstant) {
+    ConstantValue constant = hConstant.constant;
+    NumConstantValue constantNum;
+    if (constant is DeferredConstantValue) {
       constantNum = constant.referenced;
     } else {
       constantNum = constant;
     }
-    if (constantNum.isMinusZero) constantNum = new IntConstant(0);
-    Value value = info.newIntValue(constantNum.value);
+    if (constantNum.isMinusZero) constantNum = new IntConstantValue(0);
+    Value value = info.newIntValue(constantNum.primitiveValue);
     return info.newNormalizedRange(value, value);
   }
 
   Range visitFieldGet(HFieldGet fieldGet) {
     if (!fieldGet.isInteger(compiler)) return info.newUnboundRange();
     if (!fieldGet.receiver.isIndexablePrimitive(compiler)) {
       return visitInstruction(fieldGet);
     }
     JavaScriptBackend backend = compiler.backend;
     assert(fieldGet.element == backend.jsIndexableLength);
@@ skipping 372 matching lines @@
   }
 
   Range handleBinaryOperation(HBinaryArithmetic instruction) {
     Range leftRange = visit(instruction.left);
     Range rightRange = visit(instruction.right);
     if (leftRange == null || rightRange == null) return null;
     BinaryOperation operation = instruction.operation(info.constantSystem);
     return operation.apply(leftRange, rightRange);
   }
 }