Construct literal maps using factory constructor.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 84 matching lines @@
   Element jsArrayAdd;
   Element jsStringSplit;
   Element jsStringToString;
   Element jsStringOperatorAdd;
   Element objectEquals;
 
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
   ClassElement typeVariableClass;
+  Element mapLiteralConstructor;
+  Element mapLiteralConstructorEmpty;
 
   ClassElement noSideEffectsClass;
   ClassElement noThrowsClass;
   ClassElement noInlineClass;
   ClassElement irRepresentationClass;
 
   Element getInterceptorMethod;
   Element interceptedNames;
 
   /**
@@ skipping 606 matching lines @@
       } else if (cls == compiler.functionClass) {
         enqueueClass(enqueuer, compiler.closureClass, elements);
       } else if (cls == compiler.mapClass) {
         // The backend will use a literal list to initialize the entries
         // of the map.
         enqueueClass(enqueuer, compiler.listClass, elements);
         enqueueClass(enqueuer, mapLiteralClass, elements);
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(mapLiteralClass, cls);
-        enqueueInResolution(getMapMaker(), elements);
       } else if (cls == compiler.boundClosureClass) {
         // TODO(ngeoffray): Move the bound closure class in the
         // backend.
         enqueueClass(enqueuer, compiler.boundClosureClass, elements);
       } else if (Elements.isNativeOrExtendsNative(cls)) {
         enqueue(enqueuer, getNativeInterceptorMethod, elements);
         enqueueClass(enqueuer, jsInterceptorClass, compiler.globalDependencies);
         enqueueClass(enqueuer, jsPlainJavaScriptObjectClass, elements);
+      } else if (cls == mapLiteralClass) {
+        // For map literals, the dependency between the implementation class
+        // and [Map] is not visible, so we have to add it manually.
+        Element getFactory(String name, int arity) {
+          return mapLiteralClass.patch.lookupConstructor(
+            new Selector.callConstructor(
+                name, mapLiteralClass.getLibrary(), arity),
+            (element) {
+              compiler.internalError(mapLiteralClass,
+                  "Map literal class $mapLiteralClass missing "
+                  "'$name' constructor"
+                  "  ${mapLiteralClass.constructors}");
+            });
+        }
+        mapLiteralConstructor = getFactory('_literal', 1);
+        mapLiteralConstructorEmpty = getFactory('_empty', 0);
+        enqueueInResolution(mapLiteralConstructor, elements);
+        enqueueInResolution(mapLiteralConstructorEmpty, elements);
       }
     }
     if (cls == compiler.closureClass) {
       enqueue(enqueuer,
               compiler.findHelper('closureFromTearOff'),
               elements);
     }
     ClassElement result = null;
     if (cls == compiler.stringClass || cls == jsStringClass) {
       addInterceptors(jsStringClass, enqueuer, elements);
@@ skipping 691 matching lines @@
   }
 
   Element getClosureConverter() {
     return compiler.findHelper('convertDartClosureToJS');
   }
 
   Element getTraceFromException() {
     return compiler.findHelper('getTraceFromException');
   }
 
-  Element getMapMaker() {
-    return compiler.findHelper('makeLiteralMap');
-  }
-
   Element getSetRuntimeTypeInfo() {
     return compiler.findHelper('setRuntimeTypeInfo');
   }
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper('getRuntimeTypeInfo');
   }
 
   Element getGetTypeArgumentByIndex() {
     return compiler.findHelper('getTypeArgumentByIndex');
@@ skipping 414 matching lines @@
   }
 }
 
 /// Records that [constant] is used by [user.element].
 class Dependency {
   final Constant constant;
   final TreeElements user;
 
   const Dependency(this.constant, this.user);
 }
-