Fix bug where constants were not correctly canonicalized.

lib/compiler/implementation/compile_time_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.
 
 class Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
   bool isFalse() => false;
   bool isInt() => false;
   bool isDouble() => false;
   bool isNum() => false;
   bool isString() => false;
   bool isList() => false;
   bool isMap() => false;
   bool isConstructedObject() => false;
   /** Returns true if the constant is null, a bool, a number or a string. */
   bool isPrimitive() => false;
   /** Returns true if the constant is a list, a map or a constructed object. */
   bool isObject() => false;
 
-  abstract void writeJsCode(StringBuffer buffer, ConstantHandler handler);
+  abstract void _writeJsCode(StringBuffer buffer, ConstantHandler handler);
   /**
     * Unless the constant can be emitted multiple times (as for numbers and
     * strings) adds its canonical name to the buffer.
     */
-  abstract void writeCanonicalizedJsCode(StringBuffer buffer,
-                                         ConstantHandler handler);
+  abstract void _writeCanonicalizedJsCode(StringBuffer buffer,
+                                          ConstantHandler handler);
   abstract List<Constant> getDependencies();
 }
 
 class PrimitiveConstant extends Constant {
   abstract get value();
   const PrimitiveConstant();
   bool isPrimitive() => true;
 
   bool operator ==(var other) {
     if (other is !PrimitiveConstant) return false;
     PrimitiveConstant otherPrimitive = other;
     // We use == instead of === so that DartStrings compare correctly.
     return value == otherPrimitive.value;
   }
 
   String toString() => value.toString();
   // Primitive constants don't have dependencies.
   List<Constant> getDependencies() => const <Constant>[];
   abstract DartString toDartString();
 
-  void writeCanonicalizedJsCode(StringBuffer buffer, ConstantHandler handler) {
-    writeJsCode(buffer, handler);
+  void _writeCanonicalizedJsCode(StringBuffer buffer, ConstantHandler handler) {
+    _writeJsCode(buffer, handler);
   }
 }
 
 class NullConstant extends PrimitiveConstant {
   factory NullConstant() => const NullConstant._internal();
   const NullConstant._internal();
   bool isNull() => true;
   get value() => null;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("(void 0)");
   }
 
   // The magic constant has no meaning. It is just a random value.
   int hashCode() => 785965825;
   DartString toDartString() => const LiteralDartString("null");
 }
 
 class NumConstant extends PrimitiveConstant {
   abstract num get value();
@@ skipping 17 matching lines @@
       case 9: return const IntConstant._internal(9);
       case 10: return const IntConstant._internal(10);
       case -1: return const IntConstant._internal(-1);
       case -2: return const IntConstant._internal(-2);
       default: return new IntConstant._internal(value);
     }
   }
   const IntConstant._internal(this.value);
   bool isInt() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("$value");
   }
 
   // We have to override the equality operator so that ints and doubles are
   // treated as separate constants.
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
     if (other is !IntConstant) return false;
     IntConstant otherInt = other;
@@ skipping 17 matching lines @@
       return const DoubleConstant._internal(0.0);
     } else if (value == 1.0) {
       return const DoubleConstant._internal(1.0);
     } else {
       return new DoubleConstant._internal(value);
     }
   }
   const DoubleConstant._internal(this.value);
   bool isDouble() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     if (value.isNaN()) {
       buffer.add("(0/0)");
     } else if (value == double.INFINITY) {
       buffer.add("(1/0)");
     } else if (value == -double.INFINITY) {
       buffer.add("(-1/0)");
     } else {
       buffer.add("$value");
     }
   }
@@ skipping 30 matching lines @@
   abstract BoolConstant negate();
 }
 
 class TrueConstant extends BoolConstant {
   final bool value = true;
 
   factory TrueConstant() => const TrueConstant._internal();
   const TrueConstant._internal() : super._internal();
   bool isTrue() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("true");
   }
 
   FalseConstant negate() => new FalseConstant();
 
   bool operator ==(var other) => this === other;
   // The magic constant is just a random value. It does not have any
   // significance.
   int hashCode() => 499;
   DartString toDartString() => const LiteralDartString("true");
 }
 
 class FalseConstant extends BoolConstant {
   final bool value = false;
 
   factory FalseConstant() => const FalseConstant._internal();
   const FalseConstant._internal() : super._internal();
   bool isFalse() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("false");
   }
 
   TrueConstant negate() => new TrueConstant();
 
   bool operator ==(var other) => this === other;
   // The magic constant is just a random value. It does not have any
   // significance.
   int hashCode() => 536555975;
   DartString toDartString() => const LiteralDartString("false");
 }
 
 class StringConstant extends PrimitiveConstant {
   final DartString value;
   int _hashCode;
 
   StringConstant(this.value) {
     // TODO(floitsch): cache StringConstants.
     // TODO(floitsch): compute hashcode without calling toString() on the
     // DartString.
     _hashCode = value.slowToString().hashCode();
   }
   bool isString() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("'");
     ConstantHandler.writeEscapedString(value, buffer, (reason) {
       throw new CompilerCancelledException(reason);
     });
     buffer.add("'");
   }
 
   bool operator ==(var other) {
     if (other is !StringConstant) return false;
     StringConstant otherString = other;
     return (_hashCode == otherString._hashCode) && (value == otherString.value);
   }
 
   int hashCode() => _hashCode;
   DartString toDartString() => value;
 }
 
 class ObjectConstant extends Constant {
   final Type type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
   // TODO(1603): The class should be marked as abstract, but the VM doesn't
   // currently allow this.
   abstract int hashCode();
 
-  void writeCanonicalizedJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeCanonicalizedJsCode(StringBuffer buffer, ConstantHandler handler) {
     String name = handler.getNameForConstant(this);
     String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
     buffer.add("$isolatePrototype.$name");
   }
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   int _hashCode;
 
   ListConstant(Type type, this.entries) : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant input in entries) hash ^= input.hashCode();
     _hashCode = hash;
   }
   bool isList() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     // TODO(floitsch): we should not need to go through the compiler to make
     // the list constant.
     String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
     buffer.add("$isolatePrototype.makeConstantList");
     buffer.add("([");
     for (int i = 0; i < entries.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant entry = entries[i];
-      entry.writeCanonicalizedJsCode(buffer, handler);
+      handler.writeConstant(buffer, entry);
     }
     buffer.add("])");
   }
 
   bool operator ==(var other) {
     if (other is !ListConstant) return false;
     ListConstant otherList = other;
     if (hashCode() != otherList.hashCode()) return false;
     // TODO(floitsch): verify that the generic types are the same.
     if (entries.length != otherList.entries.length) return false;
@@ skipping 31 matching lines @@
 
   MapConstant(Type type, this.keys, this.values, this.protoValue)
       : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant value in values) hash ^= value.hashCode();
     _hashCode = hash;
   }
   bool isMap() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
 
     void writeJsMap() {
       buffer.add("{");
       int valueIndex = 0;
       for (int i = 0; i < keys.entries.length; i++) {
         StringConstant key = keys.entries[i];
         if (key.value == const LiteralDartString(PROTO_PROPERTY)) continue;
         
         if (valueIndex != 0) buffer.add(", ");
 
-        key.writeJsCode(buffer, handler);
+        key._writeJsCode(buffer, handler);
         buffer.add(": ");
         Constant value = values[valueIndex++];
-        value.writeCanonicalizedJsCode(buffer, handler);
+        handler.writeConstant(buffer, value);
       }
       buffer.add("}");
       if (valueIndex != values.length) {
         handler.compiler.internalError("Bad value count.");
       }
     }
 
     void badFieldCountError() {
       handler.compiler.internalError(
           "Compiler and ConstantMap disagree on number of fields.");
     }
 
     ClassElement classElement = type.element;
     buffer.add("new ");
     buffer.add(handler.getJsConstructor(classElement));
     buffer.add("(");
     // The arguments of the JavaScript constructor for any given Dart class
     // are in the same order as the members of the class element.
     int emittedArgumentCount = 0;
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosing, Element field) {
       if (emittedArgumentCount != 0) buffer.add(", ");
       if (field.name == LENGTH_NAME) {
         buffer.add(keys.entries.length);
       } else if (field.name == JS_OBJECT_NAME) {
         writeJsMap();
       } else if (field.name == KEYS_NAME) {
-        keys.writeCanonicalizedJsCode(buffer, handler);
+        handler.writeConstant(buffer, keys);
       } else if (field.name == PROTO_VALUE) {
         assert(protoValue !== null);
-        protoValue.writeCanonicalizedJsCode(buffer, handler);
+        handler.writeConstant(buffer, protoValue);
       } else {
         badFieldCountError();
       }
       emittedArgumentCount++;
     });
     if ((protoValue === null && emittedArgumentCount != 3) ||
         (protoValue !== null && emittedArgumentCount != 4)) {
       badFieldCountError(); 
     }
     buffer.add(")");
@@ skipping 29 matching lines @@
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode();
     }
     hash ^= type.element.hashCode();
     _hashCode = hash;
   }
   bool isConstructedObject() => true;
 
-  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
+  void _writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("new ");
     buffer.add(handler.getJsConstructor(type.element));
     buffer.add("(");
     for (int i = 0; i < fields.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant field = fields[i];
-      field.writeCanonicalizedJsCode(buffer, handler);
+      handler.writeConstant(buffer, field);
     }
     buffer.add(")");
   }
 
   bool operator ==(var otherVar) {
     if (otherVar is !ConstructedConstant) return false;
     ConstructedConstant other = otherVar;
     if (hashCode() != other.hashCode()) return false;
     // TODO(floitsch): verify that the (generic) types are the same.
     if (type.element != other.type.element) return false;
@@ skipping 144 matching lines @@
     }
 
     compiledConstants.forEach((Constant key, ignored) => addConstant(key));
     return result;
   }
 
   String getNameForConstant(Constant constant) {
     return compiledConstants[constant];
   }
 
+  /** This function writes the constant in non-canonicalized form. */
   StringBuffer writeJsCode(StringBuffer buffer, Constant value) {
-    value.writeJsCode(buffer, this);
+    value._writeJsCode(buffer, this);
     return buffer;
   }
 
+  StringBuffer writeConstant(StringBuffer buffer, Constant value) {
+    value._writeCanonicalizedJsCode(buffer, this);
+    return buffer;
+  }
+
   StringBuffer writeJsCodeForVariable(StringBuffer buffer,
                                       VariableElement element) {
     if (!initialVariableValues.containsKey(element)) {
       compiler.internalError("No initial value for given element",
                              element: element);
     }
     Constant constant = initialVariableValues[element];
-    if (constant.isObject()) {
-      String name = compiledConstants[constant];
-      buffer.add("${compiler.namer.ISOLATE}.prototype.$name");
-    } else {
-      writeJsCode(buffer, constant);
-    }
+    writeConstant(buffer, constant);
     return buffer;
   }
 
   /**
    * Write the contents of the quoted string to a [StringBuffer] in
    * a form that is valid as JavaScript string literal content.
    * The string is assumed quoted by single quote characters.
    */
   static void writeEscapedString(DartString string,
                                  StringBuffer buffer,
@@ skipping 485 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);          
     });
     return jsNewArguments;
   }
 }