Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/js_backend/namer.dart

 // Copyright (c) 2011, 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;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 238 matching lines @@
   final Set<String> usedGlobalNames;
   final Set<String> usedInstanceNames;
   final Map<String, String> globalNameMap;
   final Map<String, String> suggestedGlobalNames;
   final Map<String, String> instanceNameMap;
   final Map<String, String> suggestedInstanceNames;
 
   final Map<String, String> operatorNameMap;
   final Map<String, int> popularNameCounters;
 
-  final Map<Constant, String> constantNames;
-  final Map<Constant, String> constantLongNames;
+  final Map<ConstantValue, String> constantNames;
+  final Map<ConstantValue, String> constantLongNames;
   ConstantCanonicalHasher constantHasher;
 
   // All alphanumeric characters.
   static const String _alphaNumeric =
       'abcdefghijklmnopqrstuvwxyzABZDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
 
   Namer(Compiler compiler)
       : compiler = compiler,
         globals = new Map<Element, String>(),
         shortPrivateNameOwners = new Map<String, LibraryElement>(),
         usedGlobalNames = new Set<String>(),
         usedInstanceNames = new Set<String>(),
         instanceNameMap = new Map<String, String>(),
         operatorNameMap = new Map<String, String>(),
         globalNameMap = new Map<String, String>(),
         suggestedGlobalNames = new Map<String, String>(),
         suggestedInstanceNames = new Map<String, String>(),
         popularNameCounters = new Map<String, int>(),
-        constantNames = new Map<Constant, String>(),
-        constantLongNames = new Map<Constant, String>(),
+        constantNames = new Map<ConstantValue, String>(),
+        constantLongNames = new Map<ConstantValue, String>(),
         constantHasher = new ConstantCanonicalHasher(compiler),
         functionTypeNamer = new FunctionTypeNamer(compiler);
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
   /**
    * Some closures must contain their name. The name is stored in
    * [STATIC_CLOSURE_NAME_NAME].
@@ skipping 11 matching lines @@
       case 'REFLECTABLE': return reflectableField;
       case 'CLASS_DESCRIPTOR_PROPERTY': return classDescriptorProperty;
       default:
         compiler.reportError(
             node, MessageKind.GENERIC,
             {'text': 'Error: Namer has no name for "$name".'});
         return 'BROKEN';
     }
   }
 
-  String constantName(Constant constant) {
+  String constantName(ConstantValue constant) {
     // In the current implementation it doesn't make sense to give names to
     // function constants since the function-implementation itself serves as
     // constant and can be accessed directly.
     assert(!constant.isFunction);
     String result = constantNames[constant];
     if (result == null) {
       String longName = constantLongName(constant);
       result = getFreshName(longName, usedGlobalNames, suggestedGlobalNames,
                             ensureSafe: true);
       constantNames[constant] = result;
     }
     return result;
   }
 
   // The long name is unminified and may have collisions.
-  String constantLongName(Constant constant) {
+  String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
       longName = new ConstantNamingVisitor(compiler, constantHasher)
           .getName(constant);
       constantLongNames[constant] = longName;
     }
     return longName;
   }
 
   String breakLabelName(LabelDefinition label) {
@@ skipping 534 matching lines @@
         [globalObjectFor(element), getStaticClosureName(element)]);
   }
 
   // This name is used as part of the name of a TypeConstant
   String uniqueNameForTypeConstantElement(Element element) {
     // TODO(sra): If we replace the period with an identifier character,
     // TypeConstants will have better names in unminified code.
     return "${globalObjectFor(element)}.${getNameX(element)}";
   }
 
-  String globalObjectForConstant(Constant constant) => 'C';
+  String globalObjectForConstant(ConstantValue constant) => 'C';
 
   String operatorIsPrefix() => r'$is';
 
   String operatorAsPrefix() => r'$as';
 
   String operatorSignature() => r'$signature';
 
   String typedefTag() => r'typedef';
 
   String functionTypeTag() => r'func';
@@ skipping 105 matching lines @@
 
   void forgetElement(Element element) {
     String globalName = globals[element];
     invariant(element, globalName != null, message: 'No global name.');
     usedGlobalNames.remove(globalName);
     globals.remove(element);
   }
 }
 
 /**
- * Generator of names for [Constant] values.
+ * Generator of names for [ConstantValue] values.
  *
  * The names are stable under perturbations of the source.  The name is either a
  * short sequence of words, if this can be found from the constant, or a type
  * followed by a hash tag.
  *
  *     List_imX                // A List, with hash tag.
  *     C_Sentinel              // const Sentinel(),  "C_" added to avoid clash
  *                             //   with class name.
  *     JSInt_methods           // an interceptor.
  *     Duration_16000          // const Duration(milliseconds: 16)
  *     EventKeyProvider_keyup  // const EventKeyProvider('keyup')
  *
  */
