Update collection (list / map / iterable) printing.

tool/input_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 50 matching lines @@
   }
 
   bool containsValue(Object value) {
     for (K key in keys) {
       if (this[key] == value) return true;
     }
     return false;
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
-    if (keys.contains(key)) {
+    if (containsKey(key)) {
       return this[key];
     }
     return this[key] = ifAbsent();
   }
 
   bool containsKey(Object key) => keys.contains(key);
   int get length => keys.length;
   bool get isEmpty => keys.isEmpty;
   bool get isNotEmpty => keys.isNotEmpty;
-  Iterable<V> get values => new _MapBaseValueIterable<V>(this);
+  Iterable<V> get values => new _MapBaseValueIterable<K, V>(this);
   String toString() => Maps.mapToString(this);
 }
 
 /**
  * Basic implementation of an unmodifiable [Map].
  *
  * This class has a basic implementation of all but two of the members of
  * an umodifiable [Map].
  * A simple unmodifiable `Map` class can be implemented by extending this
  * class and implementing `keys` and `operator[]`.
@@ skipping 12 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>
-                               implements EfficientLength {
-  final Map _map;
+class _MapBaseValueIterable<K, V> extends Iterable<V>
+                                  implements EfficientLength {
+  final Map<K, V> _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];
 
-  Iterator<V> get iterator => new _MapBaseValueIterator<V>(_map);
+  Iterator<V> get iterator => new _MapBaseValueIterator<K, V>(_map);
 }
 
 /**
  * Iterator created by [_MapBaseValueIterable].
  *
  * Iterates over the values of a map by iterating its keys and lookup up the
  * values.
  */
-class _MapBaseValueIterator<V> implements Iterator<V> {
-  final Iterator _keys;
-  final Map _map;
+class _MapBaseValueIterator<K, V> implements Iterator<V> {
+  final Iterator<K> _keys;
+  final Map<K, V> _map;
   V _current = null;
 
-  _MapBaseValueIterator(Map map) : _map = map, _keys = map.keys.iterator;
+  _MapBaseValueIterator(Map<K, V> map)
+      : _map = map,
+        _keys = map.keys.iterator;
 
   bool moveNext() {
     if (_keys.moveNext()) {
       _current = _map[_keys.current];
       return true;
     }
     _current = null;
     return false;
   }
 
@@ skipping 60 matching lines @@
 class UnmodifiableMapView<K, V> =
     MapView<K, V> with _UnmodifiableMapMixin<K, V>;
 
 /**
  * Helper class which implements complex [Map] operations
  * in term of basic ones ([Map.keys], [Map.operator []],
  * [Map.operator []=] and [Map.remove].)  Not all methods are
  * necessary to implement each particular operation.
  */
 class Maps {
-  static bool containsValue(Map map, value) {
+  static bool containsValue(Map map, Object value) {
     for (final v in map.values) {
-      if (value == v) {
+      if (v == value) {
         return true;
       }
     }
     return false;
   }
 
-  static bool containsKey(Map map, key) {
+  static bool containsKey(Map map, Object key) {
     for (final k in map.keys) {
-      if (key == k) {
+      if (k == key) {
         return true;
       }
     }
     return false;
   }
 
   static putIfAbsent(Map map, key, ifAbsent()) {
     if (map.containsKey(key)) {
       return map[key];
     }
@@ skipping 35 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.");
     }
   }
 }