Compact LinkedHashMap/Set implementation.

runtime/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 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 900 matching lines @@
   var _previousEntry;
 
   /* 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) {
           if (_useInternalCached) {
             return new _InternalLinkedHashMap<K, V>();
+          } else if (_useCompactCached) {
+            return new _CompactLinkedHashMap<K, V>();
           } else {
             return new _LinkedHashMap<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>;
 
   static final bool _useInternalCached = _useInternal;
   static bool get _useInternal native "LinkedHashMap_useInternal";
+  static final bool _useCompactCached = _useCompact;
+  static bool get _useCompact native "LinkedHashMap_useCompact";
 }
 
 // Methods that are exactly the same in all three linked hash map variants.
 abstract class _LinkedHashMapMixin<K, V> implements LinkedHashMap<K, V> {
   var _nextEntry;
   var _previousEntry;
 
 
   bool containsValue(Object value) {
     int modificationCount = _modificationCount;
@@ skipping 96 matching lines @@
 }
 
 
 patch class LinkedHashSet<E> {
   /* patch */ factory LinkedHashSet({ bool equals(E e1, E e2),
                                       int hashCode(E e),
                                       bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
-          return new _LinkedHashSet<E>();
+          if (_useCompactCached) {

[Vyacheslav Egorov (Google), 2015/02/12 15:42:40]

Any reason why you can't just do LinkedHashMap._useCompactCached?

[koda, 2015/02/17 17:26:28]

Done.

+            return new _CompactLinkedHashSet<E>();
+          } else {
+            return new _LinkedHashSet<E>();
+          }
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _LinkedIdentityHashSet<E>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _LinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
   /* patch */ factory LinkedHashSet.identity() = _LinkedIdentityHashSet<E>;
+
+  static final bool _useCompactCached = _useCompact;
+  static bool get _useCompact native "LinkedHashMap_useCompact";
 }
 
 class _LinkedHashSetEntry extends _HashSetEntry {
   /// Links this element into a double-linked list of elements of a hash set.
   /// The hash set object itself is used as the head entry of the list, so
   /// the field is typed as "var".
   /// Both links are initialized to `this` when the object is created.
   var _nextEntry;
   var _previousEntry;
   _LinkedHashSetEntry(var key, int hashCode, _LinkedHashSetEntry next,
@@ skipping 169 matching lines @@
       return false;
     }
     _LinkedHashSetEntry entry = _next;
     _current = entry.key;
     _next = entry._nextEntry;
     return true;
   }
 
   E get current => _current;
 }