Avoid useless allocations in _CompactLinkedHashSet constructor

runtime/lib/compact_hash.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:typed_data';
 import 'dart:_internal' as internal;
 
 // Hash table with open addressing that separates the index from keys/values.
 
 abstract class _HashFieldBase {
   // Each occupied entry in _index is a fixed-size integer that encodes a pair:
   //   [ hash pattern for key | index of entry in _data ]
   // The hash pattern is based on hashCode, but is guaranteed to be non-zero.
   // The length of _index is always a power of two, and there is always at
   // least one unoccupied entry.
   // NOTE: When maps are deserialized, their _index and _hashMask is regenerated
   // lazily by _regenerateIndex.
   // TODO(koda): Consider also using null _index for tiny, linear-search tables.
-  Uint32List _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
+  Uint32List _index;
 
   // Cached in-place mask for the hash pattern component. 
-  int _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
+  int _hashMask;
 
   // Fixed-length list of keys (set) or key/value at even/odd indices (map).
-  List _data = new List(_HashBase._INITIAL_INDEX_SIZE);
+  List _data;
 
   // Length of _data that is used (i.e., keys + values for a map).
   int _usedData = 0;
 
   // Number of deleted keys.
   int _deletedKeys = 0;
 }
 
 // Base class for VM-internal classes; keep in sync with _HashFieldBase.
 abstract class _HashVMBase {
@@ skipping 82 matching lines @@
     with MapMixin<K, V>, _LinkedHashMapMixin<K, V>, _HashBase,
          _OperatorEqualsAndHashCode
     implements LinkedHashMap<K, V> {
   factory _InternalLinkedHashMap() native "LinkedHashMap_allocate";
 }
 
 class _LinkedHashMapMixin<K, V> {  
   int get length => (_usedData >> 1) - _deletedKeys;
   bool get isEmpty => length == 0;
   bool get isNotEmpty => !isEmpty;
-  
+
   void _rehash() {
     if ((_deletedKeys << 2) > _usedData) {
       // TODO(koda): Consider shrinking.
       // TODO(koda): Consider in-place compaction and more costly CME check.
       _init(_index.length, _hashMask, _data, _usedData);
     } else {
       // TODO(koda): Support 32->64 bit transition (and adjust _hashMask).
       _init(_index.length << 1, _hashMask >> 1, _data, _usedData);
     }
   }
   
   void clear() {
     if (!isEmpty) {
       // Use _data.length, since _index might be null.
-      _init(_data.length, _hashMask);
+      _init(_data.length, _hashMask, null, 0);
     }
   }
 
   // Allocate new _index and _data, and optionally copy existing contents.
-  void _init(int size, int hashMask, [List oldData, int oldUsed]) {
+  void _init(int size, int hashMask, List oldData, int oldUsed) {
     assert(size & (size - 1) == 0);
     assert(_HashBase._UNUSED_PAIR == 0);
     _index = new Uint32List(size);
     _hashMask = hashMask;
     _data = new List(size);
     _usedData = 0;
     _deletedKeys = 0;
     if (oldData != null) {
       for (int i = 0; i < oldUsed; i += 2) {
         var key = oldData[i];
@@ skipping 40 matching lines @@
   // If key is present, returns the index of the value in _data, else returns
   // the negated insertion point in _index.
   int _findValueOrInsertPoint(K key, int fullHash, int hashPattern, int size) {
     final int sizeMask = size - 1;
     final int maxEntries = size >> 1;
     int i = _HashBase._firstProbe(fullHash, sizeMask);
     int firstDeleted = -1;
     int pair = _index[i];
     while (pair != _HashBase._UNUSED_PAIR) {
       if (pair == _HashBase._DELETED_PAIR) {
-        if (firstDeleted < 0){
+        if (firstDeleted < 0) {
           firstDeleted = i;
         }
       } else {
         final int entry = hashPattern ^ pair;
         if (entry < maxEntries) {
           final int d = entry << 1;
           if (_equals(key, _data[d])) {
             return d + 1;
           }
         }
@@ skipping 124 matching lines @@
   Iterable<K> get keys =>
       new _CompactIterable<K>(this, _data, _usedData, -2, 2);
   Iterable<V> get values =>
       new _CompactIterable<V>(this, _data, _usedData, -1, 2);
 }
 
 class _CompactLinkedIdentityHashMap<K, V> extends _HashFieldBase
     with MapMixin<K, V>, _LinkedHashMapMixin<K, V>, _HashBase,
          _IdenticalAndIdentityHashCode
     implements LinkedHashMap<K, V> {
+
+  _CompactLinkedIdentityHashMap() {
+    _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
+    _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
+    _data = new List(_HashBase._INITIAL_INDEX_SIZE);
+  }
 }
 
 class _CompactLinkedCustomHashMap<K, V> extends _HashFieldBase
     with MapMixin<K, V>, _LinkedHashMapMixin<K, V>, _HashBase
     implements LinkedHashMap<K, V> {
   final _equality;
   final _hasher;
   final _validKey;
 
   // TODO(koda): Ask gbracha why I cannot have fields _equals/_hashCode.
   int _hashCode(e) => _hasher(e);
   bool _equals(e1, e2) => _equality(e1, e2);
 
   bool containsKey(Object o) => _validKey(o) ? super.containsKey(o) : false;
   V operator[](Object o) => _validKey(o) ? super[o] : null;
   V remove(Object o) => _validKey(o) ? super.remove(o) : null;
 
   _CompactLinkedCustomHashMap(this._equality, this._hasher, validKey)
-      : _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test;
+      : _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test {
+    _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
+    _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
+    _data = new List(_HashBase._INITIAL_INDEX_SIZE);
+  }
 }
 
 // Iterates through _data[_offset + _step], _data[_offset + 2*_step], ...
 // and checks for concurrent modification.
 class _CompactIterable<E> extends IterableBase<E> {
   final _table;
   final List _data;
   final int _len;
   final int _offset;
   final int _step;
@@ skipping 39 matching lines @@
 }
 
 // Set implementation, analogous to _CompactLinkedHashMap.
 class _CompactLinkedHashSet<E> extends _HashFieldBase
     with _HashBase, _OperatorEqualsAndHashCode, SetMixin<E>
     implements LinkedHashSet<E> {
 
   _CompactLinkedHashSet() {
     assert(_HashBase._UNUSED_PAIR == 0);
     _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
+    _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
     _data = new List(_HashBase._INITIAL_INDEX_SIZE >> 1);
   }
 
   int get length => _usedData - _deletedKeys;
 
   void _rehash() {
     if ((_deletedKeys << 1) > _usedData) {
       _init(_index.length, _hashMask, _data, _usedData);
     } else {
       _init(_index.length << 1, _hashMask >> 1, _data, _usedData);
     }
   }
 
   void clear() {
     if (!isEmpty) {
-      _init(_index.length, _hashMask);
+      _init(_index.length, _hashMask, null, 0);
     }
   }
 
-  void _init(int size, int hashMask, [List oldData, int oldUsed]) {
+  void _init(int size, int hashMask, List oldData, int oldUsed) {
     _index = new Uint32List(size);
     _hashMask = hashMask;
     _data = new List(size >> 1);
     _usedData = 0;
     _deletedKeys = 0;
     if (oldData != null) {
       for (int i = 0; i < oldUsed; i += 1) {
         var key = oldData[i];
         if (!_HashBase._isDeleted(oldData, key)) {
           add(key);
         }
       }
     }
   }
 
   bool add(E key) {
     final int size = _index.length;
     final int sizeMask = size - 1;
     final int maxEntries = size >> 1;
     final int fullHash = _hashCode(key);
     final int hashPattern = _HashBase._hashPattern(fullHash, _hashMask, size);
     int i = _HashBase._firstProbe(fullHash, sizeMask);
     int firstDeleted = -1;
     int pair = _index[i];
     while (pair != _HashBase._UNUSED_PAIR) {
       if (pair == _HashBase._DELETED_PAIR) {
-        if (firstDeleted < 0){
+        if (firstDeleted < 0) {
           firstDeleted = i;
         }
       } else {
         final int d = hashPattern ^ pair;
         if (d < maxEntries && _equals(key, _data[d])) {
           return false;
         }
       }
       i = _HashBase._nextProbe(i, sizeMask);
       pair = _index[i];
@@ skipping 91 matching lines @@
   E lookup(Object o) => _validKey(o) ? super.lookup(o) : null;
   bool remove(Object o) => _validKey(o) ? super.remove(o) : false;
 
   _CompactLinkedCustomHashSet(this._equality, this._hasher, validKey)
       : _validKey = (validKey != null) ? validKey : new _TypeTest<E>().test;
 
   Set<E> toSet() =>
       new _CompactLinkedCustomHashSet<E>(_equality, _hasher, _validKey)
           ..addAll(this);
 }