Remove override of runtimeType from HashMap implementations.

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 17 matching lines @@
     }
     return new _CustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 }
 
 const int _MODIFICATION_COUNT_MASK = 0x3fffffff;
 
 class _HashMap<K, V> implements HashMap<K, V> {
   static const int _INITIAL_CAPACITY = 8;
 
-  Type get runtimeType => HashMap;
 
   int _elementCount = 0;
   List<_HashMapEntry> _buckets = new List(_INITIAL_CAPACITY);
   int _modificationCount = 0;
 
   int get length => _elementCount;
   bool get isEmpty => _elementCount == 0;
   bool get isNotEmpty => _elementCount != 0;
 
   Iterable<K> get keys => new _HashMapKeyIterable<K>(this);
@@ skipping 170 matching lines @@
   String toString() => Maps.mapToString(this);
 }
 
 class _CustomHashMap<K, V> extends _HashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate _validKey;
   _CustomHashMap(this._equals, this._hashCode, validKey)
       : _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test;
 
-  Type get runtimeType => HashMap;
 
   bool containsKey(Object key) {
     if (!_validKey(key)) return false;
     int hashCode = _hashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && _equals(entry.key, key)) return true;
       entry = entry.next;
@@ skipping 73 matching lines @@
       previous = entry;
       entry = next;
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
 }
 
 class _IdentityHashMap<K, V> extends _HashMap<K, V> {
-  Type get runtimeType => HashMap;
 
   bool containsKey(Object key) {
     int hashCode = key.hashCode;
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) return true;
       entry = entry.next;
     }
@@ skipping 563 matching lines @@
     }
     return new _LinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 }
 
 // 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;
 
-  Type get runtimeType => LinkedHashMap;
 
   bool containsValue(Object value) {
     int modificationCount = _modificationCount;
     var cursor = _nextEntry;
     while (!identical(cursor, this)) {
       _HashMapEntry entry = cursor;
       if (entry.value == value) return true;
       if (modificationCount != _modificationCount) {
         throw new ConcurrentModificationError(this);
       }
@@ skipping 284 matching lines @@
       return false;
     }
     _LinkedHashSetEntry entry = _next;
     _current = entry.key;
     _next = entry._nextEntry;
     return true;
   }
 
   E get current => _current;
 }