dart2js: use Es6 maps when available.

sdk/lib/_internal/compiler/js_lib/linked_hash_map.dart

 // Copyright (c) 2014, 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.
 
 // Efficient JavaScript based implementation of a linked hash map used as a
 // backing map for constant maps and the [LinkedHashMap] patch
 
 part of _js_helper;
 
+const _USE_ES6_MAPS = const bool.fromEnvironment("dart2js.use.es6.maps");
+
 class JsLinkedHashMap<K, V> implements LinkedHashMap<K, V>, InternalMap {
   int _length = 0;
 
   // The hash map contents are divided into three parts: one part for
   // string keys, one for numeric keys, and one for the rest. String
   // and numeric keys map directly to their linked cells, but the rest
   // of the entries are stored in bucket lists of the form:
   //
   //    [cell-0, cell-1, ...]
   //
   // where all keys in the same bucket share the same hash code.
   var _strings;
   var _nums;
   var _rest;
 
   // The keys and values are stored in cells that are linked together
   // to form a double linked list.
   LinkedHashMapCell _first;
   LinkedHashMapCell _last;
 
   // We track the number of modifications done to the key set of the
   // hash map to be able to throw when the map is modified while being
   // iterated over.
   int _modifications = 0;
 
+  static bool get _supportsEs6Maps {
+    return JS('returns:bool;depends:none;effects:none;',
+    'typeof Map != "undefined"');
+  }
+
   JsLinkedHashMap();
 
+  /// If ES6 Maps are available returns a linked hash-map backed by an ES6 Map.
+  factory JsLinkedHashMap.es6() {
+    if (_USE_ES6_MAPS && JsLinkedHashMap._supportsEs6Maps) {

[herhut, 2015/04/13 12:58:33]

Type inference will not currently understand this pattern but hopefully type
propagation will get rid of the constructor call, so that the code in the end
does not contain the implementation for the ES6 map if usage is disabled.

+      return new Es6LinkedHashMap<K, V>();
+    } else {
+      return new JsLinkedHashMap<K, V>();
+    }
+  }
 
   int get length => _length;
   bool get isEmpty => _length == 0;
   bool get isNotEmpty => !isEmpty;
 
   Iterable<K> get keys {
     return new LinkedHashMapKeyIterable<K>(this);
   }
 
   Iterable<V> get values {
     return new MappedIterable<K, V>(keys, (each) => this[each]);
   }
 
   bool containsKey(Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) return false;
-      LinkedHashMapCell cell = _getTableEntry(strings, key);
-      return cell != null;
+      return _containsTableEntry(strings, key);
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       if (nums == null) return false;
-      LinkedHashMapCell cell = _getTableEntry(nums, key);
-      return cell != null;
+      return _containsTableEntry(nums, key);
     } else {
       return internalContainsKey(key);
     }
   }
 
   bool internalContainsKey(Object key) {
     var rest = _rest;
     if (rest == null) return false;
     var bucket = _getBucket(rest, key);
     return internalFindBucketIndex(bucket, key) >= 0;
@@ skipping 46 matching lines @@
       _addHashTableEntry(nums, key, value);
     } else {
       internalSet(key, value);
     }
   }
 
   void internalSet(K key, V value) {
     var rest = _rest;
     if (rest == null) _rest = rest = _newHashTable();
     var hash = internalComputeHashCode(key);
-    var bucket = JS('var', '#[#]', rest, hash);
+    var bucket = _getTableEntry(rest, hash);
     if (bucket == null) {
       LinkedHashMapCell cell = _newLinkedCell(key, value);
       _setTableEntry(rest, hash, JS('var', '[#]', cell));
     } else {
       int index = internalFindBucketIndex(bucket, key);
       if (index >= 0) {
         LinkedHashMapCell cell = JS('var', '#[#]', bucket, index);
         cell.hashMapCellValue = value;
       } else {
         LinkedHashMapCell cell = _newLinkedCell(key, value);
@@ skipping 108 matching lines @@
       assert(cell == _last);
       _last = previous;
     } else {
       next._previous = previous;
     }
     _length--;
     _modified();
   }
 
   static bool _isStringKey(var key) {
-    return key is String && key != '__proto__';
+    return key is String;

[herhut, 2015/04/13 12:58:33]

Nice!

   }
 
   static bool _isNumericKey(var key) {
     // Only treat unsigned 30-bit integers as numeric keys. This way,
     // we avoid converting them to strings when we use them as keys in
     // the JavaScript hash table object.
     return key is num && JS('bool', '(# & 0x3ffffff) === #', key, key);
   }
 
   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', key.hashCode);
   }
 
-  static _getTableEntry(var table, var key) {
-    return JS('var', '#[#]', table, key);
-  }
-
-  static void _setTableEntry(var table, var key, var value) {
-    assert(value != null);
-    JS('void', '#[#] = #', table, key, value);
-  }
-
-  static void _deleteTableEntry(var table, var key) {
-    JS('void', 'delete #[#]', table, key);
-  }
-
   List _getBucket(var table, var key) {
     var hash = internalComputeHashCode(key);
-    return JS('var', '#[#]', table, hash);
+    return _getTableEntry(table, hash);
   }
 
   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 (cell.hashMapCellKey == key) return i;
     }
     return -1;
   }
 
-  static _newHashTable() {
+  String toString() => Maps.mapToString(this);
+
+  _getTableEntry(var table, var key) {
+    return JS('var', '#[#]', table, key);
+  }
+
+  void _setTableEntry(var table, var key, var value) {
+    assert(value != null);
+    JS('void', '#[#] = #', table, key, value);
+  }
+
+  void _deleteTableEntry(var table, var key) {
+    JS('void', 'delete #[#]', table, key);
+  }
+
+  bool _containsTableEntry(var table, var key) {
+    LinkedHashMapCell cell = _getTableEntry(table, key);
+    return cell != null;
+  }
+
+  _newHashTable() {
     // Create a new JavaScript object to be used as a hash table. Use
     // Object.create to avoid the properties on Object.prototype
     // showing up as entries.
     var table = JS('var', 'Object.create(null)');
     // Attempt to force the hash table into 'dictionary' mode by
     // adding a property to it and deleting it again.
     var temporaryKey = '<non-identifier-key>';
     _setTableEntry(table, temporaryKey, table);
     _deleteTableEntry(table, temporaryKey);
     return table;
   }
+}
 
-  String toString() => Maps.mapToString(this);
+class Es6LinkedHashMap<K, V> extends JsLinkedHashMap<K, V> {
+
+  @override
+  _getTableEntry(var table, var key) {
+    return JS('var', '#.get(#)', table, key);
+  }
+
+  @override
+  void _setTableEntry(var table, var key, var value) {
+    JS('void', '#.set(#, #)', table, key, value);
+  }
+
+  @override
+  void _deleteTableEntry(var table, var key) {
+    JS('void', '#.delete(#)', table, key);
+  }
+
+  @override
+  bool _containsTableEntry(var table, var key) {
+    return JS('bool', '#.has(#)', table, key);
+  }
+
+  @override
+  _newHashTable() {
+    return JS('var', 'new Map()');
+  }
 }
 
 class LinkedHashMapCell {
   final hashMapCellKey;
   var hashMapCellValue;
 
   LinkedHashMapCell _next;
   LinkedHashMapCell _previous;
 
   LinkedHashMapCell(this.hashMapCellKey, this.hashMapCellValue);
@@ skipping 46 matching lines @@
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
       _current = _cell.hashMapCellKey;
       _cell = _cell._next;
       return true;
     }
   }
 }