Move implementation from IterableBase to Iterable.

sdk/lib/collection/maps.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.
 
 part of dart.collection;
 
 /**
  * Base class for implementing a [Map].
  *
  * This class has a basic implementation of all but five of the members of
@@ skipping 93 matching lines @@
 abstract class UnmodifiableMapBase<K, V> =
     MapBase<K, V> with _UnmodifiableMapMixin<K, V>;
 
 /**
  * Implementation of [Map.values] based on the map and its [Map.keys] iterable.
  *
  * Iterable that iterates over the values of a `Map`.
  * It accesses the values by iterating over the keys of the map, and using the
  * map's `operator[]` to lookup the keys.
  */
-class _MapBaseValueIterable<V> extends IterableBase<V>
+class _MapBaseValueIterable<V> extends Iterable<V>
                                implements EfficientLength {
   final Map _map;
   _MapBaseValueIterable(this._map);
 
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
   V get first => _map[_map.keys.first];
   V get single => _map[_map.keys.single];
   V get last => _map[_map.keys.last];
@@ skipping 153 matching lines @@
    * or maps, the contained reference is rendered as [:'{...}':]. This
    * prevents the infinite regress that would otherwise occur. So, for example,
    * calling this method on a map whose sole entry maps the string key 'me'
    * to a reference to the map would return [:'{me: {...}}':].
    *
    * A typical implementation of a map's [toString] method will
    * simply return the results of this method applied to the collection.
    */
   static String mapToString(Map m) {
     // Reuse the list in IterableBase for detecting toString cycles.
-    if (IterableBase._isToStringVisiting(m)) { return '{...}'; }
+    if (_isToStringVisiting(m)) { return '{...}'; }
 
     var result = new StringBuffer();
     try {
-      IterableBase._toStringVisiting.add(m);
+      _toStringVisiting.add(m);
       result.write('{');
       bool first = true;
       m.forEach((k, v) {
         if(!first) {
           result.write(', ');
         }
         first = false;
         result.write(k);
         result.write(': ');
         result.write(v);
       });
       result.write('}');
     } finally {
-      assert(identical(IterableBase._toStringVisiting.last, m));
-      IterableBase._toStringVisiting.removeLast();
+      assert(identical(_toStringVisiting.last, m));
+      _toStringVisiting.removeLast();
     }
 
     return result.toString();
   }
 
   static _id(x) => x;
 
   /**
    * Fills a map with key/value pairs computed from [iterable].
    *
@@ skipping 26 matching lines @@
       map[keyIterator.current] = valueIterator.current;
       hasNextKey = keyIterator.moveNext();
       hasNextValue = valueIterator.moveNext();
     }
 
     if (hasNextKey || hasNextValue) {
       throw new ArgumentError("Iterables do not have same length.");
     }
   }
 }