Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/js_emitter/old_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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   TypeTestEmitter get typeTestEmitter => task.typeTestEmitter;
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
   final MetadataEmitter metadataEmitter = new MetadataEmitter();
 
-  final Set<Constant> cachedEmittedConstants;
+  final Set<ConstantValue> cachedEmittedConstants;
   final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter get nativeEmitter => task.nativeEmitter;
 
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeBuffer> outputBuffers = new Map<OutputUnit, CodeBuffer>();
   final CodeBuffer deferredConstants = new CodeBuffer();
 
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
-  Map<OutputUnit, List<Constant>> get outputConstantLists
+  Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
   List<ClassElement> get nativeClasses => task.nativeClasses;
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
   final Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties =
       new Map<ClassElement, Map<String, jsAst.Expression>>();
 
   Set<ClassElement> get instantiatedClasses => task.instantiatedClasses;
@@ skipping 82 matching lines @@
   /// Used by the incremental compiler.
   void clearCspPrecompiledNodes() {
     _cspPrecompiledFunctions.clear();
     _cspPrecompiledConstructorNames.clear();
   }
 
   void addComment(String comment, CodeBuffer buffer) {
     buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
-  jsAst.Expression constantReference(Constant value) {
+  jsAst.Expression constantReference(ConstantValue value) {
     return constantEmitter.reference(value);
   }
 
-  jsAst.Expression constantInitializerExpression(Constant value) {
+  jsAst.Expression constantInitializerExpression(ConstantValue value) {
     return constantEmitter.initializationExpression(value);
   }
 
   String get name => 'CodeEmitter';
 
   String get currentGenerateAccessorName
       => '${namer.currentIsolate}.\$generateAccessor';
   String get generateAccessorHolder
       => '$isolatePropertiesName.\$generateAccessor';
   String get finishClassesProperty
@@ skipping 736 matching lines @@
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     JavaScriptConstantCompiler handler = backend.constants;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
       // `mapTypeToInterceptor` is handled in [emitMapTypeToInterceptor].
       if (element == backend.mapTypeToInterceptor) continue;
       compiler.withCurrentElement(element, () {
-        Constant initialValue = handler.getInitialValueFor(element).value;
+        ConstantValue initialValue = handler.getInitialValueFor(element).value;
         jsAst.Expression init =
           js('$isolateProperties.# = #',
               [namer.getNameOfGlobalField(element),
                constantEmitter.referenceInInitializationContext(initialValue)]);
         buffer.write(jsAst.prettyPrint(init, compiler,
                                        monitor: compiler.dumpInfoTask));
         buffer.write('$N');
       });
     }
   }
@@ skipping 29 matching lines @@
         buffer.write("$N");
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
 
-  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;
   }
 
-  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));
   }
 
   void emitCompileTimeConstants(CodeBuffer buffer, OutputUnit outputUnit) {
-    List<Constant> constants = outputConstantLists[outputUnit];
+    List<ConstantValue> constants = outputConstantLists[outputUnit];
     if (constants == null) return;
     bool isMainBuffer = buffer == mainBuffer;
     if (compiler.hasIncrementalSupport && isMainBuffer) {
       buffer = cachedEmittedConstantsBuffer;
     }
-    for (Constant constant in constants) {
+    for (ConstantValue constant in constants) {
       if (compiler.hasIncrementalSupport && isMainBuffer) {
         if (cachedEmittedConstants.contains(constant)) continue;
         cachedEmittedConstants.add(constant);
       }
       String name = namer.constantName(constant);
       if (constant.isList) emitMakeConstantListIfNotEmitted(buffer);
       jsAst.Expression init = js('#.# = #',
           [namer.globalObjectForConstant(constant), name,
            constantInitializerExpression(constant)]);
       buffer.write(jsAst.prettyPrint(init, compiler,
@@ skipping 912 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }