Revert "Construct literal maps using factory constructor."

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 5021 matching lines @@
           joinBlock);
     }
     handler.close();
   }
 
   visitLiteralMap(ast.LiteralMap node) {
     if (node.isConst()) {
       stack.add(addConstant(node));
       return;
     }
-    List<HInstruction> listInputs = <HInstruction>[];
+    List<HInstruction> inputs = <HInstruction>[];
     for (Link<ast.Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
-      listInputs.add(pop());
-      listInputs.add(pop());
+      inputs.add(pop());
+      inputs.add(pop());
     }
-
-    Element constructor;
-    List<HInstruction> inputs = <HInstruction>[];
-
-    if (listInputs.isEmpty) {
-      constructor = backend.mapLiteralConstructorEmpty;
-    } else {
-      constructor = backend.mapLiteralConstructor;
-      HLiteralList keyValuePairs = buildLiteralList(listInputs);
-      add(keyValuePairs);
-      inputs.add(keyValuePairs);
-    }
-
-    assert(constructor.isFactoryConstructor());
-
-    FunctionElement functionElement = constructor;
-    constructor = functionElement.redirectionTarget;
-
-    InterfaceType type = elements.getType(node);
-    InterfaceType expectedType = functionElement.computeTargetType(type);
-
-    if (constructor.isFactoryConstructor()) {
-      compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
-    }
-
-    ClassElement cls = constructor.getEnclosingClass();
-
-    if (backend.classNeedsRti(cls)) {
-      Link<DartType> typeVariable = cls.typeVariables;
-      expectedType.typeArguments.forEach((DartType argument) {
-            inputs.add(analyzeTypeArgument(argument));
-            typeVariable = typeVariable.tail;
-          });
-      assert(typeVariable.isEmpty);
-    }
-
-    TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
-        constructor, compiler);
-    addInlinedInstantiation(expectedType);
-    pushInvokeStatic(node, constructor, inputs, returnTypeMask);
-    removeInlinedInstantiation(expectedType);
+    HLiteralList keyValuePairs = buildLiteralList(inputs);
+    add(keyValuePairs);
+    TypeMask mapType = new TypeMask.nonNullSubtype(backend.mapLiteralClass);
+    pushInvokeStatic(node, backend.getMapMaker(), [keyValuePairs], mapType);
+    stack.add(setRtiIfNeeded(pop(), node));
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(ast.NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 1151 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }