Make dart:core strong-mode clean.

sdk/lib/core/iterable.dart

 // Copyright (c) 2011, 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.core;
 
 /**
  * A collection of values, or "elements", that can be accessed sequentially.
  *
  * The elements of the iterable are accessed by getting an [Iterator]
@@ skipping 433 matching lines @@
   }
 
   /**
    * Returns the first element.
    *
    * Throws a [StateError] if `this` is empty.
    * Otherwise returs the first element in the iteration order,
    * equivalent to `(iterator..moveNext())..current`.
    */
   E get first {
-    Iterator it = iterator;
+    Iterator<E> it = iterator;
     if (!it.moveNext()) {
       throw IterableElementError.noElement();
     }
     return it.current;
   }
 
   /**
    * Returns the last element.
    *
    * Throws a [StateError] if `this` is empty.
    * Otherwise may iterate through the elements and returns the last one
    * seen.
    * Some iterables may have more efficient ways to find the last element
    * (for example a list can directly access the last element,
    * without iterating through the previous ones).
    */
   E get last {
-    Iterator it = iterator;
+    Iterator<E> it = iterator;
     if (!it.moveNext()) {
       throw IterableElementError.noElement();
     }
     E result;
     do {
       result = it.current;
     } while(it.moveNext());
     return result;
   }
 
   /**
    * Checks that this iterable has only one element, and returns that element.
    *
    * Throws a [StateError] if `this` is empty or has more than one element.
    */
   E get single {
-    Iterator it = iterator;
+    Iterator<E> it = iterator;
     if (!it.moveNext()) throw IterableElementError.noElement();
     E result = it.current;
     if (it.moveNext()) throw IterableElementError.tooMany();
     return result;
   }
 
   /**
    * Returns the first element that satisfies the given predicate [test].
    *
    * Iterates through elements and returns the first to satsify [test].
@@ skipping 103 matching lines @@
   String toString() => IterableBase.iterableToShortString(this, '(', ')');
 }
 
 typedef E _Generator<E>(int index);
 
 class _GeneratorIterable<E> extends Iterable<E>
                             implements EfficientLength {
   final int _start;
   final int _end;
   final _Generator<E> _generator;
+
+  /// Creates an iterable that builds the elements from a generator function.
+  ///
+  /// The [generator] may be null, in which case the default generator
+  /// enumerating the integer positions is used. This means that [int] must
+  /// be assignable to [E] when no generator is provided. In practice this means
+  /// that the generator can only be emitted when [E] is equal to `dynamic`,
+  /// `int`, or `num`. The constructor will check that the types match.
   _GeneratorIterable(this._end, E generator(int n))
       : _start = 0,
-        _generator = (generator != null) ? generator : _id;
+        // The `as` below is used as check to make sure that `int` is assignable
+        // to [E].
+        _generator = (generator != null) ? generator : _id as _Generator<E>;
 
   _GeneratorIterable.slice(this._start, this._end, this._generator);
 
   Iterator<E> get iterator =>
       new _GeneratorIterator<E>(_start, _end, _generator);
   int get length => _end - _start;
 
   Iterable<E> skip(int count) {
     RangeError.checkNotNegative(count, "count");
     if (count == 0) return this;
@@ skipping 40 matching lines @@
  */
 abstract class BidirectionalIterator<E> implements Iterator<E> {
   /**
    * Move back to the previous element.
    *
    * Returns true and updates [current] if successful. Returns false
    * and sets [current] to null if there is no previous element.
    */
   bool movePrevious();
 }