Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/constant_system_dart.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 dart2js;
 
 const DART_CONSTANT_SYSTEM = const DartConstantSystem();
 
 class BitNotOperation implements UnaryOperation {
   final String name = '~';
   const BitNotOperation();
-  Constant fold(Constant constant) {
+  ConstantValue fold(ConstantValue constant) {
     if (constant.isInt) {
-      IntConstant intConstant = constant;
-      return DART_CONSTANT_SYSTEM.createInt(~intConstant.value);
+      IntConstantValue intConstant = constant;
+      return DART_CONSTANT_SYSTEM.createInt(~intConstant.primitiveValue);
     }
     return null;
   }
 }
 
 class NegateOperation implements UnaryOperation {
   final String name = 'negate';
   const NegateOperation();
-  Constant fold(Constant constant) {
+  ConstantValue fold(ConstantValue constant) {
     if (constant.isInt) {
-      IntConstant intConstant = constant;
-      return DART_CONSTANT_SYSTEM.createInt(-intConstant.value);
+      IntConstantValue intConstant = constant;
+      return DART_CONSTANT_SYSTEM.createInt(-intConstant.primitiveValue);
     }
     if (constant.isDouble) {
-      DoubleConstant doubleConstant = constant;
-      return DART_CONSTANT_SYSTEM.createDouble(-doubleConstant.value);
+      DoubleConstantValue doubleConstant = constant;
+      return DART_CONSTANT_SYSTEM.createDouble(-doubleConstant.primitiveValue);
     }
     return null;
   }
 }
 
 class NotOperation implements UnaryOperation {
   final String name = '!';
   const NotOperation();
-  Constant fold(Constant constant) {
+  ConstantValue fold(ConstantValue constant) {
     if (constant.isBool) {
-      BoolConstant boolConstant = constant;
-      return DART_CONSTANT_SYSTEM.createBool(!boolConstant.value);
+      BoolConstantValue boolConstant = constant;
+      return DART_CONSTANT_SYSTEM.createBool(!boolConstant.primitiveValue);
     }
     return null;
   }
 }
 
 /**
  * Operations that only work if both arguments are integers.
  */
 abstract class BinaryBitOperation implements BinaryOperation {
   const BinaryBitOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isInt && right.isInt) {
-      IntConstant leftInt = left;
-      IntConstant rightInt = right;
-      int resultValue = foldInts(leftInt.value, rightInt.value);
+      IntConstantValue leftInt = left;
+      IntConstantValue rightInt = right;
+      int resultValue =
+          foldInts(leftInt.primitiveValue, rightInt.primitiveValue);
       if (resultValue == null) return null;
       return DART_CONSTANT_SYSTEM.createInt(resultValue);
     }
     return null;
   }
 
   int foldInts(int left, int right);
 }
 
 class BitOrOperation extends BinaryBitOperation {
@@ skipping 34 matching lines @@
   const ShiftRightOperation();
   int foldInts(int left, int right) {
     if (right < 0) return null;
     return left >> right;
   }
   apply(left, right) => left >> right;
 }
 
 abstract class BinaryBoolOperation implements BinaryOperation {
   const BinaryBoolOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isBool && right.isBool) {
-      BoolConstant leftBool = left;
-      BoolConstant rightBool = right;
-      bool resultValue = foldBools(leftBool.value, rightBool.value);
+      BoolConstantValue leftBool = left;
+      BoolConstantValue rightBool = right;
+      bool resultValue =
+          foldBools(leftBool.primitiveValue, rightBool.primitiveValue);
       return DART_CONSTANT_SYSTEM.createBool(resultValue);
     }
     return null;
   }
 
   bool foldBools(bool left, bool right);
 }
 
 class BooleanAndOperation extends BinaryBoolOperation {
   final String name = '&&';
   const BooleanAndOperation();
   bool foldBools(bool left, bool right) => left && right;
   apply(left, right) => left && right;
 }
 
 class BooleanOrOperation extends BinaryBoolOperation {
   final String name = '||';
   const BooleanOrOperation();
   bool foldBools(bool left, bool right) => left || right;
   apply(left, right) => left || right;
 }
 
 abstract class ArithmeticNumOperation implements BinaryOperation {
   const ArithmeticNumOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isNum && right.isNum) {
-      NumConstant leftNum = left;
-      NumConstant rightNum = right;
+      NumConstantValue leftNum = left;
+      NumConstantValue rightNum = right;
       num foldedValue;
       if (left.isInt && right.isInt) {
-        foldedValue = foldInts(leftNum.value, rightNum.value);
+        foldedValue = foldInts(leftNum.primitiveValue, rightNum.primitiveValue);
       } else {
-        foldedValue = foldNums(leftNum.value, rightNum.value);
+        foldedValue = foldNums(leftNum.primitiveValue, rightNum.primitiveValue);
       }
       // A division by 0 means that we might not have a folded value.
       if (foldedValue == null) return null;
       if (left.isInt && right.isInt && !isDivide() ||
           isTruncatingDivide()) {
         assert(foldedValue is int);
         return DART_CONSTANT_SYSTEM.createInt(foldedValue);
       } else {
         return DART_CONSTANT_SYSTEM.createDouble(foldedValue);
       }
@@ skipping 52 matching lines @@
   final String name = '/';
   const DivideOperation();
   num foldNums(num left, num right) => left / right;
   bool isDivide() => true;
   apply(left, right) => left / right;
 }
 
 class AddOperation implements BinaryOperation {
   final String name = '+';
   const AddOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isInt && right.isInt) {
-      IntConstant leftInt = left;
-      IntConstant rightInt = right;
-      int result = leftInt.value + rightInt.value;
+      IntConstantValue leftInt = left;
+      IntConstantValue rightInt = right;
+      int result = leftInt.primitiveValue + rightInt.primitiveValue;
       return DART_CONSTANT_SYSTEM.createInt(result);
     } else if (left.isNum && right.isNum) {
-      NumConstant leftNum = left;
-      NumConstant rightNum = right;
-      double result = leftNum.value + rightNum.value;
+      NumConstantValue leftNum = left;
+      NumConstantValue rightNum = right;
+      double result = leftNum.primitiveValue + rightNum.primitiveValue;
       return DART_CONSTANT_SYSTEM.createDouble(result);
     } else {
       return null;
     }
   }
   apply(left, right) => left + right;
 }
 
 abstract class RelationalNumOperation implements BinaryOperation {
   const RelationalNumOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (!left.isNum || !right.isNum) return null;
-    NumConstant leftNum = left;
-    NumConstant rightNum = right;
-    bool foldedValue = foldNums(leftNum.value, rightNum.value);
+    NumConstantValue leftNum = left;
+    NumConstantValue rightNum = right;
+    bool foldedValue =
+        foldNums(leftNum.primitiveValue, rightNum.primitiveValue);
     assert(foldedValue != null);
     return DART_CONSTANT_SYSTEM.createBool(foldedValue);
   }
 
   bool foldNums(num left, num right);
 }
 
 class LessOperation extends RelationalNumOperation {
   final String name = '<';
   const LessOperation();
@@ skipping 18 matching lines @@
 class GreaterEqualOperation extends RelationalNumOperation {
   final String name = '>=';
   const GreaterEqualOperation();
   bool foldNums(num left, num right) => left >= right;
   apply(left, right) => left >= right;
 }
 
 class EqualsOperation implements BinaryOperation {
   final String name = '==';
   const EqualsOperation();
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     if (left.isNum && right.isNum) {
       // Numbers need to be treated specially because: NaN != NaN, -0.0 == 0.0,
       // and 1 == 1.0.
-      NumConstant leftNum = left;
-      NumConstant rightNum = right;
-      bool result = leftNum.value == rightNum.value;
+      NumConstantValue leftNum = left;
+      NumConstantValue rightNum = right;
+      bool result = leftNum.primitiveValue == rightNum.primitiveValue;
       return DART_CONSTANT_SYSTEM.createBool(result);
     }
     if (left.isConstructedObject) {
       // Unless we know that the user-defined object does not implement the
       // equality operator we cannot fold here.
       return null;
     }
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => left == right;
 }
 
 class IdentityOperation implements BinaryOperation {
   final String name = '===';
   const IdentityOperation();
-  BoolConstant fold(Constant left, Constant right) {
+  BoolConstantValue fold(ConstantValue left, ConstantValue right) {
     // In order to preserve runtime semantics which says that NaN !== NaN don't
     // constant fold NaN === NaN. Otherwise the output depends on inlined
     // variables and other optimizations.
     if (left.isNaN && right.isNaN) return null;
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => identical(left, right);
 }
 
 /**
@@ skipping 21 matching lines @@
   final multiply = const MultiplyOperation();
   final negate = const NegateOperation();
   final not = const NotOperation();
   final shiftLeft = const ShiftLeftOperation();
   final shiftRight = const ShiftRightOperation();
   final subtract = const SubtractOperation();
   final truncatingDivide = const TruncatingDivideOperation();
 
   const DartConstantSystem();
 
-  IntConstant createInt(int i) => new IntConstant(i);
-  DoubleConstant createDouble(double d) => new DoubleConstant(d);
-  StringConstant createString(DartString string) => new StringConstant(string);
-  BoolConstant createBool(bool value) => new BoolConstant(value);
-  NullConstant createNull() => new NullConstant();
-  MapConstant createMap(Compiler compiler, InterfaceType type,
-                        List<Constant> keys, List<Constant> values) {
-    return new MapConstant(type, keys, values);
+  IntConstantValue createInt(int i) => new IntConstantValue(i);
+  DoubleConstantValue createDouble(double d) => new DoubleConstantValue(d);
+  StringConstantValue createString(DartString string) {
+    return new StringConstantValue(string);
+  }
+  BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
+  NullConstantValue createNull() => new NullConstantValue();
+  MapConstantValue createMap(Compiler compiler,
+                             InterfaceType type,
+                             List<ConstantValue> keys,
+                             List<ConstantValue> values) {
+    return new MapConstantValue(type, keys, values);
   }
 
-  bool isInt(Constant constant) => constant.isInt;
-  bool isDouble(Constant constant) => constant.isDouble;
-  bool isString(Constant constant) => constant.isString;
-  bool isBool(Constant constant) => constant.isBool;
-  bool isNull(Constant constant) => constant.isNull;
+  bool isInt(ConstantValue constant) => constant.isInt;
+  bool isDouble(ConstantValue constant) => constant.isDouble;
+  bool isString(ConstantValue constant) => constant.isString;
+  bool isBool(ConstantValue constant) => constant.isBool;
+  bool isNull(ConstantValue constant) => constant.isNull;
 
   bool isSubtype(Compiler compiler, DartType s, DartType t) {
     return compiler.types.isSubtype(s, t);
   }
 }