Support general expressions as keys in literal maps.

sdk/lib/_internal/compiler/implementation/js_backend/constant_emitter.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 js_backend;
 
 class ConstantEmitter  {
   ConstantReferenceEmitter _referenceEmitter;
   ConstantInitializerEmitter _initializerEmitter;
 
@@ skipping 197 matching lines @@
     return maybeAddTypeArguments(constant.type, value);
   }
 
   String getJsConstructor(ClassElement element) {
     return namer.isolateAccess(element);
   }
 
   jsAst.Expression visitMap(MapConstant constant) {
     jsAst.Expression jsMap() {
       List<jsAst.Property> properties = <jsAst.Property>[];
-      int valueIndex = 0;
       for (int i = 0; i < constant.keys.entries.length; i++) {
         StringConstant key = constant.keys.entries[i];
         if (key.value == MapConstant.PROTO_PROPERTY) continue;
 
         // Keys in literal maps must be emitted in place.
         jsAst.Literal keyExpression = _visit(key);
         jsAst.Expression valueExpression =
-            _reference(constant.values[valueIndex++]);
+            _reference(constant.values[i]);
         properties.add(new jsAst.Property(keyExpression, valueExpression));
       }
-      if (valueIndex != constant.values.length) {
-        compiler.internalError("Bad value count.");
-      }
       return new jsAst.ObjectInitializer(properties);
     }
 
-    void badFieldCountError() {
-      compiler.internalError(
-          "Compiler and ConstantMap disagree on number of fields.");
+    jsAst.Expression jsGeneralMap() {
+      List<jsAst.Expression> data = <jsAst.Expression>[];
+      for (int i = 0; i < constant.keys.entries.length; i++) {
+        jsAst.Expression keyExpression =
+            _reference(constant.keys.entries[i]);
+        jsAst.Expression valueExpression =
+            _reference(constant.values[i]);
+        data.add(keyExpression);
+        data.add(valueExpression);
+      }
+      return new jsAst.ArrayInitializer.from(data);
     }
 
     ClassElement classElement = constant.type.element;
+    SourceString className = classElement.name;
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[];
 
     // 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.implementation.forEachInstanceField(
         (ClassElement enclosing, Element field) {
           if (field.name == MapConstant.LENGTH_NAME) {
             arguments.add(
                 new jsAst.LiteralNumber('${constant.keys.entries.length}'));
           } else if (field.name == MapConstant.JS_OBJECT_NAME) {
             arguments.add(jsMap());
           } else if (field.name == MapConstant.KEYS_NAME) {
             arguments.add(_reference(constant.keys));
           } else if (field.name == MapConstant.PROTO_VALUE) {
             assert(constant.protoValue != null);
             arguments.add(_reference(constant.protoValue));
+          } else if (field.name == MapConstant.JS_DATA_NAME) {
+            arguments.add(jsGeneralMap());
           } else {
-            badFieldCountError();
+            compiler.internalError(
+                "Compiler has unexpected field ${field.name} for "
+                "${className}.");
           }
           emittedArgumentCount++;
         },
         includeSuperAndInjectedMembers: true);
-
-    if ((constant.protoValue == null && emittedArgumentCount != 3) ||
-        (constant.protoValue != null && emittedArgumentCount != 4)) {
-      badFieldCountError();
+    if ((className == MapConstant.DART_STRING_CLASS &&
+         emittedArgumentCount != 3) ||
+        (className == MapConstant.DART_PROTO_CLASS &&
+         emittedArgumentCount != 4) ||
+        (className == MapConstant.DART_GENERAL_CLASS &&
+         emittedArgumentCount != 1)) {
+      compiler.internalError(
+          "Compiler and ${className} disagree on number of fields.");
     }
 
     jsAst.Expression value = new jsAst.New(
         new jsAst.VariableUse(getJsConstructor(classElement)),
         arguments);
     return maybeAddTypeArguments(constant.type, value);
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
@@ skipping 51 matching lines @@
           .toList(growable: false)
           .map((DartType type) => rti.getTypeRepresentation(type, (_){}));
       jsAst.Expression argumentList =
           new jsAst.LiteralString('[${arguments.join(', ')}]');
       return new jsAst.Call(getHelperProperty(backend.getSetRuntimeTypeInfo()),
                             [value, argumentList]);
     }
     return value;
   }
 }