Version 1.4.3.

dart/sdk/lib/_internal/compiler/implementation/inferrer/type_graph_nodes.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;
 
 /**
  * Common class for all nodes in the graph. The current nodes are:
  *
  * - Concrete types
@@ skipping 1041 matching lines @@
 
   // The set of [TypeInformation] where values from the traced map could
   // flow in.
   final Setlet<TypeInformation> flowsInto = new Setlet<TypeInformation>();
 
   // Set to false once analysis has succeeded.
   bool bailedOut = true;
   bool analyzed = false;
 
   // Set to false if a statically unknown key flows into this map.
-  bool isDictionary = true;
+  bool _allKeysAreStrings = true;
+
+  bool get inDictionaryMode => !bailedOut && _allKeysAreStrings;
 
   MapTypeInformation(this.initialType, this.keyType, this.valueType) {
     keyType.addUser(this);
     valueType.addUser(this);
     type = initialType;
   }
 
   TypeInformation addEntryAssignment(TypeInformation key,
                                      TypeInformation value,
                                      [bool nonNull = false]) {
     TypeInformation newInfo = null;
-    if (isDictionary && key is StringLiteralTypeInformation) {
+    if (_allKeysAreStrings && key is StringLiteralTypeInformation) {
       String keyString = key.asString();
       typeInfoMap.putIfAbsent(keyString,
           () => newInfo = new ValueInMapTypeInformation(null, nonNull));
       typeInfoMap[keyString].addAssignment(value);
     } else {
-      isDictionary = false;
+      _allKeysAreStrings = false;
       typeInfoMap.clear();
     }
     keyType.addAssignment(key);
     valueType.addAssignment(value);
     if (newInfo != null) newInfo.addUser(this);
 
     return newInfo;
   }
 
-  List<TypeInformation> addMapAssignment(MapTypeInformation map) {
+  List<TypeInformation> addMapAssignment(MapTypeInformation other) {
     List<TypeInformation> newInfos = <TypeInformation>[];
-    if (map.isDictionary) {
-      map.typeInfoMap.forEach((keyString, value) {
+    if (_allKeysAreStrings && other.inDictionaryMode) {
+      other.typeInfoMap.forEach((keyString, value) {
         typeInfoMap.putIfAbsent(keyString, () {
           TypeInformation newInfo = new ValueInMapTypeInformation(null, false);
           newInfos.add(newInfo);
           return newInfo;
         });
         typeInfoMap[keyString].addAssignment(value);
       });
+    } else {
+      _allKeysAreStrings = false;
+      typeInfoMap.clear();
     }
-    keyType.addAssignment(map.keyType);
-    valueType.addAssignment(map.valueType);
+    keyType.addAssignment(other.keyType);
+    valueType.addAssignment(other.valueType);
 
     return newInfos;
   }
 
   markAsInferred() {
     keyType.inferred = valueType.inferred = true;
     typeInfoMap.values.forEach((v) => v.inferred = true);
   }
 
   addAssignment(TypeInformation other) {
     throw "not supported";
   }
 
   accept(TypeInformationVisitor visitor) {
     return visitor.visitMapTypeInformation(this);
   }
 
   TypeMask toTypeMask(TypeGraphInferrerEngine inferrer) {
-    if (isDictionary) {
+    if (inDictionaryMode) {
       Map<String, TypeMask> mappings = new Map<String, TypeMask>();
       for (var key in typeInfoMap.keys) {
         mappings[key] = typeInfoMap[key].type;
       }
       return new DictionaryTypeMask(initialType.forwardTo,
                                     initialType.allocationNode,
                                     initialType.allocationElement,
                                     keyType.type,
                                     valueType.type,
                                     mappings);
     } else {
       return new MapTypeMask(initialType.forwardTo,
                              initialType.allocationNode,
                              initialType.allocationElement,
                              keyType.type,
                              valueType.type);
     }
   }
 
   TypeMask refine(TypeGraphInferrerEngine inferrer) {
-    if (!bailedOut && type.isDictionary != isDictionary) {
+    if (type.isDictionary != inDictionaryMode) {
       return toTypeMask(inferrer);
-    } else if (!bailedOut && type.isDictionary) {
+    } else if (type.isDictionary) {
+      assert(inDictionaryMode);
       DictionaryTypeMask mask = type;
       for (var key in typeInfoMap.keys) {
         TypeInformation value = typeInfoMap[key];
         if (!mask.typeMap.containsKey(key) &&
             !value.type.containsAll(inferrer.compiler) &&
             !value.type.isNullable) {
           return toTypeMask(inferrer);
         }
         if (mask.typeMap[key] != typeInfoMap[key].type) {
           return toTypeMask(inferrer);
@@ skipping 118 matching lines @@
   T visitListTypeInformation(ListTypeInformation info);
   T visitMapTypeInformation(MapTypeInformation info);
   T visitConcreteTypeInformation(ConcreteTypeInformation info);
   T visitStringLiteralTypeInformation(StringLiteralTypeInformation info);
   T visitClosureCallSiteTypeInformation(ClosureCallSiteTypeInformation info);
   T visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info);
   T visitDynamicCallSiteTypeInformation(DynamicCallSiteTypeInformation info);
   T visitElementTypeInformation(ElementTypeInformation info);
   T visitClosureTypeInformation(ClosureTypeInformation info);
 }