VM: Remove old LinkedHashMap implementation that is no longer used

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.
 
 import 'dart:typed_data';
 import 'dart:_internal' as internal;
 
 @patch
 class HashMap<K, V> {
   @patch
@@ skipping 810 matching lines @@
         return true;
       }
     }
     _current = null;
     return false;
   }
 
   E get current => _current;
 }
 
-class _LinkedHashMapEntry extends _HashMapEntry {
-  /// Double-linked list of entries of a linked hash map.
-  /// The _LinkedHashMap itself is the head of the list, so the type is "var".
-  /// Both are initialized to `this` when initialized.
-  var _nextEntry;
-  var _previousEntry;
-  _LinkedHashMapEntry(key, value, int hashCode, _LinkedHashMapEntry next,
-      this._previousEntry, this._nextEntry)
-      : super(key, value, hashCode, next) {
-    _previousEntry._nextEntry = this;
-    _nextEntry._previousEntry = this;
-  }
-}
-
-class _LinkedHashMapKeyIterable<K> extends EfficientLengthIterable<K> {
-  LinkedHashMap<K, dynamic> _map;
-  _LinkedHashMapKeyIterable(this._map);
-  Iterator<K> get iterator => new _LinkedHashMapKeyIterator<K>(_map);
-  bool contains(Object key) => _map.containsKey(key);
-  bool get isEmpty => _map.isEmpty;
-  bool get isNotEmpty => _map.isNotEmpty;
-  int get length => _map.length;
-  Set<K> toSet() => _map._newKeySet()..addAll(this);
-}
-
-class _LinkedHashMapValueIterable<V> extends EfficientLengthIterable<V> {
-  LinkedHashMap<dynamic, V> _map;
-  _LinkedHashMapValueIterable(this._map);
-  Iterator<V> get iterator => new _LinkedHashMapValueIterator<V>(_map);
-  bool contains(Object value) => _map.containsValue(value);
-  bool get isEmpty => _map.isEmpty;
-  bool get isNotEmpty => _map.isNotEmpty;
-  int get length => _map.length;
-}
-
-abstract class _LinkedHashMapIterator<T> implements Iterator<T> {
-  final LinkedHashMap _map;
-  var _next;
-  T _current;
-  int _modificationCount;
-  _LinkedHashMapIterator(LinkedHashMap map)
-      : _map = map,
-        _next = map._nextEntry,
-        _modificationCount = map._modificationCount;
-
-  bool moveNext() {
-    if (_modificationCount != _map._modificationCount) {
-      throw new ConcurrentModificationError(_map);
-    }
-    if (identical(_map, _next)) {
-      _current = null;
-      return false;
-    }
-    _LinkedHashMapEntry entry = _next;
-    _next = entry._nextEntry;
-    _current = _getValue(entry);
-    return true;
-  }
-
-  T _getValue(_LinkedHashMapEntry entry);
-
-  T get current => _current;
-}
-
-class _LinkedHashMapKeyIterator<K> extends _LinkedHashMapIterator<K> {
-  _LinkedHashMapKeyIterator(LinkedHashMap map) : super(map);
-  K _getValue(_LinkedHashMapEntry entry) => entry.key;
-}
-
-class _LinkedHashMapValueIterator<V> extends _LinkedHashMapIterator<V> {
-  _LinkedHashMapValueIterator(LinkedHashMap map) : super(map);
-  V _getValue(_LinkedHashMapEntry entry) => entry.value;
-}
-
 /**
  * A hash-based map that iterates keys and values in key insertion order.
+ * This is never actually instantiated any more - the constructor always

[zra, 2017/07/20 16:44:07]

'the constructor always ...'

Maybe update comment to reflect the possibility to return
_InternalLinkedHashMap() when no defaults are overridden.

[erikcorry, 2017/07/28 08:28:10]

Done.

+ * returns an instance of CompactLinkedHashMap, which despite the name
+ * does not use links (but is insertion-ordered as if it did).
  */
 @patch
 class LinkedHashMap<K, V> {
-  /// Holds a double-linked list of entries in insertion order.
-  /// The fields have the same name as the ones in [_LinkedHashMapEntry],
-  /// and this map is itself used as the head entry of the list.
-  /// Set to `this` when initialized, representing the empty list (containing
-  /// only the head entry itself).
-  var _nextEntry;
-  var _previousEntry;
-
   @patch
   factory LinkedHashMap(
       {bool equals(K key1, K key2),
       int hashCode(K key),
       bool isValidKey(potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _InternalLinkedHashMap<K, V>();
         }
@@ skipping 51 matching lines @@
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
   @patch
   factory LinkedHashSet.identity() = _CompactLinkedIdentityHashSet<E>;
 }