Support general expressions as keys in literal maps.

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 356 matching lines @@
 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__");
 
   /** The dart class implementing constant map literals. */
   static const SourceString DART_CLASS = const SourceString("ConstantMap");
+  static const SourceString DART_STRING_CLASS =
+      const SourceString("ConstantStringMap");
   static const SourceString DART_PROTO_CLASS =
       const SourceString("ConstantProtoMap");
+  static const SourceString DART_GENERAL_CLASS =
+      const SourceString("GeneralConstantMap");
   static const SourceString LENGTH_NAME = const SourceString("length");
   static const SourceString JS_OBJECT_NAME = const SourceString("_jsObject");
   static const SourceString KEYS_NAME = const SourceString("_keys");
   static const SourceString PROTO_VALUE = const SourceString("_protoValue");
+  static const SourceString JS_DATA_NAME = const SourceString("_jsData");
 
   final ListConstant keys;
   final List<Constant> values;
   final Constant protoValue;
   final int hashCode;
+  final bool hasNonStringKey;
 
-  MapConstant(DartType type, this.keys, List<Constant> values, this.protoValue)
+  MapConstant(DartType type, this.keys, List<Constant> values, this.protoValue,
+              this.hasNonStringKey)
       : this.values = values,
         this.hashCode = computeHash(type, values),
         super(type);
   bool isMap() => true;
 
   static int computeHash(DartType type, List<Constant> values) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant value in values) {
       hash ^= value.hashCode;
     }
     hash ^= type.hashCode;
     return hash;
   }
 
   bool operator ==(var other) {
     if (other is !MapConstant) return false;
     MapConstant otherMap = other;
     if (hashCode != otherMap.hashCode) return false;
     if (type != other.type) return false;
     if (keys != otherMap.keys) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != otherMap.values[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() {
-    List<Constant> result = <Constant>[keys];
+    List<Constant> result = <Constant>[];
+    if (hasNonStringKey) {

[ngeoffray, 2013/09/13 07:30:15]

This seems fishy. Why can't you just add keys? Is that an optimization?

[Johnni Winther, 2013/09/18 12:37:21]

If I just add [keys], we will create an unused constant for the list of key.
Added a comment.

+      result.addAll(keys.entries);
+    } else {
+      result.add(keys);
+    }
     result.addAll(values);
     return result;
   }
 
   int get length => keys.length;
 
   accept(ConstantVisitor visitor) => visitor.visitMap(this);
 }
 
 class InterceptorConstant extends Constant {
@@ skipping 61 matching lines @@
     // 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;
   }
 }