dart2js: use Es6 maps when available.

sdk/lib/_internal/compiler/js_lib/collection_patch.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.
 
 // Patch file for dart:collection classes.
 import 'dart:_foreign_helper' show JS;
 import 'dart:_js_helper' show
-    fillLiteralMap, InternalMap, NoInline, NoThrows, patch, JsLinkedHashMap,
+    fillLiteralMap, InternalMap, NoInline, NoThrows, patch,
+    JsLinkedHashMap, Es6LinkedHashMap,
     LinkedHashMapCell, LinkedHashMapKeyIterable, LinkedHashMapKeyIterator;
 
 @patch
 class HashMap<K, V> {
   @patch
   factory HashMap({ bool equals(K key1, K key2),
                     int hashCode(K key),
                     bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
@@ skipping 360 matching lines @@
       if (identical(JS('var', '#[#]', bucket, i), key)) return i;
     }
     return -1;
   }
 }
 
 class _CustomHashMap<K, V> extends _HashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate _validKey;
+
   _CustomHashMap(this._equals, this._hashCode, bool validKey(potentialKey))
       : _validKey = (validKey != null) ? validKey : ((v) => v is K);
 
   V operator[](Object key) {
     if (!_validKey(key)) return null;
     return super._get(key);
   }
 
   void operator[]=(K key, V value) {
     super._set(key, value);
@@ skipping 86 matching lines @@
 
 @patch
 class LinkedHashMap<K, V> {
   @patch
   factory LinkedHashMap({ bool equals(K key1, K key2),
                           int hashCode(K key),
                           bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
-          return new JsLinkedHashMap<K, V>();
+          if (JsLinkedHashMap.supportsEs6Maps) {
+            return new Es6LinkedHashMap<K, V>();
+          } else {
+            return new JsLinkedHashMap<K, V>();
+          }
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _LinkedIdentityHashMap<K, V>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _LinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
   @patch
   factory LinkedHashMap.identity() = _LinkedIdentityHashMap<K, V>;
 
   // Private factory constructor called by generated code for map literals.
   @NoInline()
   factory LinkedHashMap._literal(List keyValuePairs) {
-    return fillLiteralMap(keyValuePairs, new JsLinkedHashMap<K, V>());
+    Map map = JsLinkedHashMap.supportsEs6Maps

[Vyacheslav Egorov (Google), 2015/03/26 00:03:57]

Can this just call some force-inline static method? cause seems like a bit of
duplication going on (there are three places with the same condition.

[Harry Terkelsen, 2015/03/26 00:40:06]

Won't that require generic methods?

[floitsch, 2015/03/26 00:53:24]

:)
I wondered the same, and had already started. The problem is, that functions
can't have generic types. So it would need to be a factory constructor.
That was my initial implementation (dispatching inside the JsLinkedHashMap
factory constructor). But that requires other changes all over the place,
because JsLinkedHashMap is subclassed.

One good alternative would be to create a named factory constructor in
JsLinkedHasMap. I just couldn't come up with a good name yet.

+        ? new Es6LinkedHashMap<K, V>()
+        : new JsLinkedHashMap<K, V>();
+    return fillLiteralMap(keyValuePairs, map);
   }
 
   // Private factory constructor called by generated code for map literals.
   @NoThrows() @NoInline()
   factory LinkedHashMap._empty() {
-    return new JsLinkedHashMap<K, V>();
+    return JsLinkedHashMap.supportsEs6Maps
+        ? new Es6LinkedHashMap<K, V>()
+        : new JsLinkedHashMap<K, V>();
   }
 }
 
+// TODO(floitsch): use ES6 Maps when available.
 class _LinkedIdentityHashMap<K, V> extends JsLinkedHashMap<K, V> {
+

[Harry Terkelsen, 2015/03/26 00:40:07]

unnecessary blank line

[floitsch, 2015/03/26 00:53:24]

Done.

   int internalComputeHashCode(var key) {
     // We force the hash codes to be unsigned 30-bit integers to avoid
     // issues with problematic keys like '__proto__'. Another option
     // would be to throw an exception if the hash code isn't a number.
     return JS('int', '# & 0x3ffffff', identityHashCode(key));
   }
 
   int internalFindBucketIndex(var bucket, var key) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
       LinkedHashMapCell cell = JS('var', '#[#]', bucket, i);
       if (identical(cell.hashMapCellKey, key)) return i;
     }
     return -1;
   }
 }
 
+// TODO(floitsch): use ES6 maps when available.
 class _LinkedCustomHashMap<K, V> extends JsLinkedHashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate _validKey;
+
   _LinkedCustomHashMap(this._equals, this._hashCode,
                        bool validKey(potentialKey))
       : _validKey = (validKey != null) ? validKey : ((v) => v is K);
 
+

[Harry Terkelsen, 2015/03/26 00:40:06]

unnecessary blank line

[floitsch, 2015/03/26 00:53:24]

Done.

   V operator[](Object key) {
     if (!_validKey(key)) return null;
     return super.internalGet(key);
   }
 
   void operator[]=(K key, V value) {
     super.internalSet(key, value);
   }
 
   bool containsKey(Object key) {
@@ skipping 887 matching lines @@
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
       _current = _cell._element;
       _cell = _cell._next;
       return true;
     }
   }
 }