Rename Constant to ConstantValue and ConstExp to ConstantExpression.

tests/compiler/dart2js/backend_dart/dart_printer_test.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.
 
 library dart_printer_test;
 
 import "package:expect/expect.dart";
 import 'package:compiler/implementation/constants/values.dart';
 import 'package:compiler/implementation/dart_backend/backend_ast_nodes.dart';
 import 'package:compiler/implementation/scanner/scannerlib.dart';
@@ skipping 173 matching lines @@
       var part = parts[i];
       if (part is Expression) {
         members.add(part);
       } else {
         assert(part is Token);
         DartString str = stringValidator.validateInterpolationPart(
             part as Token,
             quoting,
             isFirst: i == 0,
             isLast: i == parts.length - 1);
-        members.add(new Literal(new StringConstant(str)));
+        members.add(new Literal(new StringConstantValue(str)));
       }
     }
     push(new StringConcat(members));
   }
   handleStringJuxtaposition(int litCount) {
     push(new StringConcat(popList(litCount, <Expression>[])));
   }
   endArguments(int count, begin, end) {
     push(popList(count, <Argument>[]));
   }
@@ skipping 76 matching lines @@
       push(r);
     }
   }
   handleAsOperator(operathor, endToken) {
     TypeAnnotation type = popTypeAnnotation();
     Expression exp = pop();
     push(new TypeOperator(exp, 'as', type));
   }
   handleLiteralBool(Token t) {
     bool value = t.value == 'true';
-    push(new Literal(value ? new TrueConstant() : new FalseConstant()));
+    push(new Literal(
+        value ? new TrueConstantValue() : new FalseConstantValue()));
   }
   handleLiteralDouble(t) {
-    push(new Literal(new DoubleConstant(double.parse(t.value))));
+    push(new Literal(new DoubleConstantValue(double.parse(t.value))));
   }
   handleLiteralInt(Token t) {
-    push(new Literal(new IntConstant(int.parse(t.value))));
+    push(new Literal(new IntConstantValue(int.parse(t.value))));
   }
   handleLiteralNull(t) {
-    push(new Literal(new NullConstant()));
+    push(new Literal(new NullConstantValue()));
   }
   endLiteralSymbol(Token hash, int idCount) {
     List<Identifier> ids = popList(idCount, <Identifier>[]);
     push(new LiteralSymbol(ids.map((id) => id.name).join('.')));
   }
   handleLiteralList(int count, begin, constKeyword, end) {
     List<Expression> exps = popList(count, <Expression>[]);
     List<TypeAnnotation> types = pop();
     assert(types.length <= 1);
     push(new LiteralList(exps,
@@ skipping 321 matching lines @@
         continue; // do not check things from Object, such as hashCode
       }
       MethodMirror mm = xm.type.instanceMembers[name];
       if (mm.isGetter) {
         var xv = xm.getField(name).reflectee;
         var yv = ym.getField(name).reflectee;
         checkDeepEqual(xv,yv);
       }
     }
   }
-  else if (x is PrimitiveConstant && y is PrimitiveConstant) {
-    checkDeepEqual(x.value, y.value);
+  else if (x is PrimitiveConstantValue && y is PrimitiveConstantValue) {
+    checkDeepEqual(x.primitiveValue, y.primitiveValue);
   }
   else if (x is DartString && y is DartString) {
     if (x.slowToString() != y.slowToString()) {
       throw new Error();
     }
   }
   else {
     if (x != y) {
       throw new Error();
     }
@@ skipping 311 matching lines @@
   checkStatement("do while(x); while (y);");
   checkStatement("{do; while(x); while (y);}");
 
   checkStatement('switch(x) { case 1: case 2: return y; }');
   checkStatement('switch(x) { default: return y; }');
   checkStatement('switch(x) { case 1: x=y; default: return y; }');
   checkStatement('switch(x) { case 1: x=y; y=z; break; default: return y; }');
 
 }