-class ConstantNamingVisitor implements ConstantVisitor {
+class ConstantNamingVisitor implements ConstantValueVisitor {
 
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static const MAX_FRAGMENTS = 5;
   static const MAX_EXTRA_LENGTH = 30;
   static const DEFAULT_TAG_LENGTH = 3;
 
   final Compiler compiler;
   final ConstantCanonicalHasher hasher;
 
   String root = null;     // First word, usually a type name.
   bool failed = false;    // Failed to generate something pretty.
   List<String> fragments = <String>[];
   int length = 0;
 
   ConstantNamingVisitor(this.compiler, this.hasher);
 
-  String getName(Constant constant) {
+  String getName(ConstantValue constant) {
     _visit(constant);
     if (root == null) return 'CONSTANT';
     if (failed) return '${root}_${getHashTag(constant, DEFAULT_TAG_LENGTH)}';
     if (fragments.length == 1) return 'C_${root}';
     return fragments.join('_');
   }
 
-  String getHashTag(Constant constant, int width) =>
+  String getHashTag(ConstantValue constant, int width) =>
       hashWord(hasher.getHash(constant), width);
 
   String hashWord(int hash, int length) {
     hash &= 0x1fffffff;
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < length; i++) {
       int digit = hash % 62;
       sb.write('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
           [digit]);
       hash ~/= 62;
@@ skipping 20 matching lines @@
   }
 
   void addIdentifier(String fragment) {
     if (fragment.length <= MAX_EXTRA_LENGTH && IDENTIFIER.hasMatch(fragment)) {
       add(fragment);
     } else {
       failed = true;
     }
   }
 
-  _visit(Constant constant) {
+  _visit(ConstantValue constant) {
     return constant.accept(this);
   }
 
-  visitFunction(FunctionConstant constant) {
+  visitFunction(FunctionConstantValue constant) {
     add(constant.element.name);
   }
 
-  visitNull(NullConstant constant) {
+  visitNull(NullConstantValue constant) {
     add('null');
   }
 
-  visitInt(IntConstant constant) {
+  visitInt(IntConstantValue constant) {
     // No `addRoot` since IntConstants are always inlined.
-    if (constant.value < 0) {
-      add('m${-constant.value}');
+    if (constant.primitiveValue < 0) {
+      add('m${-constant.primitiveValue}');
     } else {
-      add('${constant.value}');
+      add('${constant.primitiveValue}');
     }
   }
 
-  visitDouble(DoubleConstant constant) {
+  visitDouble(DoubleConstantValue constant) {
     failed = true;
   }
 
-  visitTrue(TrueConstant constant) {
+  visitTrue(TrueConstantValue constant) {
     add('true');
   }
 
-  visitFalse(FalseConstant constant) {
+  visitFalse(FalseConstantValue constant) {
     add('false');
   }
 
-  visitString(StringConstant constant) {
+  visitString(StringConstantValue constant) {
     // No `addRoot` since string constants are always inlined.
-    addIdentifier(constant.value.slowToString());
+    addIdentifier(constant.primitiveValue.slowToString());
   }
 
-  visitList(ListConstant constant) {
+  visitList(ListConstantValue constant) {
     // TODO(9476): Incorporate type parameters into name.
     addRoot('List');
     int length = constant.length;
     if (constant.length == 0) {
       add('empty');
     } else if (length >= MAX_FRAGMENTS) {
       failed = true;
     } else {
       for (int i = 0; i < length; i++) {
         _visit(constant.entries[i]);
         if (failed) break;
       }
     }
   }
 
   visitMap(JavaScriptMapConstant constant) {
     // TODO(9476): Incorporate type parameters into name.
     addRoot('Map');
     if (constant.length == 0) {
       add('empty');
     } else {
       // Using some bits from the keys hash tag groups the names Maps with the
       // same structure.
       add(getHashTag(constant.keyList, 2) + getHashTag(constant, 3));
     }
   }
 
-  visitConstructed(ConstructedConstant constant) {
+  visitConstructed(ConstructedConstantValue constant) {
     addRoot(constant.type.element.name);
     for (int i = 0; i < constant.fields.length; i++) {
       _visit(constant.fields[i]);
       if (failed) return;
     }
   }
 
-  visitType(TypeConstant constant) {
+  visitType(TypeConstantValue constant) {
     addRoot('Type');
     DartType type = constant.representedType;
     JavaScriptBackend backend = compiler.backend;
     String name = backend.rti.getTypeRepresentationForTypeConstant(type);
     addIdentifier(name);
   }
 
-  visitInterceptor(InterceptorConstant constant) {
+  visitInterceptor(InterceptorConstantValue constant) {
     addRoot(constant.dispatchedType.element.name);
     add('methods');
   }
 
-  visitDummy(DummyConstant constant) {
+  visitDummy(DummyConstantValue constant) {
     add('dummy_receiver');
   }
 
-  visitDeferred(DeferredConstant constant) {
+  visitDeferred(DeferredConstantValue constant) {
     addRoot('Deferred');
   }
 }
 
 /**
- * Generates canonical hash values for [Constant]s.
+ * Generates canonical hash values for [ConstantValue]s.
  *
  * Unfortunately, [Constant.hashCode] is not stable under minor perturbations,
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
-class ConstantCanonicalHasher implements ConstantVisitor<int> {
+class ConstantCanonicalHasher implements ConstantValueVisitor<int> {
 
   static const _MASK = 0x1fffffff;
   static const _UINT32_LIMIT = 4 * 1024 * 1024 * 1024;
 
 
   final Compiler compiler;
-  final Map<Constant, int> hashes = new Map<Constant, int>();
+  final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
 
   ConstantCanonicalHasher(this.compiler);
 
-  int getHash(Constant constant) => _visit(constant);
+  int getHash(ConstantValue constant) => _visit(constant);
 
-  int _visit(Constant constant) {
+  int _visit(ConstantValue constant) {
     int hash = hashes[constant];
     if (hash == null) {
       hash = _finish(constant.accept(this));
       hashes[constant] = hash;
     }
     return hash;
   }
 
-  int visitNull(NullConstant constant) => 1;
-  int visitTrue(TrueConstant constant) => 2;
-  int visitFalse(FalseConstant constant) => 3;
+  int visitNull(NullConstantValue constant) => 1;
+  int visitTrue(TrueConstantValue constant) => 2;
+  int visitFalse(FalseConstantValue constant) => 3;
 
-  int visitFunction(FunctionConstant constant) {
+  int visitFunction(FunctionConstantValue constant) {
     return _hashString(1, constant.element.name);
   }
 
-  int visitInt(IntConstant constant) => _hashInt(constant.value);
+  int visitInt(IntConstantValue constant) => _hashInt(constant.primitiveValue);
 
-  int visitDouble(DoubleConstant constant) => _hashDouble(constant.value);
-
-  int visitString(StringConstant constant) {
-    return _hashString(2, constant.value.slowToString());
+  int visitDouble(DoubleConstantValue constant) {
+    return _hashDouble(constant.primitiveValue);
   }
 
-  int visitList(ListConstant constant) {
+  int visitString(StringConstantValue constant) {
+    return _hashString(2, constant.primitiveValue.slowToString());
+  }
+
+  int visitList(ListConstantValue constant) {
     return _hashList(constant.length, constant.entries);
   }
 
-  int visitMap(MapConstant constant) {
+  int visitMap(MapConstantValue constant) {
     int hash = _hashList(constant.length, constant.keys);
     return _hashList(hash, constant.values);
   }
 
-  int visitConstructed(ConstructedConstant constant) {
+  int visitConstructed(ConstructedConstantValue constant) {
     int hash = _hashString(3, constant.type.element.name);
     for (int i = 0; i < constant.fields.length; i++) {
       hash = _combine(hash, _visit(constant.fields[i]));
     }
     return hash;
   }
 
-  int visitType(TypeConstant constant) {
+  int visitType(TypeConstantValue constant) {
     DartType type = constant.representedType;
     JavaScriptBackend backend = compiler.backend;
     String name = backend.rti.getTypeRepresentationForTypeConstant(type);
     return _hashString(4, name);
   }
 
-  visitInterceptor(InterceptorConstant constant) {
+  visitInterceptor(InterceptorConstantValue constant) {
     String typeName = constant.dispatchedType.element.name;
     return _hashString(5, typeName);
   }
 
-  visitDummy(DummyConstant constant) {
+  visitDummy(DummyConstantValue constant) {
     compiler.internalError(NO_LOCATION_SPANNABLE,
         'DummyReceiverConstant should never be named and never be subconstant');
   }
 
-  visitDeferred(DeferredConstant constant) {
+  visitDeferred(DeferredConstantValue constant) {
     int hash = constant.prefix.hashCode;
     return _combine(hash, constant.referenced.accept(this));
   }
 
   int _hashString(int hash, String s) {
     int length = s.length;
     hash = _combine(hash, length);
     // Increasing stride is O(log N) on large strings which are unlikely to have
     // many collisions.
     for (int i = 0; i < length; i += 1 + (i >> 2)) {
       hash = _combine(hash, s.codeUnitAt(i));
     }
     return hash;
   }
 
-  int _hashList(int hash, List<Constant> constants) {
-    for (Constant constant in constants) {
+  int _hashList(int hash, List<ConstantValue> constants) {
+    for (ConstantValue constant in constants) {
       hash = _combine(hash, _visit(constant));
     }
     return hash;
   }
 
   static int _hashInt(int value) {
     if (value.abs() < _UINT32_LIMIT) return _MASK & value;
     return _hashDouble(value.toDouble());
   }
 
@@ skipping 92 matching lines @@
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }