Implement constant maps.

frog/leg/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 a list, a map or a constructed object. */
   bool isObject() => false;
 
   abstract void writeJsCode(StringBuffer buffer, ConstantHandler handler);
+
+  /**
+   * Recursively adds the constants dependencies unless the dependency is
+   * already in the [seenConstants] list. Does not add itself to the [list].

[ngeoffray, 2012/03/10 18:33:55]

[seenConstants] list -> [seenConstants] set.

[floitsch, 2012/03/10 19:58:54]

has been removed.

+   *
+   * The dependent constants must always be added before the user of the
+   * constant.
+   *
+   * Any constant that is added to the list must also be added to the set.
+   */
+  // TODO(floitsch): this should take an ordered set.
+  abstract void addDependencies(List<Constant> list,

[ngeoffray, 2012/03/10 18:33:55]

Maybe rename list to orderedList. 'list' is too generic here and a better name
would explain better what this method is doing.

[floitsch, 2012/03/10 19:58:54]

has been removed.

+                                Set<Constant> seenConstants);
 }
 
 class PrimitiveConstant extends Constant {
   abstract get value();
   const PrimitiveConstant();
 
   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();
+  void addDependencies(List<Constant> list, Set<Constant> seenConstants) {
+    // Primitive constants don't have dependencies.
+  }
   abstract DartString toDartString();
 }
 
 class NullConstant extends PrimitiveConstant {
   factory NullConstant() => const NullConstant._internal();
   const NullConstant._internal();
   bool isNull() => true;
   get value() => null;
 
   void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
@@ skipping 184 matching lines @@
 
   int hashCode() => _hashCode;
   DartString toDartString() => value;
 }
 
 class ObjectConstant extends Constant {
   final Type type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
+
+  void addDependency(Constant constant,

[ngeoffray, 2012/03/10 18:33:55]

Instead of putting addDependeny on a Constant class, I suggest creating an
abstraction for the dependencies. It would encapsulate the list and and the set
and contain this method.

Also, the addDependencies could be changed to a getDependecies method that
returns a list. The suggested abstraction would then use this list to update
itself.

[floitsch, 2012/03/10 19:58:54]

replaced with getDependencies().

+                     List<Constant> list,
+                     Set<Constant> seenConstants) {
+    if (!seenConstants.contains(constant)) {
+      constant.addDependencies(list, seenConstants);
+      list.add(constant);
+      seenConstants.add(constant);
+    }
+  }
 }
 
 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();
@@ skipping 17 matching lines @@
         entry.writeJsCode(buffer, handler);
       }
     }
     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 types are the same.
+    // TODO(floitsch): verify that the generic types are the same.
     if (entries.length != otherList.entries.length) return false;
     for (int i = 0; i < entries.length; i++) {
       if (entries[i] != otherList.entries[i]) return false;
     }
     return true;
   }
 
   int hashCode() => _hashCode;
+
+  void addDependencies(List<Constant> list, Set<Constant> seenConstants) {
+    for (Constant constant in entries) {
+      addDependency(constant, list, seenConstants);
+    }
+  }
+}
+
+class MapConstant extends ObjectConstant {
+  /** The dart class implementing constant map literals. */
+  static final SourceString DART_CLASS = const SourceString("ConstantMap");
+  static final SourceString LENGTH_NAME = const SourceString("length");
+  static final SourceString JS_OBJECT_NAME = const SourceString("_jsObject");
+  static final SourceString KEYS_NAME = const SourceString("_keys");
+
+  final ListConstant keys;
+  final List<Constant> values;
+  int _hashCode;
+
+  MapConstant(Type type, this.keys, this.values) : 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) {
+    String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
+
+    void writeJsMap() {
+      buffer.add("{");
+      for (int i = 0; i < keys.entries.length; i++) {
+        if (i != 0) buffer.add(", ");
+
+        StringConstant key = keys.entries[i];
+        key.writeJsCode(buffer, handler);
+        buffer.add(": ");
+        Constant value = values[i];
+        // TODO(floitsch): share this code with the ListConstant and
+        // ConstructedConstant.
+        if (value.isObject()) {
+          String name = handler.getNameForConstant(value);
+          buffer.add("$isolatePrototype.$name");
+        } else {
+          value.writeJsCode(buffer, handler);
+        }      
+      }
+      buffer.add("}");      
+    }
+
+    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;
+    for (Element element in classElement.members) {
+      if (element.name == LENGTH_NAME) {
+        buffer.add(keys.entries.length);
+      } else if (element.name == JS_OBJECT_NAME) {
+        writeJsMap();
+      } else if (element.name == KEYS_NAME) {
+        // TODO(floitsch): share this code with the ListConstant and
+        // ConstructedConstant.
+        String name = handler.getNameForConstant(keys);
+        buffer.add("$isolatePrototype.$name");
+      } else {
+        // Skip methods.
+        if (element.kind == ElementKind.FIELD) badFieldCountError();
+        continue;
+      }
+      emittedArgumentCount++;
+      if (emittedArgumentCount == 3) {
+        break;  // All arguments have been emitted.
+      } else {
+        buffer.add(", ");
+      }
+    }
+    if (emittedArgumentCount != 3) badFieldCountError();
+    buffer.add(")");
+  }
+
+  bool operator ==(var other) {
+    if (other is !MapConstant) return false;
+    MapConstant otherMap = other;
+    if (hashCode() != otherMap.hashCode()) return false;
+    // TODO(floitsch): verify that the generic types are the same.
+    if (keys != otherMap.keys) return false;
+    for (int i = 0; i < values.length; i++) {
+      if (values[i] != otherMap.values[i]) return false;
+    }
+    return true;
+  }
+
+  int hashCode() => _hashCode;
+
+  void addDependencies(List<Constant> list, Set<Constant> seenConstants) {
+    addDependency(keys, list, seenConstants);
+    for (Constant constant in values) {
+      addDependency(constant, list, seenConstants);
+    }
+  }
 }
 
 class ConstructedConstant extends ObjectConstant {
   final List<Constant> fields;
   int _hashCode;
 
   ConstructedConstant(Type type, this.fields) : super(type) {
     assert(type !== null);
     // 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) {
     buffer.add("new ");
     buffer.add(handler.getJsConstructor(type.element));
     buffer.add("(");
     String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
     for (int i = 0; i < fields.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant field = fields[i];
       // TODO(floitsch): share this code with the ListConstant.
       if (field.isObject()) {
-        String name = handler.getNameForConstant(entry);
+        String name = handler.getNameForConstant(field);
         buffer.add("$isolatePrototype.$name");
       } else {
         field.writeJsCode(buffer, handler);
       }
     }
     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;
     if (fields.length != other.fields.length) return false;
     for (int i = 0; i < fields.length; i++) {
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   int hashCode() => _hashCode;
+
+  void addDependencies(List<Constant> list, Set<Constant> seenConstants) {
+    for (Constant constant in fields) {
+      addDependency(constant, list, seenConstants);
+    }
+  }
 }
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
   // Contains the initial value of fields. Must contain all static and global
   // initializations of used fields. May contain caches for instance fields.
@@ skipping 111 matching lines @@
    */
   List<VariableElement> getStaticFinalFieldsForEmission() {
     return initialVariableValues.getKeys().filter((element) {
       return element.kind == ElementKind.FIELD
           && !element.isInstanceMember()
           && element.modifiers.isFinal();
     });
   }
 
   List<Constant> getConstantsForEmission() {
-    return compiledConstants.getKeys();
+    // TODO(floitsch): Improve the creation of the dependencies.
+    Set<Constant> seenConstants = new Set<Constant>();
+    List<Constant> result = new List<Constant>();
+    compiledConstants.forEach((Constant key, ignored) {
+      if (seenConstants.contains(key)) return;
+      key.addDependencies(result, seenConstants);
+      assert(!seenConstants.contains(key));
+      seenConstants.add(key);
+      result.add(key);
+    });
+    return result;
   }
 
   String getNameForConstant(Constant constant) {
     return compiledConstants[constant];
   }
 
   StringBuffer writeJsCode(StringBuffer buffer, Constant value) {
     value.writeJsCode(buffer, this);
     return buffer;
   }
@@ skipping 105 matching lines @@
   Constant visitLiteralDouble(LiteralDouble node) {
     return new DoubleConstant(node.value);
   }
 
   Constant visitLiteralInt(LiteralInt node) {
     return new IntConstant(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst()) error(node);
-    List arguments = [];
+    List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
       arguments.add(evaluate(link.head));
     }
     // TODO(floitsch): get type from somewhere.
     Type type = null;
     return constantHandler.compileListLiteral(node, type, arguments);
   }
 
   Constant visitLiteralMap(LiteralMap node) {
-    compiler.unimplemented("CompileTimeConstantEvaluator map", node: node);
+    // TODO(floitsch): check for isConst, once the parser adds it into the node.
+    // if (!node.isConst()) error(node);
+    List<StringConstant> keys = <StringConstant>[];
+    List<Constant> values = <Constant>[];
+    bool hasProtoKey = false;
+    for (Link<Node> link = node.entries.nodes;
+         !link.isEmpty();
+         link = link.tail) {
+      LiteralMapEntry entry = link.head;
+      Constant key = evaluate(entry.key);
+      if (!key.isString() ||
+          (entry.key.asLiteralString() === null &&
+           entry.key.asStringInterpolation() === null)) {

[ngeoffray, 2012/03/10 18:33:55]

AFAIK, string interpolation for constants is still not in the spec.

[floitsch, 2012/03/10 19:58:54]

This is in preparation for future changes.
Since string-interpolation is not a compile-time constant the key will return as
'null'.
In some sense the check is currently dead code. If you want I can remove it for
now.

[ngeoffray, 2012/03/10 22:28:03]

I'd prefer that you remove it. I have a strong aversion against dead code.

[floitsch, 2012/03/10 22:58:22]

Done.

+        MessageKind kind = MessageKind.KEY_NOT_A_STRING_LITERAL;
+        // TODO(floitsch): is resolution error the correct error?
+        compiler.reportError(entry.key, new ResolutionError(kind, const []));
+      }
+      // TODO(floitsch): make this faster.
+      StringConstant keyConstant = key;
+      if (keyConstant.value == new LiteralDartString("__proto__")) {
+        hasProtoKey = true;
+      }
+      keys.add(key);
+      values.add(evaluate(entry.value));
+    }
+    if (hasProtoKey) {
+      compiler.unimplemented("visitLiteralMap with __proto__ key",
+                             node: node);
+    }
+    // TODO(floitsch): this should be a List<String> type.
+    Type keysType = null;
+    ListConstant keysList = new ListConstant(keysType, keys);
+    constantHandler.registerCompileTimeConstant(keysList);
+    ClassElement classElement =
+        compiler.jsHelperLibrary.find(MapConstant.DART_CLASS);
+    classElement.ensureResolved(compiler);
+    // TODO(floitsch): copy over the generic type.
+    Type type = new SimpleType(classElement.name, classElement);
+    compiler.registerInstantiatedClass(classElement);
+    Constant constant = new MapConstant(type, keysList, values);
+    constantHandler.registerCompileTimeConstant(constant);
+    return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return new NullConstant();
   }
 
   Constant visitLiteralString(LiteralString node) {
     return new StringConstant(node.dartString);
   }
 
@@ skipping 144 matching lines @@
                                                      arguments);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }