Move compile-time constant registrations to the backend.

sdk/lib/_internal/compiler/implementation/constants.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 dart2js;
 
 abstract class ConstantVisitor<R> {
   R visitFunction(FunctionConstant constant);
   R visitNull(NullConstant constant);
   R visitInt(IntConstant constant);
@@ skipping 27 matching lines @@
   bool isPrimitive() => false;
   /** Returns true if the constant is a list, a map or a constructed object. */
   bool isObject() => false;
   bool isType() => false;
   bool isSentinel() => false;
   bool isInterceptor() => false;
 
   bool isNaN() => false;
   bool isMinusZero() => false;
 
+  // TODO(johnniwinther): Replace with a 'type' getter.
   DartType computeType(Compiler compiler);
 
   List<Constant> getDependencies();
 
   accept(ConstantVisitor visitor);
 }
 
 class FunctionConstant extends Constant {
   Element element;
 
@@ skipping 230 matching lines @@
   bool operator ==(var other) {
     if (other is !StringConstant) return false;
     StringConstant otherString = other;
     return (hashCode == otherString.hashCode) && (value == otherString.value);
   }
 
   DartString toDartString() => value;
   int get length => value.length;
 
   accept(ConstantVisitor visitor) => visitor.visitString(this);
+
+  String toString() {
+    return 'StringConstant(${Error.safeToString(value.slowToString())})';
+  }
 }
 
 abstract class ObjectConstant extends Constant {
   final DartType type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
   DartType computeType(Compiler compiler) => type;
 }
 
 class TypeConstant extends ObjectConstant {
   /// The user type that this constant represents.
   final DartType representedType;
 
   TypeConstant(this.representedType, type) : super(type);
 
   bool isType() => true;
 
   bool operator ==(other) {
     return other is TypeConstant && representedType == other.representedType;
   }
 
   int get hashCode => representedType.hashCode * 13;
 
   List<Constant> getDependencies() => const <Constant>[];
 
   accept(ConstantVisitor visitor) => visitor.visitType(this);
+
+  String toString() => 'TypeConstant(${Error.safeToString(representedType)})';
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   final int hashCode;
 
   ListConstant(DartType type, List<Constant> entries)
       : this.entries = entries,
         hashCode = _computeHash(type, entries),
         super(type);
@@ skipping 19 matching lines @@
       if (entries[i] != otherList.entries[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() => entries;
 
   int get length => entries.length;
 
   accept(ConstantVisitor visitor) => visitor.visitList(this);
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('ListConstant([');
+    for (int i = 0 ; i < entries.length ; i++) {
+      if (i > 0) sb.write(',');
+      sb.write(Error.safeToString(entries[i]));
+    }
+    sb.write('])');
+    return sb.toString();
+  }
 }
 
 class MapConstant extends ObjectConstant {
   /**
    * The [PROTO_PROPERTY] must not be used as normal property in any JavaScript
    * object. It would change the prototype chain.
    */
   static const LiteralDartString PROTO_PROPERTY =
       const LiteralDartString("__proto__");
 
@@ skipping 55 matching lines @@
       // for the keys.
       result.addAll(keys.entries);
     }
     result.addAll(values);
     return result;
   }
 
   int get length => keys.length;
 
   accept(ConstantVisitor visitor) => visitor.visitMap(this);
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('MapConstant({');
+    for (int i = 0 ; i < keys.entries.length ; i++) {
+      if (i > 0) sb.write(',');
+      sb.write(Error.safeToString(keys.entries[i]));
+      sb.write(':');
+      sb.write(Error.safeToString(values[i]));
+    }
+    sb.write('})');
+    return sb.toString();
+  }
 }
 
 class InterceptorConstant extends Constant {
   /// The type for which this interceptor holds the methods.  The constant
   /// is a dispatch table for this type.
   final DartType dispatchedType;
 
   InterceptorConstant(this.dispatchedType);
 
   bool isInterceptor() => true;
 
   bool operator ==(other) {
     return other is InterceptorConstant
         && dispatchedType == other.dispatchedType;
   }
 
   int get hashCode => dispatchedType.hashCode * 43;
 
   List<Constant> getDependencies() => const <Constant>[];
 
   accept(ConstantVisitor visitor) => visitor.visitInterceptor(this);
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
+
+  String toString() {
+    return 'InterceptorConstant(${Error.safeToString(dispatchedType)})';
+  }
 }
 
 class ConstructedConstant extends ObjectConstant {
   final List<Constant> fields;
   final int hashCode;
 
   ConstructedConstant(DartType type, List<Constant> fields)
     : this.fields = fields,
       hashCode = computeHash(type, fields),
       super(type) {
@@ skipping 30 matching lines @@
   Map<Element, Constant> get fieldElements {
     // TODO(ahe): Refactor constant system to store this information directly.
     ClassElement classElement = type.element;
     int count = 0;
     Map<Element, Constant> result = new Map<Element, Constant>();
     classElement.implementation.forEachInstanceField((holder, field) {
       result[field] = fields[count++];
     }, includeSuperAndInjectedMembers: true);
     return result;
   }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('ConstructedConstant(');
+    sb.write(type);
+    sb.write('(');
+    int i = 0;
+    fieldElements.forEach((Element field, Constant value) {
+      if (i > 0) sb.write(',');
+      sb.write(Error.safeToString(field.name.slowToString()));
+      sb.write('=');
+      sb.write(Error.safeToString(value));
+      i++;
+    });
+    sb.write('))');
+    return sb.toString();
+  }
 }