Move Iterable implementation to collection.

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> {
   final _HashMapTable<K, V> _hashTable = new _HashMapTable<K, V>();
 
   /* patch */ HashMap() {
     _hashTable._container = this;
   }
@@ skipping 682 matching lines @@
     assert(!_isFree(_table[offset]));
     _setKey(offset, _TOMBSTONE);
     _deletedCount++;
     _recordModification();
   }
 }
 
 /**
  * Generic iterable based on a [_HashTable].
  */
-abstract class _HashTableIterable<E> extends Iterable<E> {
+abstract class _HashTableIterable<E> extends IterableBase<E> {
   final _HashTable _hashTable;
   _HashTableIterable(this._hashTable);
 
   Iterator<E> get iterator;
 
   /**
    * Return the iterated value for a given entry.
    */
   E _valueAt(int offset, Object key);
 
@@ skipping 203 matching lines @@
   }
 
   void _deleteEntry(int offset) {
     _unlink(offset);
     _setKey(offset, _TOMBSTONE);
     _deletedCount++;
     _recordModification();
   }
 }
 
-class _LinkedHashTableKeyIterable<K> extends Iterable<K> {
+class _LinkedHashTableKeyIterable<K> extends IterableBase<K> {
   final _LinkedHashTable<K> _table;
   _LinkedHashTableKeyIterable(this._table);
   Iterator<K> get iterator => new _LinkedHashTableKeyIterator<K>(_table);
 
   bool contains(Object value) => _table._get(value) >= 0;
 
   int get length => _table._elementCount;
 }
 
 class _LinkedHashTableKeyIterator<K> extends _LinkedHashTableIterator<K> {
   _LinkedHashTableKeyIterator(_LinkedHashTable<K> hashTable): super(hashTable);
 
   K _getCurrent(int offset) => _hashTable._key(offset);
 }
 
-class _LinkedHashTableValueIterable<V> extends Iterable<V> {
+class _LinkedHashTableValueIterable<V> extends IterableBase<V> {
   final _LinkedHashTable _hashTable;
   final int _valueIndex;
   _LinkedHashTableValueIterable(this._hashTable, this._valueIndex);
   Iterator<V> get iterator =>
       new _LinkedHashTableValueIterator<V>(_hashTable, _valueIndex);
   int get length => _hashTable._elementCount;
 }
 
 class _LinkedHashTableValueIterator<V> extends _LinkedHashTableIterator<V> {
   final int _valueIndex;
@@ skipping 39 matching lines @@
 
   _LinkedHashMapTable() : super(_INITIAL_CAPACITY);
 
   V _value(int offset) => _table[offset + _VALUE_INDEX];
   void _setValue(int offset, V value) { _table[offset + _VALUE_INDEX] = value; }
 
   _copyEntry(List oldTable, int fromOffset, int toOffset) {
     _table[toOffset + _VALUE_INDEX] = oldTable[fromOffset + _VALUE_INDEX];
   }
 }