Ensure hash pattern is non-zero. Re-enable compact hash map/set.

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';
 
 // Hash table with open addressing that separates the index from keys/values.
 abstract class _HashBase {
   // Each occupied entry in _index is a fixed-size integer that encodes a pair:
   //   [ hash pattern for key | index of entry in _data ]
@@ skipping 14 matching lines @@
   static const int _UNUSED_PAIR = 0;
   static const int _DELETED_PAIR = 1;
   
   // Cached in-place mask for the hash pattern component. On 32-bit, the top
   // bits are wasted to avoid Mint allocation.
   // TODO(koda): Reclaim the bits by making the compiler treat hash patterns
   // as unsigned words.
   int _hashMask = int.is64Bit() ?
       (1 << (32 - _INITIAL_INDEX_BITS)) - 1 :
       (1 << (30 - _INITIAL_INDEX_BITS)) - 1;
-  
-  static int _hashPattern(int fullHash, int hashMask, int size) =>
-      // TODO(koda): Consider keeping bit length and use left shift.
-      (fullHash == 0) ? (size >> 1) : (fullHash & hashMask) * (size >> 1);
+
+  static int _hashPattern(int fullHash, int hashMask, int size) {
+    final int maskedHash = fullHash & hashMask;
+    // TODO(koda): Consider keeping bit length and use left shift.
+    return (maskedHash == 0) ? (size >> 1) : maskedHash * (size >> 1);
+  }
 
   // Linear probing.
   static int _firstProbe(int fullHash, int sizeMask) {
     final int i = fullHash & sizeMask;
     // Light, fast shuffle to mitigate bad hashCode (e.g., sequential).
     return ((i << 1) + i) & sizeMask;
   }
   static int _nextProbe(int i, int sizeMask) => (i + 1) & sizeMask;
   
   // Fixed-length list of keys (set) or key/value at even/odd indices (map).
@@ skipping 68 matching lines @@
         }
       }
     }
   }
   
   void _insert(K key, V value, int hashPattern, int i) {
     if (_usedData == _data.length) {
       _rehash();
       this[key] = value;
     } else {
-      assert(0 <= hashPattern && hashPattern <  (1 << 32));
+      assert(1 <= hashPattern && hashPattern <  (1 << 32));
       final int index = _usedData >> 1;
       assert((index & hashPattern) == 0);
       _index[i] = hashPattern | index;
       _data[_usedData++] = key;
       _data[_usedData++] = value;
     }
   }
   
   // If key is present, returns the index of the value in _data, else returns
   // the negated insertion point in _index.
@@ skipping 258 matching lines @@
         }
       }
       i = _HashBase._nextProbe(i, sizeMask);
       pair = _index[i];
     }
     if (_usedData == _data.length) {
       _rehash();
       add(key);
     } else {
       final int insertionPoint = (firstDeleted >= 0) ? firstDeleted : i;
-      assert(0 <= hashPattern && hashPattern < (1 << 32));
+      assert(1 <= hashPattern && hashPattern < (1 << 32));
       assert((hashPattern & _usedData) == 0);
       _index[insertionPoint] = hashPattern | _usedData;
       _data[_usedData++] = key;
     }
     return true;
   }
   
   // If key is absent, return _data (which is never a value).
   Object _getKeyOrData(Object key) {
     final int size = _index.length;
@@ skipping 45 matching lines @@
       pair = _index[i];
     }
     return false;
   }
                                                 
   Iterator<K> get iterator =>
       new _CompactIterator<K>(this, _data, _usedData, -1, 1);
 
   Set<K> toSet() => new Set<K>()..addAll(this);  
 }