Ensure that hashCode and runtimeType work on null.

lib/coreimpl/hash_map_set.dart

 // Copyright (c) 2012, 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.
 
 // Hash map implementation with open addressing and quadratic probing.
 class HashMapImplementation<K extends Hashable, V> implements HashMap<K, V> {
 
   // The [_keys] list contains the keys inserted in the map.
   // The [_keys] list must be a raw list because it
   // will contain both elements of type K, and the [_DELETED_KEY] of type
@@ skipping 51 matching lines @@
 
   static int _firstProbe(int hashCode, int length) {
     return hashCode & (length - 1);
   }
 
   static int _nextProbe(int currentProbe, int numberOfProbes, int length) {
     return (currentProbe + numberOfProbes) & (length - 1);
   }
 
   int _probeForAdding(K key) {
+    if (key == null) throw const NullPointerException();
     int hash = _firstProbe(key.hashCode(), _keys.length);
     int numberOfProbes = 1;
     int initialHash = hash;
     // insertionIndex points to a slot where a key was deleted.
     int insertionIndex = -1;
     while (true) {
       // [existingKey] can be either of type [K] or [_DeletedKeySentinel].
       Object existingKey = _keys[hash];
       if (existingKey === null) {
         // We are sure the key is not already in the set.
@@ skipping 13 matching lines @@
       }
 
       // We did not find an insertion slot. Look at the next one.
       hash = _nextProbe(hash, numberOfProbes++, _keys.length);
       // _ensureCapacity has guaranteed the following cannot happen.
       // assert(hash != initialHash);
     }
   }
 
   int _probeForLookup(K key) {
+    if (key == null) throw const NullPointerException();
     int hash = _firstProbe(key.hashCode(), _keys.length);
     int numberOfProbes = 1;
     int initialHash = hash;
     while (true) {
       // [existingKey] can be either of type [K] or [_DeletedKeySentinel].
       Object existingKey = _keys[hash];
       // If the slot does not contain anything (in particular, it does not
       // contain a deleted key), we know the key is not in the map.
       if (existingKey === null) return -1;
       // The key is in the map, return its index.
@@ skipping 74 matching lines @@
   }
 
   V operator [](K key) {
     int index = _probeForLookup(key);
     if (index < 0) return null;
     return _values[index];
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
     int index = _probeForLookup(key);
-    if (index >=0) return _values[index];
+    if (index >= 0) return _values[index];
 
     V value = ifAbsent();
     this[key] = value;
     return value;
   }
 
   V remove(K key) {
     int index = _probeForLookup(key);
     if (index >= 0) {
       _numberOfEntries--;
@@ skipping 235 matching lines @@
 
 /**
  * A singleton sentinel used to represent when a key is deleted from the map.
  * We can't use [: const Object() :] as a sentinel because it would end up
  * canonicalized and then we cannot distinguish the deleted key from the
  * canonicalized [: Object() :].
  */
 class _DeletedKeySentinel {
   const _DeletedKeySentinel();
 }