fix doc comments in dart:io and collection types

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
  * [Map].
  * A basic `Map` class can be implemented by extending this class and
  * implementing `keys`, `operator[]`, `operator[]=`, `remove` and `clear`.
  * The remaining operations are implemented in terms of these five.
  *
- * The `keys` iterable should have efficient [length] and [contains]
- * operations, and it should catch concurrent modifications of the keys
- * while iterating.
+ * The `keys` iterable should have efficient [Iterable.length] and
+ * [Iterable.contains] operations, and it should catch concurrent modifications
+ * of the keys while iterating.
  *
  * A more efficient implementation is usually possible by overriding
  * some of the other members as well.
  */
 abstract class MapBase<K, V> = Object with MapMixin<K, V>;
 
 /**
  * Mixin implementing a [Map].
  *
  * This mixin has a basic implementation of all but five of the members of
  * [Map].
  * A basic `Map` class can be implemented by mixin in this class and
  * implementing `keys`, `operator[]`, `operator[]=`, `remove` and `clear`.
  * The remaining operations are implemented in terms of these five.
  *
- * The `keys` iterable should have efficient [length] and [contains]
- * operations, and it should catch concurrent modifications of the keys
- * while iterating.
+ * The `keys` iterable should have efficient [Iterable.length] and
+ * [Iterable.contains] operations, and it should catch concurrent modifications
+ * of the keys while iterating.
  *
  * A more efficient implementation is usually possible by overriding
  * some of the other members as well.
  */
 abstract class MapMixin<K, V> implements Map<K, V> {
   Iterable<K> get keys;
   V operator [](Object key);
   operator []=(K key, V value);
   V remove(Object key);
   // The `clear` operation should not be based on `remove`.
@@ skipping 39 matching lines @@
  *
  * 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[]`.
  *
  * Modifying operations throw when used.
  * The remaining non-modifying operations are implemented in terms of `keys`
  * and `operator[]`.
  *
- * The `keys` iterable should have efficient [length] and [contains]
- * operations, and it should catch concurrent modifications of the keys
- * while iterating.
+ * The `keys` iterable should have efficient [Iterable.length] and
+ * [Iterable.contains] operations, and it should catch concurrent modifications
+ * of the keys while iterating.
  *
  * A more efficient implementation is usually possible by overriding
  * some of the other members as well.
  */
 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.
  *
@@ skipping 257 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.");
     }
   }
 }