Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 198 matching lines @@
 
   HInstruction visitInvokeUnary(HInvokeUnary node) {
     HInstruction folded =
         foldUnary(node.operation(constantSystem), node.operand);
     return folded != null ? folded : node;
   }
 
   HInstruction foldUnary(UnaryOperation operation, HInstruction operand) {
     if (operand is HConstant) {
       HConstant receiver = operand;
-      Constant folded = operation.fold(receiver.constant);
+      ConstantValue folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded, compiler);
     }
     return null;
   }
 
   HInstruction tryOptimizeLengthInterceptedGetter(HInvokeDynamic node) {
     HInstruction actualReceiver = node.inputs[1];
     if (actualReceiver.isIndexablePrimitive(compiler)) {
       if (actualReceiver.isConstantString()) {
         HConstant constantInput = actualReceiver;
-        StringConstant constant = constantInput.constant;
+        StringConstantValue constant = constantInput.constant;
         return graph.addConstantInt(constant.length, compiler);
       } else if (actualReceiver.isConstantList()) {
         HConstant constantInput = actualReceiver;
-        ListConstant constant = constantInput.constant;
+        ListConstantValue constant = constantInput.constant;
         return graph.addConstantInt(constant.length, compiler);
       }
       Element element = backend.jsIndexableLength;
       bool isFixed = isFixedLength(actualReceiver.instructionType, compiler);
       HFieldGet result = new HFieldGet(
           element, actualReceiver, backend.positiveIntType,
           isAssignable: !isFixed);
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
-      MapConstant constant = constantInput.constant;
+      MapConstantValue constant = constantInput.constant;
       return graph.addConstantInt(constant.length, compiler);
     }
     return null;
   }
 
   HInstruction handleInterceptedCall(HInvokeDynamic node) {
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
@@ skipping 176 matching lines @@
     }
     return node;
   }
 
   HInstruction foldBinary(BinaryOperation operation,
                           HInstruction left,
                           HInstruction right) {
     if (left is HConstant && right is HConstant) {
       HConstant op1 = left;
       HConstant op2 = right;
-      Constant folded = operation.fold(op1.constant, op2.constant);
+      ConstantValue folded = operation.fold(op1.constant, op2.constant);
       if (folded != null) return graph.addConstant(folded, compiler);
     }
     return null;
   }
 
   HInstruction visitAdd(HAdd node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     // We can only perform this rewriting on Integer, as it is not
     // valid for -0.0.
@@ skipping 263 matching lines @@
           } else {
             return constant;
           }
         }
       }
     }
 
     // HFieldGet of a constructed constant can be replaced with the constant's
     // field.
     if (receiver is HConstant) {
-      Constant constant = receiver.constant;
+      ConstantValue constant = receiver.constant;
       if (constant.isConstructedObject) {
-        ConstructedConstant constructedConstant = constant;
-        Map<Element, Constant> fields = constructedConstant.fieldElements;
-        Constant value = fields[node.element];
+        ConstructedConstantValue constructedConstant = constant;
+        Map<Element, ConstantValue> fields = constructedConstant.fieldElements;
+        ConstantValue value = fields[node.element];
         if (value != null) {
           return graph.addConstant(value, compiler);
         }
       }
     }
 
     return node;
   }
 
   HInstruction visitIndex(HIndex node) {
     if (node.receiver.isConstantList() && node.index.isConstantInteger()) {
       var instruction = node.receiver;
-      List<Constant> entries = instruction.constant.entries;
+      List<ConstantValue> entries = instruction.constant.entries;
       instruction = node.index;
-      int index = instruction.constant.value;
+      int index = instruction.constant.primitiveValue;
       if (index >= 0 && index < entries.length) {
         return graph.addConstant(entries[index], compiler);
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
@@ skipping 55 matching lines @@
   }
 
   HInstruction visitStringConcat(HStringConcat node) {
     // Simplify string concat:
     //
     //     "" + R                ->  R
     //     L + ""                ->  L
     //     "L" + "R"             ->  "LR"
     //     (prefix + "L") + "R"  ->  prefix + "LR"
     //
-    StringConstant getString(HInstruction instruction) {
+    StringConstantValue getString(HInstruction instruction) {
       if (!instruction.isConstantString()) return null;
       HConstant constant = instruction;
       return constant.constant;
     }
 
-    StringConstant leftString = getString(node.left);
-    if (leftString != null && leftString.value.length == 0) return node.right;
+    StringConstantValue leftString = getString(node.left);
+    if (leftString != null && leftString.primitiveValue.length == 0) {
+      return node.right;
+    }
 
-    StringConstant rightString = getString(node.right);
+    StringConstantValue rightString = getString(node.right);
     if (rightString == null) return node;
-    if (rightString.value.length == 0) return node.left;
+    if (rightString.primitiveValue.length == 0) return node.left;
 
     HInstruction prefix = null;
     if (leftString == null) {
       if (node.left is! HStringConcat) return node;
       HStringConcat leftConcat = node.left;
       // Don't undo CSE.
       if (leftConcat.usedBy.length != 1) return node;
       prefix = leftConcat.left;
       leftString = getString(leftConcat.right);
       if (leftString == null) return node;
     }
 
-    if (leftString.value.length + rightString.value.length >
+    if (leftString.primitiveValue.length + rightString.primitiveValue.length >
         MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH) {
       if (node.usedBy.length > 1) return node;
     }
 
     HInstruction folded = graph.addConstant(
-        constantSystem.createString(
-            new ast.DartString.concat(leftString.value, rightString.value)),
+        constantSystem.createString(new ast.DartString.concat(
+            leftString.primitiveValue, rightString.primitiveValue)),
         compiler);
     if (prefix == null) return folded;
     return new HStringConcat(prefix, folded, node.node, backend.stringType);
   }
 
   HInstruction visitStringify(HStringify node) {
     HInstruction input = node.inputs[0];
     if (input.isString(compiler)) return input;
     if (input.isConstant()) {
       HConstant constant = input;
       if (!constant.constant.isPrimitive) return node;
       if (constant.constant.isInt) {
         // Only constant-fold int.toString() when Dart and JS results the same.
         // TODO(18103): We should be able to remove this work-around when issue
         // 18103 is resolved by providing the correct string.
-        IntConstant intConstant = constant.constant;
+        IntConstantValue intConstant = constant.constant;
         // Very conservative range.
         if (!intConstant.isUInt32()) return node;
       }
-      PrimitiveConstant primitive = constant.constant;
+      PrimitiveConstantValue primitive = constant.constant;
       return graph.addConstant(constantSystem.createString(
           primitive.toDartString()), compiler);
     }
     return node;
   }
 
   HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
     return handleInterceptedCall(node);
   }
 }
@@ skipping 79 matching lines @@
 
   final Compiler compiler;
   SsaLiveBlockAnalyzer analyzer;
   bool eliminatedSideEffects = false;
   SsaDeadCodeEliminator(this.compiler);
 
   HInstruction zapInstructionCache;
   HInstruction get zapInstruction {
     if (zapInstructionCache == null) {
       // A constant with no type does not pollute types at phi nodes.
-      Constant constant = new DummyConstant(const TypeMask.nonNullEmpty());
+      ConstantValue constant =
+          new DummyConstantValue(const TypeMask.nonNullEmpty());
       zapInstructionCache = analyzer.graph.addConstant(constant, compiler);
     }
     return zapInstructionCache;
   }
 
   /// Returns whether the next throwing instruction that may have side
   /// effects after [instruction], throws [NoSuchMethodError] on the
   /// same receiver of [instruction].
   bool hasFollowingThrowingNSM(HInstruction instruction) {
     HInstruction receiver = instruction.getDartReceiver(compiler);
@@ skipping 166 matching lines @@
           switchRange.lower is IntValue &&
           switchRange.upper is IntValue) {
         IntValue lowerValue = switchRange.lower;
         IntValue upperValue = switchRange.upper;
         int lower = lowerValue.value;
         int upper = upperValue.value;
         Set<int> liveLabels = new Set<int>();
         for (int pos = 1; pos < node.inputs.length; pos++) {
           HConstant input = node.inputs[pos];
           if (!input.isConstantInteger()) continue;
-          IntConstant constant = input.constant;
-          int label = constant.value;
+          IntConstantValue constant = input.constant;
+          int label = constant.primitiveValue;
           if (!liveLabels.contains(label) &&
               label <= upper &&
               label >= lower) {
             markBlockLive(node.block.successors[pos - 1]);
             liveLabels.add(label);
           }
         }
         if (liveLabels.length != upper - lower + 1) {
           markBlockLive(node.defaultTarget);
         }
@@ skipping 968 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }