Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/js_backend/constant_system_javascript.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 js_backend;
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
 
 class JavaScriptBitNotOperation extends BitNotOperation {
   const JavaScriptBitNotOperation();
 
-  Constant fold(Constant constant) {
+  ConstantValue fold(ConstantValue constant) {
     if (JAVA_SCRIPT_CONSTANT_SYSTEM.isInt(constant)) {
       // In JavaScript we don't check for -0 and treat it as if it was zero.
       if (constant.isMinusZero) constant = DART_CONSTANT_SYSTEM.createInt(0);
-      IntConstant intConstant = constant;
+      IntConstantValue intConstant = constant;
       // We convert the result of bit-operations to 32 bit unsigned integers.
-      return JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(~intConstant.value);
+      return
+          JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(~intConstant.primitiveValue);
     }
     return null;
   }
 }
 
 /**
  * In JavaScript we truncate the result to an unsigned 32 bit integer. Also, -0
  * is treated as if it was the integer 0.
  */
 class JavaScriptBinaryBitOperation implements BinaryOperation {
   final BinaryBitOperation dartBitOperation;
 
   const JavaScriptBinaryBitOperation(this.dartBitOperation);
 
   String get name => dartBitOperation.name;
 
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     // In JavaScript we don't check for -0 and treat it as if it was zero.
     if (left.isMinusZero) left = DART_CONSTANT_SYSTEM.createInt(0);
     if (right.isMinusZero) right = DART_CONSTANT_SYSTEM.createInt(0);
-    IntConstant result = dartBitOperation.fold(left, right);
+    IntConstantValue result = dartBitOperation.fold(left, right);
     if (result != null) {
       // We convert the result of bit-operations to 32 bit unsigned integers.
-      return JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(result.value);
+      return JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(result.primitiveValue);
     }
     return result;
   }
 
   apply(left, right) => dartBitOperation.apply(left, right);
 }
 
 class JavaScriptShiftRightOperation extends JavaScriptBinaryBitOperation {
   const JavaScriptShiftRightOperation() : super(const ShiftRightOperation());
 
-  Constant fold(Constant left, Constant right) {
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
     // Truncate the input value to 32 bits if necessary.
     if (left.isInt) {
-      IntConstant intConstant = left;
-      int value = intConstant.value;
+      IntConstantValue intConstant = left;
+      int value = intConstant.primitiveValue;
       int truncatedValue = value & JAVA_SCRIPT_CONSTANT_SYSTEM.BITS32;
       if (value < 0) {
         // Sign-extend if the input was negative. The current semantics don't
         // make much sense, since we only look at bit 31.
         // TODO(floitsch): we should treat the input to right shifts as
         // unsigned.
 
         // A 32 bit complement-two value x can be computed by:
         //    x_u - 2^32 (where x_u is its unsigned representation).
         // Example: 0xFFFFFFFF - 0x100000000 => -1.
@@ skipping 10 matching lines @@
   }
 }
 
 class JavaScriptNegateOperation implements UnaryOperation {
   final NegateOperation dartNegateOperation = const NegateOperation();
 
   const JavaScriptNegateOperation();
 
   String get name => dartNegateOperation.name;
 
-  Constant fold(Constant constant) {
+  ConstantValue fold(ConstantValue constant) {
     if (constant.isInt) {
-      IntConstant intConstant = constant;
-      if (intConstant.value == 0) {
+      IntConstantValue intConstant = constant;
+      if (intConstant.primitiveValue == 0) {
         return JAVA_SCRIPT_CONSTANT_SYSTEM.createDouble(-0.0);
       }
     }
     return dartNegateOperation.fold(constant);
   }
 }
 
 class JavaScriptBinaryArithmeticOperation implements BinaryOperation {
   final BinaryOperation dartArithmeticOperation;
 
   const JavaScriptBinaryArithmeticOperation(this.dartArithmeticOperation);
 
   String get name => dartArithmeticOperation.name;
 
-  Constant fold(Constant left, Constant right) {
-    Constant result = dartArithmeticOperation.fold(left, right);
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
+    ConstantValue result = dartArithmeticOperation.fold(left, right);
     if (result == null) return result;
     return JAVA_SCRIPT_CONSTANT_SYSTEM.convertToJavaScriptConstant(result);
   }
 
   apply(left, right) => dartArithmeticOperation.apply(left, right);
 }
 
 class JavaScriptIdentityOperation implements BinaryOperation {
   final IdentityOperation dartIdentityOperation = const IdentityOperation();
 
   const JavaScriptIdentityOperation();
 
   String get name => dartIdentityOperation.name;
 
-  BoolConstant fold(Constant left, Constant right) {
-    BoolConstant result = dartIdentityOperation.fold(left, right);
-    if (result == null || result.value) return result;
+  BoolConstantValue fold(ConstantValue left, ConstantValue right) {
+    BoolConstantValue result = dartIdentityOperation.fold(left, right);
+    if (result == null || result.primitiveValue) return result;
     // In JavaScript -0.0 === 0 and all doubles are equal to their integer
     // values. Furthermore NaN !== NaN.
     if (left.isNum && right.isNum) {
-      NumConstant leftNum = left;
-      NumConstant rightNum = right;
-      double leftDouble = leftNum.value.toDouble();
-      double rightDouble = rightNum.value.toDouble();
-      return new BoolConstant(leftDouble == rightDouble);
+      NumConstantValue leftNum = left;
+      NumConstantValue rightNum = right;
+      double leftDouble = leftNum.primitiveValue.toDouble();
+      double rightDouble = rightNum.primitiveValue.toDouble();
+      return new BoolConstantValue(leftDouble == rightDouble);
     }
     return result;
   }
 
   apply(left, right) => identical(left, right);
 }
 
 /**
  * Constant system following the semantics for Dart code that has been
  * compiled to JavaScript.
@@ skipping 35 matching lines @@
 
   /**
    * Returns true if [value] will turn into NaN or infinity
    * at runtime.
    */
   bool integerBecomesNanOrInfinity(int value) {
     double doubleValue = value.toDouble();
     return doubleValue.isNaN || doubleValue.isInfinite;
   }
 
-  NumConstant convertToJavaScriptConstant(NumConstant constant) {
+  NumConstantValue convertToJavaScriptConstant(NumConstantValue constant) {
     if (constant.isInt) {
-      IntConstant intConstant = constant;
-      int intValue = intConstant.value;
+      IntConstantValue intConstant = constant;
+      int intValue = intConstant.primitiveValue;
       if (integerBecomesNanOrInfinity(intValue)) {
-        return new DoubleConstant(intValue.toDouble());
+        return new DoubleConstantValue(intValue.toDouble());
       }
       // If the integer loses precision with JavaScript numbers, use
       // the floored version JavaScript will use.
       int floorValue = intValue.toDouble().floor().toInt();
       if (floorValue != intValue) {
-        return new IntConstant(floorValue);
+        return new IntConstantValue(floorValue);
       }
     } else if (constant.isDouble) {
-      DoubleConstant doubleResult = constant;
-      double doubleValue = doubleResult.value;
+      DoubleConstantValue doubleResult = constant;
+      double doubleValue = doubleResult.primitiveValue;
       if (!doubleValue.isInfinite && !doubleValue.isNaN &&
           !constant.isMinusZero) {
         int intValue = doubleValue.truncate();
         if (intValue == doubleValue) {
-          return new IntConstant(intValue);
+          return new IntConstantValue(intValue);
         }
       }
     }
     return constant;
   }
 
-  NumConstant createInt(int i)
-      => convertToJavaScriptConstant(new IntConstant(i));
-  NumConstant createInt32(int i) => new IntConstant(i & BITS32);
-  NumConstant createDouble(double d)
-      => convertToJavaScriptConstant(new DoubleConstant(d));
-  StringConstant createString(DartString string) => new StringConstant(string);
-  BoolConstant createBool(bool value) => new BoolConstant(value);
-  NullConstant createNull() => new NullConstant();
+  NumConstantValue createInt(int i)
+      => convertToJavaScriptConstant(new IntConstantValue(i));
+  NumConstantValue createInt32(int i) => new IntConstantValue(i & BITS32);
+  NumConstantValue createDouble(double d)
+      => convertToJavaScriptConstant(new DoubleConstantValue(d));
+  StringConstantValue createString(DartString string) {
+    return new StringConstantValue(string);
+  }
+  BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
+  NullConstantValue createNull() => new NullConstantValue();
 
   // Integer checks don't verify that the number is not -0.0.
-  bool isInt(Constant constant) => constant.isInt || constant.isMinusZero;
-  bool isDouble(Constant constant)
+  bool isInt(ConstantValue constant) => constant.isInt || constant.isMinusZero;
+  bool isDouble(ConstantValue constant)
       => constant.isDouble && !constant.isMinusZero;
-  bool isString(Constant constant) => constant.isString;
-  bool isBool(Constant constant) => constant.isBool;
-  bool isNull(Constant constant) => constant.isNull;
+  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) {
     // At runtime, an integer is both an integer and a double: the
     // integer type check is Math.floor, which will return true only
     // for real integers, and our double type check is 'typeof number'
     // which will return true for both integers and doubles.
     if (s.element == compiler.intClass && t.element == compiler.doubleClass) {
       return true;
     }
     return compiler.types.isSubtype(s, t);
   }
 
-  MapConstant createMap(Compiler compiler,
+  MapConstantValue createMap(Compiler compiler,
                         InterfaceType sourceType,
-                        List<Constant> keys,
-                        List<Constant> values) {
+                        List<ConstantValue> keys,
+                        List<ConstantValue> values) {
     JavaScriptBackend backend = compiler.backend;
 
     bool onlyStringKeys = true;
-    Constant protoValue = null;
+    ConstantValue protoValue = null;
     for (int i = 0; i < keys.length ; i++) {
       var key = keys[i];
       if (key.isString) {
-        if (key.value == JavaScriptMapConstant.PROTO_PROPERTY) {
+        if (key.primitiveValue == JavaScriptMapConstant.PROTO_PROPERTY) {
           protoValue = values[i];
         }
       } else {
         onlyStringKeys = false;
         // Don't handle __proto__ values specially in the general map case.
         protoValue = null;
         break;
       }
     }
 
     bool hasProtoKey = (protoValue != null);
     DartType keysType;
     if (sourceType.treatAsRaw) {
       keysType = compiler.listClass.rawType;
     } else {
       List<DartType> arguments = <DartType>[sourceType.typeArguments.first];
       keysType = new InterfaceType(compiler.listClass, arguments);
     }
-    ListConstant keysList = new ListConstant(keysType, keys);
+    ListConstantValue keysList = new ListConstantValue(keysType, keys);
     String className = onlyStringKeys
         ? (hasProtoKey ? JavaScriptMapConstant.DART_PROTO_CLASS
                        : JavaScriptMapConstant.DART_STRING_CLASS)
         : JavaScriptMapConstant.DART_GENERAL_CLASS;
     ClassElement classElement = backend.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     List<DartType> typeArgument = sourceType.typeArguments;
     InterfaceType type;
     if (sourceType.treatAsRaw) {
       type = classElement.rawType;
     } else {
       type = new InterfaceType(classElement, typeArgument);
     }
     return new JavaScriptMapConstant(
         type, keysList, values, protoValue, onlyStringKeys);
 
   }
 }
 
-class JavaScriptMapConstant extends MapConstant {
+class JavaScriptMapConstant extends MapConstantValue {
   /**
    * The [PROTO_PROPERTY] must not be used as normal property in any JavaScript
    * object. It would change the prototype chain.
    */
   static const LiteralDartString PROTO_PROPERTY =
       const LiteralDartString("__proto__");
 
   /** The dart class implementing constant map literals. */
   static const String DART_CLASS = "ConstantMap";
   static const String DART_STRING_CLASS = "ConstantStringMap";
   static const String DART_PROTO_CLASS = "ConstantProtoMap";
   static const String DART_GENERAL_CLASS = "GeneralConstantMap";
   static const String LENGTH_NAME = "length";
   static const String JS_OBJECT_NAME = "_jsObject";
   static const String KEYS_NAME = "_keys";
   static const String PROTO_VALUE = "_protoValue";
   static const String JS_DATA_NAME = "_jsData";
 
-  final ListConstant keyList;
-  final Constant protoValue;
+  final ListConstantValue keyList;
+  final ConstantValue protoValue;
   final bool onlyStringKeys;
 
   JavaScriptMapConstant(InterfaceType type,
-                        ListConstant keyList,
-                        List<Constant> values,
+                        ListConstantValue keyList,
+                        List<ConstantValue> values,
                         this.protoValue,
                         this.onlyStringKeys)
       : this.keyList = keyList,
         super(type, keyList.entries, values);
   bool get isMap => true;
 
   TypeMask computeMask(Compiler compiler) {
     return compiler.typesTask.constMapType;
   }
 
-  List<Constant> getDependencies() {
-    List<Constant> result = <Constant>[];
+  List<ConstantValue> getDependencies() {
+    List<ConstantValue> result = <ConstantValue>[];
     if (onlyStringKeys) {
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }