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,
     LinkedHashMapCell, LinkedHashMapKeyIterable, LinkedHashMapKeyIterator;
 
@@ skipping 368 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>();
+          return new JsLinkedHashMap<K, V>.es6();
         }
         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>());
+    return fillLiteralMap(keyValuePairs, new JsLinkedHashMap<K, V>.es6());
   }
 
   // Private factory constructor called by generated code for map literals.
   @NoThrows() @NoInline()
   factory LinkedHashMap._empty() {
-    return new JsLinkedHashMap<K, V>();
+    return new JsLinkedHashMap<K, V>.es6();
   }
 }
 
+// TODO(floitsch): use ES6 Maps when available.
 class _LinkedIdentityHashMap<K, V> extends JsLinkedHashMap<K, V> {
   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);
 
   V operator[](Object key) {
     if (!_validKey(key)) return null;
     return super.internalGet(key);
   }
 
   void operator[]=(K key, V value) {
@@ skipping 891 matching lines @@
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
       _current = _cell._element;
       _cell = _cell._next;
       return true;
     }
   }
 }