Make LinkedHashMap also have a factory constructor and be customizable

sdk/lib/_internal/lib/collection_patch.dart

Index: sdk/lib/_internal/lib/collection_patch.dart
diff --git a/sdk/lib/_internal/lib/collection_patch.dart b/sdk/lib/_internal/lib/collection_patch.dart
index c5fa69cf9dfd4caa245c585b23dc604aa7bb86be..1d3b9054a4db309ece85e418c8d5b86acd25ac14 100644
--- a/sdk/lib/_internal/lib/collection_patch.dart
+++ b/sdk/lib/_internal/lib/collection_patch.dart
@@ -9,7 +9,7 @@ patch class HashMap<K, V> {
   patch factory HashMap({ bool equals(K key1, K key2), int hashCode(K key) }) {
     if (hashCode == null) {
       if (equals == null) {
-        return new _HashMapImpl<K, V>();
+        return new _Hash<K, V>();
       }
       if (identical(identical, equals)) {
         return new _IdentityHashMap<K, V>();
@@ -22,7 +22,7 @@ patch class HashMap<K, V> {
   }
 }
 
-class _HashMapImpl<K, V> implements HashMap<K, V> {
+class _Hash<K, V> implements HashMap<K, V> {
   int _length = 0;
 
   // The hash map contents are divided into three parts: one part for
@@ -43,7 +43,7 @@ class _HashMapImpl<K, V> implements HashMap<K, V> {
   // guard against concurrent modifications.
   List _keys;
 
-  _HashMapImpl();
+  _Hash();
 
   int get length => _length;
   bool get isEmpty => _length == 0;
@@ -325,7 +325,7 @@ class _HashMapImpl<K, V> implements HashMap<K, V> {
   }
 }
 
-class _IdentityHashMap<K, V> extends _HashMapImpl<K, V> {
+class _IdentityHashMap<K, V> extends _Hash<K, V> {
   int _findBucketIndex(var bucket, var key) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
@@ -336,7 +336,7 @@ class _IdentityHashMap<K, V> extends _HashMapImpl<K, V> {
   }
 }
 
-class _CustomHashMap<K, V> extends _HashMapImpl<K, V> {
+class _CustomHashMap<K, V> extends _Hash<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   _CustomHashMap(this._equals, this._hashCode);
@@ -416,6 +416,24 @@ class HashMapKeyIterator<E> implements Iterator<E> {
 }
 
 patch class LinkedHashMap<K, V> {
+  patch factory LinkedHashMap({ bool equals(K key1, K key2),
+                                int hashCode(K key) }) {
+    if (hashCode == null) {
+      if (equals == null) {
+        return new _LinkedHash<K, V>();
+      }
+      if (identical(identical, equals)) {
+        return new _LinkedIdentityHashMap<K, V>();
+      }
+      hashCode = _defaultHashCode;
+    } else if (equals == null) {
+      equals = _defaultEquals;
+    }
+    return new _LinkedCustomHashMap<K, V>(equals, hashCode);
+  }
+}
+
+class _LinkedHash<K, V> implements LinkedHashMap<K, V> {
   int _length = 0;
 
   // The hash map contents are divided into three parts: one part for
@@ -440,22 +458,22 @@ patch class LinkedHashMap<K, V> {
   // iterated over.
   int _modifications = 0;
 
-  patch LinkedHashMap();
+  _LinkedHash();
 
-  patch int get length => _length;
-  patch bool get isEmpty => _length == 0;
-  patch bool get isNotEmpty => !isEmpty;
+  int get length => _length;
+  bool get isEmpty => _length == 0;
+  bool get isNotEmpty => !isEmpty;
 
 
-  patch Iterable<K> get keys {
+  Iterable<K> get keys {
     return new LinkedHashMapKeyIterable<K>(this);
   }
 
-  patch Iterable<V> get values {
+  Iterable<V> get values {
     return keys.map((each) => this[each]);
   }
 
-  patch bool containsKey(Object key) {
+  bool containsKey(Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) return false;
@@ -474,17 +492,17 @@ patch class LinkedHashMap<K, V> {
     }
   }
 
-  patch bool containsValue(Object value) {
+  bool containsValue(Object value) {
     return keys.any((each) => this[each] == value);
   }
 
-  patch void addAll(Map<K, V> other) {
+  void addAll(Map<K, V> other) {
     other.forEach((K key, V value) {
       this[key] = value;
     });
   }
 
-  patch V operator[](Object key) {
+  V operator[](Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) return null;
@@ -506,7 +524,7 @@ patch class LinkedHashMap<K, V> {
     }
   }
 
-  patch void operator[]=(K key, V value) {
+  void operator[]=(K key, V value) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) _strings = strings = _newHashTable();
@@ -536,14 +554,14 @@ patch class LinkedHashMap<K, V> {
     }
   }
 
-  patch V putIfAbsent(K key, V ifAbsent()) {
+  V putIfAbsent(K key, V ifAbsent()) {
     if (containsKey(key)) return this[key];
     V value = ifAbsent();
     this[key] = value;
     return value;
   }
 
-  patch V remove(Object key) {
+  V remove(Object key) {
     if (_isStringKey(key)) {
       return _removeHashTableEntry(_strings, key);
     } else if (_isNumericKey(key)) {
@@ -564,7 +582,7 @@ patch class LinkedHashMap<K, V> {
     }
   }
 
-  patch void clear() {
+  void clear() {
     if (_length > 0) {
       _strings = _nums = _rest = _first = _last = null;
       _length = 0;
@@ -572,7 +590,7 @@ patch class LinkedHashMap<K, V> {
     }
   }
 
-  patch void forEach(void action(K key, V value)) {
+  void forEach(void action(K key, V value)) {
     LinkedHashMapCell cell = _first;
     int modifications = _modifications;
     while (cell != null) {
@@ -655,7 +673,7 @@ patch class LinkedHashMap<K, V> {
     return key is num && JS('bool', '(# & 0x3ffffff) === #', key, key);
   }
 
-  static int _computeHashCode(var key) {
+  int _computeHashCode(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.
@@ -675,12 +693,12 @@ patch class LinkedHashMap<K, V> {
     JS('void', 'delete #[#]', table, key);
   }
 
-  static List _getBucket(var table, var key) {
+  List _getBucket(var table, var key) {
     var hash = _computeHashCode(key);
     return JS('var', '#[#]', table, hash);
   }
 
-  static int _findBucketIndex(var bucket, var key) {
+  int _findBucketIndex(var bucket, var key) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
@@ -702,6 +720,43 @@ patch class LinkedHashMap<K, V> {
     _deleteTableEntry(table, temporaryKey);
     return table;
   }
+
+  String toString() => Maps.mapToString(this);
+}
+
+class _LinkedIdentityHashMap<K, V> extends _LinkedHash<K, V> {
+  int _findBucketIndex(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._key, key)) return i;
+    }
+    return -1;
+  }
+}
+
+class _LinkedCustomHashMap<K, V> extends _LinkedHash<K, V> {
+  final _Equality<K> _equals;
+  final _Hasher<K> _hashCode;
+  _LinkedCustomHashMap(this._equals, this._hashCode);
+
+  int _computeHashCode(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', _hashCode(key));
+  }
+
+  int _findBucketIndex(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 (_equals(cell._key, key)) return i;
+    }
+    return -1;
+  }
 }
 
 class LinkedHashMapCell {