Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/new_js_emitter/emitter.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 dart2js.new_js_emitter.emitter;
 
 import 'model.dart';
 import 'model_emitter.dart';
 import '../common.dart';
 import '../js/js.dart' as js;
 
-import '../constants/values.dart' show PrimitiveConstant;
+import '../constants/values.dart' show PrimitiveConstantValue;
 import '../tree/tree.dart' show DartString;
 
 import '../js_backend/js_backend.dart' show Namer, JavaScriptBackend;
 import '../js_emitter/js_emitter.dart' as emitterTask show
     CodeEmitterTask,
     Emitter;
 
 import '../universe/universe.dart' show Universe;
 import '../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
@@ skipping 170 matching lines @@
 
   StaticMethod _buildStaticMethodTearOff(FunctionElement element) {
     String name = namer.getStaticClosureName(element);
     String holder = namer.globalObjectFor(element);
     // TODO(kasperl): This clearly doesn't work yet.
     js.Expression code = js.string("<<unimplemented>>");
     return new StaticMethod(name, _registry.registerHolder(holder), code);
   }
 
   // TODO(floitsch): copied from OldEmitter. Adjust or share.
-  bool isConstantInlinedOrAlreadyEmitted(Constant constant) {
+  bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
 
   // TODO(floitsch): copied from OldEmitter. Adjust or share.
-  int compareConstants(Constant a, Constant b) {
+  int compareConstants(ConstantValue a, ConstantValue b) {
     // Inlined constants don't affect the order and sometimes don't even have
     // names.
     int cmp1 = isConstantInlinedOrAlreadyEmitted(a) ? 0 : 1;
     int cmp2 = isConstantInlinedOrAlreadyEmitted(b) ? 0 : 1;
     if (cmp1 + cmp2 < 2) return cmp1 - cmp2;
 
     // Emit constant interceptors first. Constant interceptors for primitives
     // might be used by code that builds other constants.  See Issue 18173.
     if (a.isInterceptor != b.isInterceptor) {
       return a.isInterceptor ? -1 : 1;
     }
 
     // Sorting by the long name clusters constants with the same constructor
     // which compresses a tiny bit better.
     int r = namer.constantLongName(a).compareTo(namer.constantLongName(b));
     if (r != 0) return r;
     // Resolve collisions in the long name by using the constant name (i.e. JS
     // name) which is unique.
     return namer.constantName(a).compareTo(namer.constantName(b));
   }
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     // TODO(floitsch): We should not use "init" for globals.
     return js.string("init.$global");
   }
 
-  js.Expression constantReference(Constant value) {
+  js.Expression constantReference(ConstantValue value) {
     if (!value.isPrimitive) return js.string("<<unimplemented>>");
-    PrimitiveConstant constant = value;
+    PrimitiveConstantValue constant = value;
     if (constant.isBool) return new js.LiteralBool(constant.isTrue);
     if (constant.isString) {
-      DartString dartString = constant.value;
+      DartString dartString = constant.primitiveValue;
       return js.string(dartString.slowToString());
     }
-    if (constant.isNum) return js.number(constant.value);
+    if (constant.isNum) return js.number(constant.primitiveValue);
     if (constant.isNull) return new js.LiteralNull();
     return js.string("<<unimplemented>>");
   }
 
   void invalidateCaches() {}
 }