Make dart:collection strong-mode clean.

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 60 matching lines @@
     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 Iterable<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 193 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.");
     }
   }
 }