add checks needed for covariant generics, and List<E>

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (ListIterator$(E))(this);
       }
       [core.$forEach](action) {
+        dart.as(action, dart.functionType(dart.void, [E]));
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           action(this[core.$elementAt](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
@@ skipping 20 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (dart.equals(this[core.$elementAt](i), element))
             return true;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return false;
       }
       [core.$every](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (!dart.notNull(test(this[core.$elementAt](i))))
             return false;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return true;
       }
       [core.$any](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (test(this[core.$elementAt](i)))
             return true;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return false;
       }
       [core.$firstWhere](test, opts) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = this[core.$elementAt](i);
           if (test(element))
             return element;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       [core.$lastWhere](test, opts) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         let length = this[core.$length];
         for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           let element = this[core.$elementAt](i);
           if (test(element))
             return element;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       [core.$singleWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let length = this[core.$length];
         let match = null;
         let matchFound = false;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = this[core.$elementAt](i);
           if (test(element)) {
             if (matchFound) {
               throw IterableElementError.tooMany();
             }
             matchFound = true;
@@ skipping 32 matching lines @@
           for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
             buffer.write(this[core.$elementAt](i));
             if (length != this[core.$length]) {
               throw new core.ConcurrentModificationError(this);
             }
           }
           return dart.toString(buffer);
         }
       }
       [core.$where](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return super[core.$where](test);
       }
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new MappedListIterable(this, f);
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [dart.dynamic, E]));
         let length = this[core.$length];
         if (length == 0)
           throw IterableElementError.noElement();
         let value = this[core.$elementAt](0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = dart.dcall(combine, value, this[core.$elementAt](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = dart.dcall(combine, value, this[core.$elementAt](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       [core.$skip](count) {
         return new (SubListIterable$(E))(this, count, null);
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return super[core.$skipWhile](test);
       }
       [core.$take](count) {
         return new (SubListIterable$(E))(this, 0, count);
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return super[core.$takeWhile](test);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
           result = new (core.List$(E))();
           result[core.$length] = this[core.$length];
         } else {
           result = new (core.List$(E))(this[core.$length]);
@@ skipping 545 matching lines @@
   });
   let SkipWhileIterator = SkipWhileIterator$();
   let EmptyIterable$ = dart.generic(function(E) {
     class EmptyIterable extends collection.IterableBase$(E) {
       EmptyIterable() {
         super.IterableBase();
       }
       get [core.$iterator]() {
         return dart.const(new (EmptyIterator$(E))());
       }
-      [core.$forEach](action) {}
+      [core.$forEach](action) {
+        dart.as(action, dart.functionType(dart.void, [E]));
+      }
       get [core.$isEmpty]() {
         return true;
       }
       get [core.$length]() {
         return 0;
       }
       get [core.$first]() {
         throw IterableElementError.noElement();
       }
       get [core.$last]() {
         throw IterableElementError.noElement();
       }
       get [core.$single]() {
         throw IterableElementError.noElement();
       }
       [core.$elementAt](index) {
         throw new core.RangeError.range(index, 0, 0, "index");
       }
       [core.$contains](element) {
         return false;
       }
       [core.$every](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return true;
       }
       [core.$any](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return false;
       }
       [core.$firstWhere](test, opts) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       [core.$lastWhere](test, opts) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       [core.$singleWhere](test, opts) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
         return "";
       }
       [core.$where](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return this;
       }
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return dart.const(new EmptyIterable());
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         throw IterableElementError.noElement();
       }
       [core.$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         return initialValue;
       }
       [core.$skip](count) {
         core.RangeError.checkNotNegative(count, "count");
         return this;
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return this;
       }
       [core.$take](count) {
         core.RangeError.checkNotNegative(count, "count");
         return this;
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return this;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return growable ? dart.setType([], core.List$(E)) : new (core.List$(E))(0);
       }
       [core.$toSet]() {
         return new (core.Set$(E))();
       }
     }
@@ skipping 25 matching lines @@
   let IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       static forEach(iterable, f) {
+        dart.as(f, dart.functionType(dart.void, [dart.dynamic]));
         for (let e of iterable) {
           dart.dcall(f, e);
         }
       }
       static any(iterable, f) {
+        dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
         for (let e of iterable) {
           if (dart.dcall(f, e))
             return true;
         }
         return false;
       }
       static every(iterable, f) {
+        dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
         for (let e of iterable) {
           if (!dart.notNull(dart.dcall(f, e)))
             return false;
         }
         return true;
       }
       static reduce(iterable, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
         let iterator = iterable[core.$iterator];
         if (!dart.notNull(iterator.moveNext()))
           throw IterableElementError.noElement();
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = dart.dcall(combine, value, iterator.current);
         }
         return value;
       }
       static fold(iterable, initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
         for (let element of iterable) {
           initialValue = dart.dcall(combine, initialValue, element);
         }
         return initialValue;
       }
       static removeWhereList(list, test) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let retained = [];
         let length = list[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = list[core.$get](i);
           if (!dart.notNull(dart.dcall(test, element))) {
             retained[core.$add](element);
           }
           if (length != list[core.$length]) {
             throw new core.ConcurrentModificationError(list);
           }
@@ skipping 29 matching lines @@
       static single(iterable) {
         let it = iterable[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw IterableElementError.noElement();
         let result = it.current;
         if (it.moveNext())
           throw IterableElementError.tooMany();
         return result;
       }
       static firstWhere(iterable, test, orElse) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
+        dart.as(orElse, dart.functionType(dart.dynamic, []));
         for (let element of iterable) {
           if (dart.dcall(test, element))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       static lastWhere(iterable, test, orElse) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
+        dart.as(orElse, dart.functionType(dart.dynamic, []));
         let result = null;
         let foundMatching = false;
         for (let element of iterable) {
           if (dart.dcall(test, element)) {
             result = element;
             foundMatching = true;
           }
         }
         if (foundMatching)
           return result;
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       static lastWhereList(list, test, orElse) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
+        dart.as(orElse, dart.functionType(dart.dynamic, []));
         for (let i = dart.notNull(list[core.$length]) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           let element = list[core.$get](i);
           if (dart.dcall(test, element))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       static singleWhere(iterable, test) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let result = null;
         let foundMatching = false;
         for (let element of iterable) {
           if (dart.dcall(test, element)) {
             if (foundMatching) {
               throw IterableElementError.tooMany();
             }
             result = element;
             foundMatching = true;
           }
@@ skipping 36 matching lines @@
         } else {
           buffer.write(list[core.$get](0));
           for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
             buffer.write(separator);
             buffer.write(list[core.$get](i));
           }
         }
         return dart.toString(buffer);
       }
       where(iterable, f) {
+        dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
         return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, __CastType6));
       }
       static map(iterable, f) {
+        dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         return new MappedIterable(iterable, f);
       }
       static mapList(list, f) {
+        dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         return new MappedListIterable(list, f);
       }
       static expand(iterable, f) {
+        dart.as(f, dart.functionType(core.Iterable, [dart.dynamic]));
         return new ExpandIterable(iterable, f);
       }
       takeList(list, n) {
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), 0, n);
       }
       takeWhile(iterable, test) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       skipList(list, n) {
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), n, null);
       }
       skipWhile(iterable, test) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       reversedList(list) {
         return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));
       }
       static sortList(list, compare) {
+        dart.as(compare, dart.functionType(core.int, [dart.dynamic, dart.dynamic]));
         if (compare == null)
           compare = dart.bind(core.Comparable, 'compare');
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
         if (random == null)
           random = new math.Random();
         let length = list[core.$length];
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
@@ skipping 170 matching lines @@
     let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(core.bool, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
   let FixedLengthListMixin$ = dart.generic(function(E) {
     class FixedLengthListMixin extends core.Object {
       set length(newLength) {
         throw new core.UnsupportedError("Cannot change the length of a fixed-length list");
       }
       add(value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       insert(index, value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       insertAll(at, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       addAll(iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       remove(element) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       removeWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       retainWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       clear() {
         throw new core.UnsupportedError("Cannot clear a fixed-length list");
       }
       removeAt(index) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       removeLast() {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       removeRange(start, end) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       replaceRange(start, end, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
     }
     return FixedLengthListMixin;
   });
   let FixedLengthListMixin = FixedLengthListMixin$();
   let UnmodifiableListMixin$ = dart.generic(function(E) {
     class UnmodifiableListMixin extends core.Object {
       [core.$set](index, value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       set [core.$length](newLength) {
         throw new core.UnsupportedError("Cannot change the length of an unmodifiable list");
       }
       [core.$setAll](at, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       [core.$add](value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot add to an unmodifiable list");
       }
       [core.$insert](index, value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot add to an unmodifiable list");
       }
       [core.$insertAll](at, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot add to an unmodifiable list");
       }
       [core.$addAll](iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot add to an unmodifiable list");
       }
       [core.$remove](element) {
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$removeWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$retainWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$sort](compare) {
         if (compare === void 0)
           compare = null;
+        dart.as(compare, core.Comparator$(E));
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       [core.$shuffle](random) {
         if (random === void 0)
           random = null;
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       [core.$clear]() {
         throw new core.UnsupportedError("Cannot clear an unmodifiable list");
       }
       [core.$removeAt](index) {
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$removeLast]() {
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$setRange](start, end, iterable, skipCount) {
+        dart.as(iterable, core.Iterable$(E));
         if (skipCount === void 0)
           skipCount = 0;
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       [core.$removeRange](start, end) {
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$replaceRange](start, end, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       [core.$fillRange](start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
+        dart.as(fillValue, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
     }
     UnmodifiableListMixin[dart.implements] = () => [core.List$(E)];
     return UnmodifiableListMixin;
   });
   let UnmodifiableListMixin = UnmodifiableListMixin$();
   let FixedLengthListBase$ = dart.generic(function(E) {
     class FixedLengthListBase extends dart.mixin(collection.ListBase$(E), FixedLengthListMixin$(E)) {}
     return FixedLengthListBase;
@@ skipping 42 matching lines @@
       get isNotEmpty() {
         return this[_values][core.$isNotEmpty];
       }
       containsValue(value) {
         return this[_values][core.$contains](value);
       }
       containsKey(key) {
         return typeof key == 'number' && dart.notNull(key) >= 0 && dart.notNull(key) < dart.notNull(this.length);
       }
       forEach(f) {
+        dart.as(f, dart.functionType(dart.void, [core.int, E]));
         let length = this[_values][core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(i, this[_values][core.$get](i));
           if (length != this[_values][core.$length]) {
             throw new core.ConcurrentModificationError(this[_values]);
           }
         }
       }
       set(key, value) {
+        dart.as(value, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(ifAbsent, dart.functionType(E, []));
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       remove(key) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       clear() {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       addAll(other) {
+        dart.as(other, core.Map$(core.int, E));
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
     ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
     return ListMapView;
   });
   let ListMapView = ListMapView$();
@@ skipping 492 matching lines @@
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal || (_internal = {}));