Allow use of [keys] from a map by using different bailout strategy.

sdk/lib/_internal/compiler/implementation/inferrer/node_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 selectors we know do not escape the elements inside the
 // list.
 Set<String> doesNotEscapeListSet = new Set<String>.from(
   const <String>[
@@ skipping 42 matching lines @@
     'hashCode',
     'toString',
     'noSuchMethod',
     'runtimeType',
     // from Map.
     'isEmpty',
     'isNotEmpty',
     'length',
     'clear',
     'containsKey',
-    'containsValue'
+    'containsValue',
+    // [keys] only allows key values to escape, which we do not track.
+    'keys'
   ]);
 
 abstract class TracerVisitor implements TypeInformationVisitor {
   final TypeInformation tracedType;
   final TypeGraphInferrerEngine inferrer;
   final Compiler compiler;
 
   static const int MAX_ANALYSIS_COUNT = 16;
   final Setlet<Element> analyzedElements = new Setlet<Element>();
 
@@ skipping 132 matching lines @@
           if (user.selector.isIndex()) {
             addNewEscapeInformation(user);
           } else if (!doesNotEscapeMapSet.contains(user.selector.name)) {
             bailout('Escape from a map via [${user.selector.name}]');
           }
         });
       });
     }
   }
 
+  /*
+   * Checks whether this is a call to a list adding method. The definition
+   * of what list adding means has to stay in sync with
+   * [isParameterOfListAddingMethod].
+   */
   bool isAddedToContainer(DynamicCallSiteTypeInformation info) {
     if (info.arguments == null) return false;
     var receiverType = info.receiver.type;
     if (!receiverType.isContainer) return false;
     String selectorName = info.selector.name;
     List<TypeInformation> arguments = info.arguments.positional;
     return (selectorName == '[]=' && currentUser == arguments[1])
         || (selectorName == 'insert' && currentUser == arguments[0])
         || (selectorName == 'add' && currentUser == arguments[0]);
   }
 
-  bool isValueAddedToMap(DynamicCallSiteTypeInformation info) {
+  bool isIndexSetOnMap(DynamicCallSiteTypeInformation info) {
     if (info.arguments == null) return false;
     var receiverType = info.receiver.type;
     if (!receiverType.isMap) return false;
     String selectorName = info.selector.name;
     List<TypeInformation> arguments = info.arguments.positional;
-    return selectorName == '[]=' && currentUser == arguments[1];
+    return selectorName == '[]=';
+  }
+
+  /* Checks whether this is a call to a map adding method for values. The

[karlklose, 2014/03/31 14:39:27]

Line break after '/*'. Consider using '///' instead.

[herhut, 2014/04/02 13:25:53]

Done.

+   * definition of map adding method has to stay in sync with
+   * [isParameterOfMapAddingMethod].
+   */
+  bool isValueAddedToMap(DynamicCallSiteTypeInformation info) {
+     return isIndexSetOnMap(info) &&
+         currentUser == info.arguments.positional[1];
+  }
+
+  /* Checks whether this is a call to a map adding method for keys. The
+   * definition of map adding method has to stay in sync with
+   * [isParameterOfMapAddingMethod].
+   */
+  bool isKeyAddedToMap(DynamicCallSiteTypeInformation info) {
+    return isIndexSetOnMap(info) &&
+        currentUser == info.arguments.positional[0];
   }
 
   void visitDynamicCallSiteTypeInformation(
       DynamicCallSiteTypeInformation info) {
     if (isAddedToContainer(info)) {
       ContainerTypeMask mask = info.receiver.type;
 
       if (mask.allocationNode != null) {
         ListTypeInformation list =
             inferrer.types.allocatedLists[mask.allocationNode];
         listsToAnalyze.add(list);
       } 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');
       }
     } else if (isValueAddedToMap(info)) {
       MapTypeMask mask = info.receiver.type;
       if (mask.allocationNode != null) {
         MapTypeInformation map =
             inferrer.types.allocatedMaps[mask.allocationNode];
         mapsToAnalyze.add(map);
       } else {
         // The [MapTypeMask] is a union. See comment for
         // [ContainerTypeMask] above.
         bailout('Stored in too many maps');
       }
+    } else if (isKeyAddedToMap(info)) {
+      // We do not track the use of keys from a map, so we have to bail.
+      bailout('Used as key in Map');
     }
 
     Iterable<Element> inferredTargetTypes = info.targets.map((element) {
       return inferrer.types.getInferredTypeOf(element);
     });
     if (inferredTargetTypes.any((user) => user == currentUser)) {
       addNewEscapeInformation(info);
     }
   }
 
+  /*
+   * Check whether element is the parameter of a list adding method.
+   * The definition of what a list adding method is has to stay in sync with
+   * [isAddedToContainer].
+   */
   bool isParameterOfListAddingMethod(Element element) {
     if (!element.isParameter()) return false;
     if (element.getEnclosingClass() != compiler.backend.listImplementation) {
       return false;
     }
     Element method = element.enclosingElement;
     return (method.name == '[]=')
         || (method.name == 'add')
         || (method.name == 'insert');
   }
 
+  /*
+   * Check whether element is the parameter of a list adding method.
+   * The definition of what a list adding method is has to stay in sync with
+   * [isValueAddedToMap] and [isKeyAddedToMap].
+   */
+  bool isParameterOfMapAddingMethod(Element element) {
+    if (!element.isParameter()) return false;
+    if (element.getEnclosingClass() != compiler.backend.mapImplementation) {
+      return false;
+    }
+    Element method = element.enclosingElement;
+    return (method.name == '[]=');
+  }
+
   bool isClosure(Element element) {
     if (!element.isFunction()) return false;
     Element outermost = element.getOutermostEnclosingMemberOrTopLevel();
     return outermost.declaration != element.declaration;
   }
 
   void visitElementTypeInformation(ElementTypeInformation info) {
     Element element = info.element;
     if (element.isParameter()
         && inferrer.isNativeElement(element.enclosingElement)) {
       bailout('Passed to a native method');
     }
     if (info.isClosurized()) {
       bailout('Returned from a closurized method');
     }
     if (isClosure(info.element)) {
       bailout('Returned from a closure');
     }
     if (compiler.backend.isNeededForReflection(info.element)) {
       bailout('Escape in reflection');
     }
-    if (isParameterOfListAddingMethod(info.element)) {
+    if (isParameterOfListAddingMethod(info.element) ||
+        isParameterOfMapAddingMethod(info.element)) {
       // These elements are being handled in
       // [visitDynamicCallSiteTypeInformation].
       return;
     }
     addNewEscapeInformation(info);
   }
 }