Make EfficientLength public, as EfficientLengthIterable.

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 414 matching lines @@
 
 
 class _HashMapEntry {
   final key;
   var value;
   final int hashCode;
   _HashMapEntry next;
   _HashMapEntry(this.key, this.value, this.hashCode, this.next);
 }
 
-abstract class _HashMapIterable<E> extends IterableBase<E>
-                                   implements EfficientLength {
+abstract class _HashMapIterable<E> extends Iterable<E>
+                                   implements EfficientLengthIterable<E> {
   final HashMap _map;
   _HashMapIterable(this._map);
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }
 
 class _HashMapKeyIterable<K> extends _HashMapIterable<K> {
   _HashMapKeyIterable(HashMap map) : super(map);
   Iterator<K> get iterator => new _HashMapKeyIterator<K>(_map);
@@ skipping 381 matching lines @@
   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 IterableBase<K>
-                                   implements EfficientLength {
+class _LinkedHashMapKeyIterable<K> extends Iterable<K>
+                                   implements 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 IterableBase<V>
-                                     implements EfficientLength {
+class _LinkedHashMapValueIterable<V> extends Iterable<V>
+                                     implements 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> {
@@ skipping 114 matching lines @@
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
   /* patch */ factory LinkedHashSet.identity() =
       _CompactLinkedIdentityHashSet<E>;
 }