Make hashCode a getter and not a method.

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, 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 52 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 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.
         // If the current slot is empty and we didn't find any
@@ 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 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.
       if (existingKey == key) return hash;
@@ skipping 329 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();
 }