Add a new node in the inferrer to materialize literal maps.

sdk/lib/_internal/compiler/implementation/inferrer/container_tracer.dart

 // Copyright (c) 2013, 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 type_graph_inferrer;
 
 /**
  * A set of selector names that [List] implements, that we know do not
  * change the element type of the list, or let the list escape to code
  * that might change the element type.
@@ skipping 152 matching lines @@
     '[]=',
 
     // From JSArray.
     'checkMutable',
     'checkGrowable',
   ]);
 
 bool _VERBOSE = false;
 
 class ContainerTracerVisitor implements TypeInformationVisitor {
-  final ContainerTypeInformation container;
+  final ListTypeInformation container;
   final TypeGraphInferrerEngine inferrer;
   final Compiler compiler;
 
 
   // Work list that gets populated with [TypeInformation] that could
   // contain the container.
   final List<TypeInformation> workList = <TypeInformation>[];
 
   // Work list of containers to analyze after analyzing the users of a
   // [TypeInformation] that may be [container]. We know [container]
   // has been stored in these containers and we must check how
   // [container] escapes from these containers.
-  final List<ContainerTypeInformation> containersToAnalyze =
-      <ContainerTypeInformation>[];
+  final List<ListTypeInformation> containersToAnalyze =
+      <ListTypeInformation>[];
 
   // The current [TypeInformation] in the analysis.
   TypeInformation currentUser;
 
   // The list of found assignments to the container.
   final List<TypeInformation> assignments = <TypeInformation>[];
 
   bool callsGrowableMethod = false;
   bool continueAnalyzing = true;
   
@@ skipping 54 matching lines @@
 
   visitPhiElementTypeInformation(PhiElementTypeInformation info) {
     addNewEscapeInformation(info);
   }
 
   visitElementInContainerTypeInformation(
       ElementInContainerTypeInformation info) {
     addNewEscapeInformation(info);
   }
 
-  visitContainerTypeInformation(ContainerTypeInformation info) {
+  visitListTypeInformation(ListTypeInformation info) {
     containersToAnalyze.add(info);
   }
 
+  visitMapTypeInformation(MapTypeInformation info) {
+    bailout('Stored in a map');
+  }
+
   visitConcreteTypeInformation(ConcreteTypeInformation info) {}
 
   visitClosureCallSiteTypeInformation(ClosureCallSiteTypeInformation info) {
     bailout('Passed to a closure');
   }
 
   visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info) {
     Element called = info.calledElement;
     if (called.isForeign(compiler) && called.name == 'JS') {
       bailout('Used in JS ${info.call}');
     }
     if (inferrer.types.getInferredTypeOf(called) == currentUser) {
       addNewEscapeInformation(info);
     }
   }
 
-  void analyzeStoredIntoContainer(ContainerTypeInformation container) {
+  void analyzeStoredIntoContainer(ListTypeInformation container) {
     inferrer.analyzeContainer(container);
     if (container.bailedOut) {
       bailout('Stored in a container that bailed out');
     } else {
       container.flowsInto.forEach((flow) {
         flow.users.forEach((user) {
           if (user is !DynamicCallSiteTypeInformation) return;
           if (user.receiver != flow) return;
           if (returnsElementTypeSet.contains(user.selector)) {
             addNewEscapeInformation(user);
@@ skipping 48 matching lines @@
         callsGrowableMethod = true;
         assignments.add(inferrer.types.nullType);
       }
     } else if (selector.isCall()
                && !info.targets.every((element) => element.isFunction())) {
       bailout('Passed to a closure');
       return;
     } else if (isAddedToContainer(info)) {
       ContainerTypeMask mask = info.receiver.type;
       if (mask.allocationNode != null) {
-        ContainerTypeInformation container =
-            inferrer.types.allocatedContainers[mask.allocationNode];
+        ListTypeInformation container =
+            inferrer.types.allocatedLists[mask.allocationNode];
         containersToAnalyze.add(container);
       } else {
         // The [ContainerTypeMask] is a union of two containers, and
         // we lose track of where these containers have been allocated
         // at this point.
         bailout('Stored in too many containers');
       }
     }
 
     if (info.targets
@@ skipping 28 matching lines @@
       bailout('Escape in reflection');
     }
     if (isParameterOfListAddingMethod(info.element)) {
       // These elements are being handled in
       // [visitDynamicCallSiteTypeInformation].
       return;
     }
     addNewEscapeInformation(info);
   }
 }