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

lib/runtime/dart/collection.js

 var collection;
 (function(exports) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
       }
       get [core.$length]() {
@@ skipping 101 matching lines @@
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
       }
       get [core.$isNotEmpty]() {
         return this[core.$length] != 0;
       }
       clear() {
         this.removeAll(this[core.$toList]());
       }
       addAll(elements) {
+        dart.as(elements, core.Iterable$(E));
         for (let element of elements)
           this.add(element);
       }
       removeAll(elements) {
         for (let element of elements)
           this.remove(element);
       }
       retainAll(elements) {
         let toRemove = this[core.$toSet]();
         for (let o of elements) {
           toRemove.remove(o);
         }
         this.removeAll(toRemove);
       }
       removeWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let toRemove = [];
         for (let element of this) {
           if (test(element))
             toRemove[core.$add](element);
         }
         this.removeAll(toRemove);
       }
       retainWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let toRemove = [];
         for (let element of this) {
           if (!dart.notNull(test(element)))
             toRemove[core.$add](element);
         }
         this.removeAll(toRemove);
       }
       containsAll(other) {
         for (let o of other) {
           if (!dart.notNull(this[core.$contains](o)))
             return false;
         }
         return true;
       }
       union(other) {
+        dart.as(other, core.Set$(E));
         let _ = this[core.$toSet]();
         _.addAll(other);
         return _;
       }
       intersection(other) {
         let result = this[core.$toSet]();
         for (let element of this) {
           if (!dart.notNull(other[core.$contains](element)))
             result.remove(element);
         }
@@ skipping 17 matching lines @@
         let i = 0;
         for (let element of this)
           result[core.$set]((() => {
             let x = i;
             i = dart.notNull(x) + 1;
             return x;
           })(), element);
         return result;
       }
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new (_internal.EfficientLengthMappedIterable$(E, dart.dynamic))(this, f);
       }
       get [core.$single]() {
         if (dart.notNull(this[core.$length]) > 1)
           throw _internal.IterableElementError.tooMany();
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         return result;
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
       [core.$where](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
+        dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       [core.$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext()))
           return "";
         let buffer = new core.StringBuffer();
         if (separator == null || separator == "") {
           do {
             buffer.write(`${iterator.current}`);
           } while (iterator.moveNext());
         } else {
           buffer.write(`${iterator.current}`);
           while (iterator.moveNext()) {
             buffer.write(separator);
             buffer.write(`${iterator.current}`);
           }
         }
         return dart.toString(buffer);
       }
       [core.$any](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (test(element))
             return true;
         }
         return false;
       }
       [core.$take](n) {
         return new (_internal.TakeIterable$(E))(this, n);
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let result = null;
         do {
           result = dart.as(it.current, E);
         } while (it.moveNext());
         return result;
       }
       [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, []));
         for (let element of this) {
           if (test(element))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw _internal.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 result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             result = element;
             foundMatching = true;
           }
         }
         if (foundMatching)
           return result;
         if (orElse != null)
           return orElse();
         throw _internal.IterableElementError.noElement();
       }
       [core.$singleWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             if (foundMatching) {
               throw _internal.IterableElementError.tooMany();
             }
             result = element;
             foundMatching = true;
           }
@@ skipping 109 matching lines @@
   });
   let __CastType5 = __CastType5$();
   let __CastType7$ = dart.generic(function(E) {
     let __CastType7 = dart.typedef('__CastType7', () => dart.functionType(core.bool, [E, E]));
     return __CastType7;
   });
   let __CastType7 = __CastType7$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new (_internal.MappedIterable$(E, dart.dynamic))(this, f);
       }
       [core.$where](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
+        dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       [core.$contains](element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       [core.$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext()))
           return "";
         let buffer = new core.StringBuffer();
         if (separator == null || separator == "") {
           do {
             buffer.write(`${iterator.current}`);
           } while (iterator.moveNext());
         } else {
           buffer.write(`${iterator.current}`);
           while (iterator.moveNext()) {
             buffer.write(separator);
             buffer.write(`${iterator.current}`);
           }
         }
         return dart.toString(buffer);
       }
       [core.$any](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return new core.List$(E).from(this, {growable: growable});
       }
@@ skipping 12 matching lines @@
       get [core.$isEmpty]() {
         return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
         return new (_internal.TakeIterable$(E))(this, n);
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
@@ skipping 10 matching lines @@
       get [core.$single]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         if (it.moveNext())
           throw _internal.IterableElementError.tooMany();
         return result;
       }
       [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, []));
         for (let element of this) {
           if (test(element))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw _internal.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 result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             result = element;
             foundMatching = true;
           }
         }
         if (foundMatching)
           return result;
         if (orElse != null)
           return orElse();
         throw _internal.IterableElementError.noElement();
       }
       [core.$singleWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             if (foundMatching) {
               throw _internal.IterableElementError.tooMany();
             }
             result = element;
             foundMatching = true;
           }
@@ skipping 20 matching lines @@
     }
     IterableMixin[dart.implements] = () => [core.Iterable$(E)];
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new (_internal.MappedIterable$(E, dart.dynamic))(this, f);
       }
       [core.$where](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
+        dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       [core.$contains](element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       [core.$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext()))
           return "";
         let buffer = new core.StringBuffer();
         if (separator == null || separator == "") {
           do {
             buffer.write(`${iterator.current}`);
           } while (iterator.moveNext());
         } else {
           buffer.write(`${iterator.current}`);
           while (iterator.moveNext()) {
             buffer.write(separator);
             buffer.write(`${iterator.current}`);
           }
         }
         return dart.toString(buffer);
       }
       [core.$any](f) {
+        dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return new core.List$(E).from(this, {growable: growable});
       }
@@ skipping 12 matching lines @@
       get [core.$isEmpty]() {
         return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
         return new (_internal.TakeIterable$(E))(this, n);
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
@@ skipping 10 matching lines @@
       get [core.$single]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         if (it.moveNext())
           throw _internal.IterableElementError.tooMany();
         return result;
       }
       [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, []));
         for (let element of this) {
           if (test(element))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw _internal.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 result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             result = element;
             foundMatching = true;
           }
         }
         if (foundMatching)
           return result;
         if (orElse != null)
           return orElse();
         throw _internal.IterableElementError.noElement();
       }
       [core.$singleWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let result = null;
         let foundMatching = false;
         for (let element of this) {
           if (test(element)) {
             if (foundMatching) {
               throw _internal.IterableElementError.tooMany();
             }
             result = element;
             foundMatching = true;
           }
@@ skipping 340 matching lines @@
     class LinkedList extends IterableBase$(E) {
       LinkedList() {
         this[_modificationCount] = 0;
         this[_length] = 0;
         this[_next] = null;
         this[_previous] = null;
         super.IterableBase();
         this[_next] = this[_previous] = this;
       }
       addFirst(entry) {
+        dart.as(entry, E);
         this[_insertAfter](this, entry);
       }
       add(entry) {
+        dart.as(entry, E);
         this[_insertAfter](this[_previous], entry);
       }
       addAll(entries) {
+        dart.as(entries, core.Iterable$(E));
         entries[core.$forEach]((entry => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this));
       }
       remove(entry) {
+        dart.as(entry, E);
         if (!dart.equals(entry[_list], this))
           return false;
         this[_unlink](entry);
         return true;
       }
       get [core.$iterator]() {
         return new (_LinkedListIterator$(E))(this);
       }
       get [core.$length]() {
         return this[_length];
@@ skipping 24 matching lines @@
       get [core.$single]() {
         if (core.identical(this[_previous], this)) {
           throw new core.StateError('No such element');
         }
         if (!dart.notNull(core.identical(this[_previous], this[_next]))) {
           throw new core.StateError('Too many elements');
         }
         return dart.as(this[_next], E);
       }
       [core.$forEach](action) {
+        dart.as(action, dart.functionType(dart.void, [E]));
         let modificationCount = this[_modificationCount];
         let current = this[_next];
         while (!dart.notNull(core.identical(current, this))) {
           action(dart.as(current, E));
           if (modificationCount != this[_modificationCount]) {
             throw new core.ConcurrentModificationError(this);
           }
           current = current[_next];
         }
       }
       get [core.$isEmpty]() {
         return this[_length] == 0;
       }
       [_insertAfter](entry, newEntry) {
+        dart.as(newEntry, E);
         if (newEntry.list != null) {
           throw new core.StateError('LinkedListEntry is already in a LinkedList');
         }
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         newEntry[_list] = this;
         let predecessor = entry;
         let successor = entry[_next];
         successor[_previous] = newEntry;
         newEntry[_previous] = predecessor;
         newEntry[_next] = successor;
         predecessor[_next] = newEntry;
         this[_length] = dart.notNull(this[_length]) + 1;
       }
       [_unlink](entry) {
+        dart.as(entry, LinkedListEntry$(E));
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         entry[_next][_previous] = entry[_previous];
         entry[_previous][_next] = entry[_next];
         this[_length] = dart.notNull(this[_length]) - 1;
         entry[_list] = entry[_next] = entry[_previous] = null;
       }
     }
     LinkedList[dart.implements] = () => [_LinkedListLink];
     return LinkedList;
   });
@@ skipping 51 matching lines @@
           return null;
         let result = dart.as(this[_next], E);
         return result;
       }
       get previous() {
         if (core.identical(this[_previous], this[_list]))
           return null;
         return dart.as(this[_previous], E);
       }
       insertAfter(entry) {
+        dart.as(entry, E);
         this[_list][_insertAfter](this, entry);
       }
       insertBefore(entry) {
+        dart.as(entry, E);
         this[_list][_insertAfter](this[_previous], entry);
       }
     }
     LinkedListEntry[dart.implements] = () => [_LinkedListLink];
     return LinkedListEntry;
   });
   let LinkedListEntry = LinkedListEntry$();
   let ListMixin$ = dart.generic(function(E) {
     class ListMixin extends core.Object {
       get [core.$iterator]() {
         return new (_internal.ListIterator$(E))(this);
       }
       [core.$elementAt](index) {
         return this[core.$get](index);
       }
       [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.$get](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
@@ skipping 23 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           if (dart.equals(this[core.$get](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.$get](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.$get](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.$get](i);
           if (test(element))
             return element;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (orElse != null)
           return orElse();
         throw _internal.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.$get](i);
           if (test(element))
             return element;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (orElse != null)
           return orElse();
         throw _internal.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.$get](i);
           if (test(element)) {
             if (matchFound) {
               throw _internal.IterableElementError.tooMany();
             }
             matchFound = true;
@@ skipping 10 matching lines @@
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
         if (this[core.$length] == 0)
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
       [core.$where](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, test);
       }
       [core.$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new _internal.MappedListIterable(this, f);
       }
       [core.$expand](f) {
+        dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       [core.$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         let length = this[core.$length];
         if (length == 0)
           throw _internal.IterableElementError.noElement();
         let value = this[core.$get](0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = combine(value, this[core.$get](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.$get](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       [core.$skip](count) {
         return new (_internal.SubListIterable$(E))(this, count, null);
       }
       [core.$skipWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       [core.$take](count) {
         return new (_internal.SubListIterable$(E))(this, 0, count);
       }
       [core.$takeWhile](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, 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]);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[core.$get](i));
         }
         return result;
       }
       [core.$toSet]() {
         let result = new (core.Set$(E))();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$get](i));
         }
         return result;
       }
       [core.$add](element) {
+        dart.as(element, E);
         this[core.$set]((() => {
           let o = this, x = o[core.$length];
           o[core.$length] = dart.notNull(x) + 1;
           return x;
         }).bind(this)(), element);
       }
       [core.$addAll](iterable) {
+        dart.as(iterable, core.Iterable$(E));
         for (let element of iterable) {
           this[core.$set]((() => {
             let o = this, x = o[core.$length];
             o[core.$length] = dart.notNull(x) + 1;
             return x;
           }).bind(this)(), element);
         }
       }
       [core.$remove](element) {
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           if (dart.equals(this[core.$get](i), element)) {
             this[core.$setRange](i, dart.notNull(this[core.$length]) - 1, this, dart.notNull(i) + 1);
             let o = this;
             o[core.$length] = dart.notNull(o[core.$length]) - 1;
             return true;
           }
         }
         return false;
       }
       [core.$removeWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin._filter(this, test, false);
       }
       [core.$retainWhere](test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin._filter(this, test, true);
       }
       static _filter(source, test, retainMatching) {
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let retained = [];
         let length = source[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source[core.$get](i);
           if (dart.dcall(test, element) == retainMatching) {
             retained[core.$add](element);
           }
           if (length != source[core.$length]) {
             throw new core.ConcurrentModificationError(source);
           }
@@ skipping 10 matching lines @@
         if (this[core.$length] == 0) {
           throw _internal.IterableElementError.noElement();
         }
         let result = this[core.$get](dart.notNull(this[core.$length]) - 1);
         this[core.$length] = dart.notNull(this[core.$length]) - 1;
         return result;
       }
       [core.$sort](compare) {
         if (compare === void 0)
           compare = null;
+        dart.as(compare, dart.functionType(core.int, [E, E]));
         if (compare == null) {
           let defaultCompare = dart.bind(core.Comparable, 'compare');
           compare = defaultCompare;
         }
         _internal.Sort.sort(this, compare);
       }
       [core.$shuffle](random) {
         if (random === void 0)
           random = null;
         if (random == null)
@@ skipping 32 matching lines @@
       [core.$removeRange](start, end) {
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         let length = dart.notNull(end) - dart.notNull(start);
         this[core.$setRange](start, dart.notNull(this[core.$length]) - dart.notNull(length), this, end);
         let o = this;
         o[core.$length] = dart.notNull(o[core.$length]) - dart.notNull(length);
       }
       [core.$fillRange](start, end, fill) {
         if (fill === void 0)
           fill = null;
+        dart.as(fill, E);
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           this[core.$set](i, fill);
         }
       }
       [core.$setRange](start, end, iterable, skipCount) {
+        dart.as(iterable, core.Iterable$(E));
         if (skipCount === void 0)
           skipCount = 0;
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         let length = dart.notNull(end) - dart.notNull(start);
         if (length == 0)
           return;
         core.RangeError.checkNotNegative(skipCount, "skipCount");
         let otherList = null;
         let otherStart = null;
         if (dart.is(iterable, core.List)) {
@@ skipping 10 matching lines @@
           for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
             this[core.$set](dart.notNull(start) + dart.notNull(i), dart.as(otherList[core.$get](dart.notNull(otherStart) + dart.notNull(i)), E));
           }
         } else {
           for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
             this[core.$set](dart.notNull(start) + dart.notNull(i), dart.as(otherList[core.$get](dart.notNull(otherStart) + dart.notNull(i)), E));
           }
         }
       }
       [core.$replaceRange](start, end, newContents) {
+        dart.as(newContents, core.Iterable$(E));
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         if (!dart.is(newContents, _internal.EfficientLength)) {
           newContents = newContents[core.$toList]();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
         let insertLength = newContents[core.$length];
         if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
           let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           let newLength = dart.notNull(this[core.$length]) - dart.notNull(delta);
@@ skipping 41 matching lines @@
           }
         }
         for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           if (dart.equals(this[core.$get](i), element)) {
             return i;
           }
         }
         return -1;
       }
       [core.$insert](index, element) {
+        dart.as(element, E);
         core.RangeError.checkValueInInterval(index, 0, this[core.$length], "index");
         if (index == this[core.$length]) {
           this[core.$add](element);
           return;
         }
         if (!(typeof index == 'number'))
           throw new core.ArgumentError(index);
         let o = this;
         o[core.$length] = dart.notNull(o[core.$length]) + 1;
         this[core.$setRange](dart.notNull(index) + 1, this[core.$length], this, index);
         this[core.$set](index, element);
       }
       [core.$removeAt](index) {
         let result = this[core.$get](index);
         this[core.$setRange](index, dart.notNull(this[core.$length]) - 1, this, dart.notNull(index) + 1);
         this[core.$length] = dart.notNull(this[core.$length]) - 1;
         return result;
       }
       [core.$insertAll](index, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         core.RangeError.checkValueInInterval(index, 0, this[core.$length], "index");
         if (dart.is(iterable, _internal.EfficientLength)) {
           iterable = iterable[core.$toList]();
         }
         let insertionLength = iterable[core.$length];
         let o = this;
         o[core.$length] = dart.notNull(o[core.$length]) + dart.notNull(insertionLength);
         this[core.$setRange](dart.notNull(index) + dart.notNull(insertionLength), this[core.$length], this, index);
         this[core.$setAll](index, iterable);
       }
       [core.$setAll](index, iterable) {
+        dart.as(iterable, core.Iterable$(E));
         if (dart.is(iterable, core.List)) {
           this[core.$setRange](index, dart.notNull(index) + dart.notNull(iterable[core.$length]), iterable);
         } else {
           for (let element of iterable) {
             this[core.$set]((() => {
               let x = index;
               index = dart.notNull(x) + 1;
               return x;
             })(), element);
           }
@@ skipping 15 matching lines @@
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
     return ListBase;
   });
   let ListBase = ListBase$();
   let MapMixin$ = dart.generic(function(K, V) {
     class MapMixin extends core.Object {
       forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
         for (let key of this.keys) {
           action(key, this.get(key));
         }
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         for (let key of other.keys) {
           this.set(key, other.get(key));
         }
       }
       containsValue(value) {
+        dart.as(value, V);
         for (let key of this.keys) {
           if (dart.equals(this.get(key), value))
             return true;
         }
         return false;
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         if (this.keys[core.$contains](key)) {
           return this.get(key);
         }
         return this.set(key, ifAbsent());
       }
       containsKey(key) {
         return this.keys[core.$contains](key);
       }
       get length() {
         return this.keys[core.$length];
@@ skipping 16 matching lines @@
   });
   let MapMixin = MapMixin$();
   let MapBase$ = dart.generic(function(K, V) {
     class MapBase extends dart.mixin(core.Object, MapMixin$(K, V)) {}
     return MapBase;
   });
   let MapBase = MapBase$();
   let _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
     class _UnmodifiableMapMixin extends core.Object {
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       clear() {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       remove(key) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
     }
     _UnmodifiableMapMixin[dart.implements] = () => [core.Map$(K, V)];
     return _UnmodifiableMapMixin;
   });
   let _UnmodifiableMapMixin = _UnmodifiableMapMixin$();
   let UnmodifiableMapBase$ = dart.generic(function(K, V) {
     class UnmodifiableMapBase extends dart.mixin(MapBase$(K, V), _UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapBase;
@@ skipping 58 matching lines @@
   let _MapBaseValueIterator = _MapBaseValueIterator$();
   let MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
       get(key) {
         return this[_map].get(key);
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         this[_map].set(key, value);
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         this[_map].addAll(other);
       }
       clear() {
         this[_map].clear();
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         return this[_map].putIfAbsent(key, ifAbsent);
       }
       containsKey(key) {
         return this[_map].containsKey(key);
       }
       containsValue(value) {
         return this[_map].containsValue(value);
       }
       forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
         this[_map].forEach(action);
       }
       get isEmpty() {
         return this[_map].isEmpty;
       }
       get isNotEmpty() {
         return this[_map].isNotEmpty;
       }
       get length() {
         return this[_map].length;
@@ skipping 137 matching lines @@
   let _link = Symbol('_link');
   let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
   let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
         this[_previous] = null;
         this[_next] = null;
       }
       [_link](previous, next) {
+        dart.as(previous, DoubleLinkedQueueEntry$(E));
+        dart.as(next, DoubleLinkedQueueEntry$(E));
         this[_next] = next;
         this[_previous] = previous;
         previous[_next] = this;
         next[_previous] = this;
       }
       append(e) {
+        dart.as(e, E);
         new (DoubleLinkedQueueEntry$(E))(e)[_link](this, this[_next]);
       }
       prepend(e) {
+        dart.as(e, E);
         new (DoubleLinkedQueueEntry$(E))(e)[_link](this[_previous], this);
       }
       remove() {
         this[_previous][_next] = this[_next];
         this[_next][_previous] = this[_previous];
         this[_next] = null;
         this[_previous] = null;
         return this[_element];
       }
       [_asNonSentinelEntry]() {
         return this;
       }
       previousEntry() {
         return this[_previous][_asNonSentinelEntry]();
       }
       nextEntry() {
         return this[_next][_asNonSentinelEntry]();
       }
       get element() {
         return this[_element];
       }
       set element(e) {
+        dart.as(e, E);
         this[_element] = e;
       }
     }
     return DoubleLinkedQueueEntry;
   });
   let DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$();
   let _DoubleLinkedQueueEntrySentinel$ = dart.generic(function(E) {
     class _DoubleLinkedQueueEntrySentinel extends DoubleLinkedQueueEntry$(E) {
       _DoubleLinkedQueueEntrySentinel() {
         super.DoubleLinkedQueueEntry(null);
         this[_link](this, this);
       }
       remove() {
         throw _internal.IterableElementError.noElement();
       }
       [_asNonSentinelEntry]() {
         return null;
       }
       set element(e) {
+        dart.as(e, E);
         dart.assert(false);
       }
       get element() {
         throw _internal.IterableElementError.noElement();
       }
     }
     return _DoubleLinkedQueueEntrySentinel;
   });
   let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
   let _sentinel = Symbol('_sentinel');
@@ skipping 11 matching lines @@
         let list = new (DoubleLinkedQueue$(E))();
         for (let e of dart.as(elements, core.Iterable$(E))) {
           list.addLast(e);
         }
         return dart.as(list, DoubleLinkedQueue$(E));
       }
       get [core.$length]() {
         return this[_elementCount];
       }
       addLast(value) {
+        dart.as(value, E);
         this[_sentinel].prepend(value);
         this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
       }
       addFirst(value) {
+        dart.as(value, E);
         this[_sentinel].append(value);
         this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
       }
       add(value) {
+        dart.as(value, E);
         this[_sentinel].prepend(value);
         this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
       }
       addAll(iterable) {
+        dart.as(iterable, core.Iterable$(E));
         for (let value of iterable) {
           this[_sentinel].prepend(value);
           this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
         }
       }
       removeLast() {
         let result = this[_sentinel][_previous].remove();
         this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
         return result;
       }
       removeFirst() {
         let result = this[_sentinel][_next].remove();
         this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
         return result;
       }
       remove(o) {
         let entry = this[_sentinel][_next];
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           if (dart.equals(entry.element, o)) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
             return true;
           }
           entry = entry[_next];
         }
         return false;
       }
       [_filter](test, removeMatching) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let entry = this[_sentinel][_next];
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           let next = entry[_next];
           if (core.identical(removeMatching, test(entry.element))) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
           }
           entry = next;
         }
       }
       removeWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filter](test, true);
       }
       retainWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filter](test, false);
       }
       get [core.$first]() {
         return this[_sentinel][_next].element;
       }
       get [core.$last]() {
         return this[_sentinel][_previous].element;
       }
       get [core.$single]() {
         if (core.identical(this[_sentinel][_next], this[_sentinel][_previous])) {
           return this[_sentinel][_next].element;
         }
         throw _internal.IterableElementError.tooMany();
       }
       lastEntry() {
         return this[_sentinel].previousEntry();
       }
       firstEntry() {
         return this[_sentinel].nextEntry();
       }
       get [core.$isEmpty]() {
         return core.identical(this[_sentinel][_next], this[_sentinel]);
       }
       clear() {
         this[_sentinel][_next] = this[_sentinel];
         this[_sentinel][_previous] = this[_sentinel];
         this[_elementCount] = 0;
       }
       forEachEntry(f) {
+        dart.as(f, dart.functionType(dart.void, [DoubleLinkedQueueEntry$(E)]));
         let entry = this[_sentinel][_next];
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           let nextEntry = entry[_next];
           f(entry);
           entry = nextEntry;
         }
       }
       get [core.$iterator]() {
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
@@ skipping 78 matching lines @@
           for (let element of dart.as(elements, core.Iterable$(E))) {
             result.addLast(element);
           }
           return result;
         }
       }
       get [core.$iterator]() {
         return new (_ListQueueIterator$(E))(this);
       }
       [core.$forEach](action) {
+        dart.as(action, dart.functionType(dart.void, [E]));
         let modificationCount = this[_modificationCount];
         for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table][core.$length]) - 1) {
           action(this[_table][core.$get](i));
           this[_checkModification](modificationCount);
         }
       }
       get [core.$isEmpty]() {
         return this[_head] == this[_tail];
       }
       get [core.$length]() {
@@ skipping 26 matching lines @@
         if (growable) {
           list = new (core.List$(E))();
           list[core.$length] = this[core.$length];
         } else {
           list = new (core.List$(E))(this[core.$length]);
         }
         this[_writeToList](list);
         return list;
       }
       add(element) {
+        dart.as(element, E);
         this[_add](element);
       }
       addAll(elements) {
+        dart.as(elements, core.Iterable$(E));
         if (dart.is(elements, core.List)) {
           let list = dart.as(elements, core.List);
           let addCount = list[core.$length];
           let length = this[core.$length];
           if (dart.notNull(length) + dart.notNull(addCount) >= dart.notNull(this[_table][core.$length])) {
             this[_preGrow](dart.notNull(length) + dart.notNull(addCount));
             this[_table][core.$setRange](length, dart.notNull(length) + dart.notNull(addCount), dart.as(list, core.Iterable$(E)), 0);
             this[_tail] = dart.notNull(this[_tail]) + dart.notNull(addCount);
           } else {
             let endSpace = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_tail]);
@@ skipping 18 matching lines @@
           let element = this[_table][core.$get](i);
           if (dart.equals(element, object)) {
             this[_remove](i);
             this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
             return true;
           }
         }
         return false;
       }
       [_filterWhere](test, removeMatching) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let index = this[_head];
         let modificationCount = this[_modificationCount];
         let i = this[_head];
         while (i != this[_tail]) {
           let element = this[_table][core.$get](i);
           let remove = core.identical(removeMatching, test(element));
           this[_checkModification](modificationCount);
           if (remove) {
             i = this[_remove](i);
             modificationCount = this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
           } else {
             i = dart.notNull(i) + 1 & dart.notNull(this[_table][core.$length]) - 1;
           }
         }
       }
       removeWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, true);
       }
       retainWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, false);
       }
       clear() {
         if (this[_head] != this[_tail]) {
           for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table][core.$length]) - 1) {
             this[_table][core.$set](i, null);
           }
           this[_head] = this[_tail] = 0;
           this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         }
       }
       toString() {
         return IterableBase.iterableToFullString(this, "{", "}");
       }
       addLast(element) {
+        dart.as(element, E);
         this[_add](element);
       }
       addFirst(element) {
+        dart.as(element, E);
         this[_head] = dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][core.$length]) - 1;
         this[_table][core.$set](this[_head], element);
         if (this[_head] == this[_tail])
           this[_grow]();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
       removeFirst() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ skipping 23 matching lines @@
             return number;
           number = nextNumber;
         }
       }
       [_checkModification](expectedModificationCount) {
         if (expectedModificationCount != this[_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
       }
       [_add](element) {
+        dart.as(element, E);
         this[_table][core.$set](this[_tail], element);
         this[_tail] = dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][core.$length]) - 1;
         if (this[_head] == this[_tail])
           this[_grow]();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
       [_remove](offset) {
         let mask = dart.notNull(this[_table][core.$length]) - 1;
         let startDistance = dart.notNull(offset) - dart.notNull(this[_head]) & dart.notNull(mask);
         let endDistance = dart.notNull(this[_tail]) - dart.notNull(offset) & dart.notNull(mask);
@@ skipping 22 matching lines @@
       [_grow]() {
         let newTable = new (core.List$(E))(dart.notNull(this[_table][core.$length]) * 2);
         let split = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
         newTable[core.$setRange](0, split, this[_table], this[_head]);
         newTable[core.$setRange](split, dart.notNull(split) + dart.notNull(this[_head]), this[_table], 0);
         this[_head] = 0;
         this[_tail] = this[_table][core.$length];
         this[_table] = newTable;
       }
       [_writeToList](target) {
+        dart.as(target, core.List$(E));
         dart.assert(dart.notNull(target[core.$length]) >= dart.notNull(this[core.$length]));
         if (dart.notNull(this[_head]) <= dart.notNull(this[_tail])) {
           let length = dart.notNull(this[_tail]) - dart.notNull(this[_head]);
           target[core.$setRange](0, length, this[_table], this[_head]);
           return length;
         } else {
           let firstPartSize = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
           target[core.$setRange](0, firstPartSize, this[_table], this[_head]);
           target[core.$setRange](firstPartSize, dart.notNull(firstPartSize) + dart.notNull(this[_tail]), this[_table], 0);
           return dart.notNull(this[_tail]) + dart.notNull(firstPartSize);
@@ skipping 86 matching lines @@
   let _SplayTree$ = dart.generic(function(K) {
     class _SplayTree extends core.Object {
       _SplayTree() {
         this[_dummy] = new (_SplayTreeNode$(K))(null);
         this[_root] = null;
         this[_count] = 0;
         this[_modificationCount] = 0;
         this[_splayCount] = 0;
       }
       [_splay](key) {
+        dart.as(key, K);
         if (this[_root] == null)
           return -1;
         let left = this[_dummy];
         let right = this[_dummy];
         let current = this[_root];
         let comp = null;
         while (true) {
           comp = this[_compare](current.key, key);
           if (dart.notNull(comp) > 0) {
             if (current.left == null)
@@ skipping 33 matching lines @@
         right.left = current.right;
         current.left = this[_dummy].right;
         current.right = this[_dummy].left;
         this[_root] = current;
         this[_dummy].right = null;
         this[_dummy].left = null;
         this[_splayCount] = dart.notNull(this[_splayCount]) + 1;
         return comp;
       }
       [_splayMin](node) {
+        dart.as(node, _SplayTreeNode$(K));
         let current = node;
         while (current.left != null) {
           let left = current.left;
           current.left = left.right;
           left.right = current;
           current = left;
         }
         return dart.as(current, _SplayTreeNode$(K));
       }
       [_splayMax](node) {
+        dart.as(node, _SplayTreeNode$(K));
         let current = node;
         while (current.right != null) {
           let right = current.right;
           current.right = right.left;
           right.left = current;
           current = right;
         }
         return dart.as(current, _SplayTreeNode$(K));
       }
       [_remove](key) {
+        dart.as(key, K);
         if (this[_root] == null)
           return null;
         let comp = this[_splay](key);
         if (comp != 0)
           return null;
         let result = this[_root];
         this[_count] = dart.notNull(this[_count]) - 1;
         if (this[_root].left == null) {
           this[_root] = this[_root].right;
         } else {
           let right = this[_root].right;
           this[_root] = this[_splayMax](this[_root].left);
           this[_root].right = right;
         }
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         return result;
       }
       [_addNewRoot](node, comp) {
+        dart.as(node, _SplayTreeNode$(K));
         this[_count] = dart.notNull(this[_count]) + 1;
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         if (this[_root] == null) {
           this[_root] = node;
           return;
         }
         if (dart.notNull(comp) < 0) {
           node.left = this[_root];
           node.right = this[_root].right;
           this[_root].right = null;
@@ skipping 70 matching lines @@
       fromIterables(keys, values, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       [_compare](key1, key2) {
+        dart.as(key1, K);
+        dart.as(key2, K);
         return this[_comparator](key1, key2);
       }
       _internal() {
         this[_comparator] = null;
         this[_validKey] = null;
         super._SplayTree();
       }
       get(key) {
         if (key == null)
           throw new core.ArgumentError(key);
@@ skipping 10 matching lines @@
       }
       remove(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return null;
         let mapRoot = dart.as(this[_remove](dart.as(key, K)), _SplayTreeMapNode);
         if (mapRoot != null)
           return dart.as(mapRoot.value, V);
         return null;
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         if (key == null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
         if (comp == 0) {
           let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
           mapRoot.value = value;
           return;
         }
         this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         if (key == null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
         if (comp == 0) {
           let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
           return dart.as(mapRoot.value, V);
         }
         let modificationCount = this[_modificationCount];
         let splayCount = this[_splayCount];
         let value = ifAbsent();
         if (modificationCount != this[_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         if (splayCount != this[_splayCount]) {
           comp = this[_splay](key);
           dart.assert(comp != 0);
         }
         this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
         return value;
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         other.forEach(((key, value) => {
+          dart.as(key, K);
+          dart.as(value, V);
           this.set(key, value);
         }).bind(this));
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       forEach(f) {
+        dart.as(f, dart.functionType(dart.void, [K, V]));
         let nodes = new (_SplayTreeNodeIterator$(K))(this);
         while (nodes.moveNext()) {
           let node = dart.as(nodes.current, _SplayTreeMapNode$(K, V));
           f(node.key, node.value);
         }
       }
       get length() {
         return this[_count];
       }
       clear() {
@@ skipping 34 matching lines @@
         if (this[_root] == null)
           return null;
         return dart.as(this[_first].key, K);
       }
       lastKey() {
         if (this[_root] == null)
           return null;
         return dart.as(this[_last].key, K);
       }
       lastKeyBefore(key) {
+        dart.as(key, K);
         if (key == null)
           throw new core.ArgumentError(key);
         if (this[_root] == null)
           return null;
         let comp = this[_splay](key);
         if (dart.notNull(comp) < 0)
           return this[_root].key;
         let node = this[_root].left;
         if (node == null)
           return null;
         while (node.right != null) {
           node = node.right;
         }
         return node.key;
       }
       firstKeyAfter(key) {
+        dart.as(key, K);
         if (key == null)
           throw new core.ArgumentError(key);
         if (this[_root] == null)
           return null;
         let comp = this[_splay](key);
         if (dart.notNull(comp) > 0)
           return this[_root].key;
         let node = this[_root].right;
         if (node == null)
           return null;
@@ skipping 191 matching lines @@
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeSet$(E))(compare, isValidKey);
         for (let element of dart.as(elements, core.Iterable$(E))) {
           result.add(element);
         }
         return result;
       }
       [_compare](e1, e2) {
+        dart.as(e1, E);
+        dart.as(e2, E);
         return dart.dcall(this[_comparator], e1, e2);
       }
       get [core.$iterator]() {
         return new (_SplayTreeKeyIterator$(E))(this);
       }
       get [core.$length]() {
         return this[_count];
       }
       get [core.$isEmpty]() {
         return this[_root] == null;
@@ skipping 15 matching lines @@
         if (this[_count] == 0)
           throw _internal.IterableElementError.noElement();
         if (dart.notNull(this[_count]) > 1)
           throw _internal.IterableElementError.tooMany();
         return this[_root].key;
       }
       [core.$contains](object) {
         return dart.notNull(dart.dcall(this[_validKey], object)) && this[_splay](dart.as(object, E)) == 0;
       }
       add(element) {
+        dart.as(element, E);
         let compare = this[_splay](element);
         if (compare == 0)
           return false;
         this[_addNewRoot](new (_SplayTreeNode$(E))(element), compare);
         return true;
       }
       remove(object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return false;
         return this[_remove](dart.as(object, E)) != null;
       }
       addAll(elements) {
+        dart.as(elements, core.Iterable$(E));
         for (let element of elements) {
           let compare = this[_splay](element);
           if (compare != 0) {
             this[_addNewRoot](new (_SplayTreeNode$(E))(element), compare);
           }
         }
       }
       removeAll(elements) {
         for (let element of elements) {
           if (dart.dcall(this[_validKey], element))
@@ skipping 18 matching lines @@
       }
       lookup(object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return null;
         let comp = this[_splay](dart.as(object, E));
         if (comp != 0)
           return null;
         return this[_root].key;
       }
       intersection(other) {
+        dart.as(other, core.Set$(E));
         let result = new (SplayTreeSet$(E))(dart.as(this[_comparator], dart.functionType(core.int, [E, E])), this[_validKey]);
         for (let element of this) {
           if (other[core.$contains](element))
             result.add(element);
         }
         return result;
       }
       difference(other) {
+        dart.as(other, core.Set$(E));
         let result = new (SplayTreeSet$(E))(dart.as(this[_comparator], dart.functionType(core.int, [E, E])), this[_validKey]);
         for (let element of this) {
           if (!dart.notNull(other[core.$contains](element)))
             result.add(element);
         }
         return result;
       }
       union(other) {
+        dart.as(other, core.Set$(E));
         let _ = this[_clone]();
         _.addAll(other);
         return _;
       }
       [_clone]() {
         let set = new (SplayTreeSet$(E))(dart.as(this[_comparator], dart.functionType(core.int, [E, E])), this[_validKey]);
         set[_count] = this[_count];
         set[_root] = this[_copyNode](this[_root]);
         return set;
       }
       [_copyNode](node) {
+        dart.as(node, _SplayTreeNode$(E));
         if (node == null)
           return null;
         let _ = new (_SplayTreeNode$(E))(node.key);
         _.left = this[_copyNode](node.left);
         _.right = this[_copyNode](node.right);
         return _;
       }
       clear() {
         this[_clear]();
       }
@@ skipping 70 matching lines @@
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this[_computeKeys]()[core.$any]((each => dart.equals(this.get(each), value)).bind(this));
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         other.forEach(((key, value) => {
+          dart.as(key, K);
+          dart.as(value, V);
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
         if (_HashMap._isStringKey(key)) {
           let strings = this[_strings];
           return dart.as(strings == null ? null : _HashMap._getTableEntry(strings, key), V);
         } else if (_HashMap._isNumericKey(key)) {
           let nums = this[_nums];
           return dart.as(nums == null ? null : _HashMap._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         return dart.as(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1], V);
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         if (_HashMap._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             this[_strings] = strings = _HashMap._newHashTable();
           this[_addHashTableEntry](strings, key, value);
         } else if (_HashMap._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             this[_nums] = nums = _HashMap._newHashTable();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         let rest = this[_rest];
         if (rest == null)
           this[_rest] = rest = _HashMap._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
           _HashMap._setTableEntry(rest, hash, [key, value]);
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             bucket[dart.notNull(index) + 1] = value;
           } else {
             bucket.push(key, value);
             this[_length] = dart.notNull(this[_length]) + 1;
             this[_keys] = null;
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
         if (_HashMap._isStringKey(key)) {
           return this[_removeHashTableEntry](this[_strings], key);
         } else if (_HashMap._isNumericKey(key)) {
@@ skipping 14 matching lines @@
         this[_keys] = null;
         return dart.as(bucket.splice(index, 2)[1], V);
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_keys] = null;
           this[_length] = 0;
         }
       }
       forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
         let keys = this[_computeKeys]();
         for (let i = 0, length = keys[core.$length]; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let key = keys[i];
           action(dart.as(key, K), this.get(key));
           if (keys !== this[_keys]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       [_computeKeys]() {
@@ skipping 33 matching lines @@
               let key = bucket[i];
               result[index] = key;
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index == this[_length]);
         return this[_keys] = result;
       }
       [_addHashTableEntry](table, key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         if (!dart.notNull(_HashMap._hasTableEntry(table, key))) {
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         }
         _HashMap._setTableEntry(table, key, value);
       }
       [_removeHashTableEntry](table, key) {
         if (dart.notNull(table != null) && dart.notNull(_HashMap._hasTableEntry(table, key))) {
           let value = dart.as(_HashMap._getTableEntry(table, key), V);
           _HashMap._deleteTableEntry(table, key);
@@ skipping 85 matching lines @@
         this[_hashCode] = hashCode;
         this[_validKey] = dart.as(validKey != null ? validKey : v => dart.is(v, K), _Predicate);
         super._HashMap();
       }
       get(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         super[_set](key, value);
       }
       containsKey(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return false;
         return super[_containsKey](key);
       }
       remove(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return null;
@@ skipping 31 matching lines @@
       get [core.$isEmpty]() {
         return dart.equals(dart.dload(this[_map], _length), 0);
       }
       get [core.$iterator]() {
         return new (HashMapKeyIterator$(E))(this[_map], dart.as(dart.dsend(this[_map], _computeKeys), core.List));
       }
       [core.$contains](element) {
         return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       [core.$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         let keys = dart.as(dart.dsend(this[_map], _computeKeys), core.List);
         for (let i = 0, length = keys.length; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(dart.as(keys[i], E));
           if (keys !== dart.dload(this[_map], _keys)) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
         }
       }
     }
     HashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
@@ skipping 84 matching lines @@
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this.keys[core.$any]((each => dart.equals(this.get(each), value)).bind(this));
       }
       addAll(other) {
+        dart.as(other, core.Map$(K, V));
         other.forEach(((key, value) => {
+          dart.as(key, K);
+          dart.as(value, V);
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
         if (_LinkedHashMap._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return null;
           let cell = dart.as(_LinkedHashMap._getTableEntry(strings, key), LinkedHashMapCell);
           return dart.as(cell == null ? null : cell[_value], V);
@@ skipping 12 matching lines @@
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0)
           return null;
         let cell = dart.as(bucket[index], LinkedHashMapCell);
         return dart.as(cell[_value], V);
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         if (_LinkedHashMap._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             this[_strings] = strings = _LinkedHashMap._newHashTable();
           this[_addHashTableEntry](strings, key, value);
         } else if (_LinkedHashMap._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             this[_nums] = nums = _LinkedHashMap._newHashTable();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         let rest = this[_rest];
         if (rest == null)
           this[_rest] = rest = _LinkedHashMap._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
           let cell = this[_newLinkedCell](key, value);
           _LinkedHashMap._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             let cell = dart.as(bucket[index], LinkedHashMapCell);
             cell[_value] = value;
           } else {
             let cell = this[_newLinkedCell](key, value);
             bucket.push(cell);
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
         if (_LinkedHashMap._isStringKey(key)) {
           return this[_removeHashTableEntry](this[_strings], key);
         } else if (_LinkedHashMap._isNumericKey(key)) {
@@ skipping 15 matching lines @@
         return dart.as(cell[_value], V);
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
           this[_length] = 0;
           this[_modified]();
         }
       }
       forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
         let cell = this[_first];
         let modifications = this[_modifications];
         while (cell != null) {
           action(dart.as(cell[_key], K), dart.as(cell[_value], V));
           if (modifications != this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           cell = cell[_next];
         }
       }
       [_addHashTableEntry](table, key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         let cell = dart.as(_LinkedHashMap._getTableEntry(table, key), LinkedHashMapCell);
         if (cell == null) {
           _LinkedHashMap._setTableEntry(table, key, this[_newLinkedCell](key, value));
         } else {
           cell[_value] = value;
         }
       }
       [_removeHashTableEntry](table, key) {
         if (table == null)
           return null;
         let cell = dart.as(_LinkedHashMap._getTableEntry(table, key), LinkedHashMapCell);
         if (cell == null)
           return null;
         this[_unlinkCell](cell);
         _LinkedHashMap._deleteTableEntry(table, key);
         return dart.as(cell[_value], V);
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         let cell = new LinkedHashMapCell(key, value);
         if (this[_first] == null) {
           this[_first] = this[_last] = cell;
         } else {
           let last = this[_last];
           cell[_previous] = last;
           this[_last] = last[_next] = cell;
         }
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_modified]();
@@ skipping 93 matching lines @@
         this[_hashCode] = hashCode;
         this[_validKey] = dart.as(validKey != null ? validKey : v => dart.is(v, K), _Predicate);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
         super[_set](key, value);
       }
       containsKey(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return false;
         return super[_containsKey](key);
       }
       remove(key) {
         if (!dart.notNull(dart.dcall(this[_validKey], key)))
           return null;
@@ skipping 37 matching lines @@
       get [core.$isEmpty]() {
         return dart.equals(dart.dload(this[_map], _length), 0);
       }
       get [core.$iterator]() {
         return new (LinkedHashMapKeyIterator$(E))(this[_map], dart.as(dart.dload(this[_map], _modifications), core.int));
       }
       [core.$contains](element) {
         return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       [core.$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         let cell = dart.as(dart.dload(this[_map], _first), LinkedHashMapCell);
         let modifications = dart.as(dart.dload(this[_map], _modifications), core.int);
         while (cell != null) {
           f(dart.as(cell[_key], E));
           if (!dart.equals(modifications, dart.dload(this[_map], _modifications))) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
           cell = cell[_next];
         }
       }
@@ skipping 88 matching lines @@
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0)
           return null;
         return dart.as(bucket[core.$get](index), E);
       }
       add(element) {
+        dart.as(element, E);
         if (_HashSet._isStringElement(element)) {
           let strings = this[_strings];
           if (strings == null)
             this[_strings] = strings = _HashSet._newHashTable();
           return this[_addHashTableEntry](strings, element);
         } else if (_HashSet._isNumericElement(element)) {
           let nums = this[_nums];
           if (nums == null)
             this[_nums] = nums = _HashSet._newHashTable();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
+        dart.as(element, E);
         let rest = this[_rest];
         if (rest == null)
           this[_rest] = rest = _HashSet._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
           _HashSet._setTableEntry(rest, hash, [element]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0)
             return false;
           bucket.push(element);
         }
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       addAll(objects) {
+        dart.as(objects, core.Iterable$(E));
         for (let each of objects) {
           this.add(each);
         }
       }
       remove(object) {
         if (_HashSet._isStringElement(object)) {
           return this[_removeHashTableEntry](this[_strings], object);
         } else if (_HashSet._isNumericElement(object)) {
           return this[_removeHashTableEntry](this[_nums], object);
         } else {
@@ skipping 55 matching lines @@
             for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
               result[index] = bucket[i];
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index == this[_length]);
         return this[_elements] = result;
       }
       [_addHashTableEntry](table, element) {
+        dart.as(element, E);
         if (_HashSet._hasTableEntry(table, element))
           return false;
         _HashSet._setTableEntry(table, element, 0);
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       [_removeHashTableEntry](table, element) {
         if (dart.notNull(table != null) && dart.notNull(_HashSet._hasTableEntry(table, element))) {
           _HashSet._deleteTableEntry(table, element);
@@ skipping 92 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (this[_equality](dart.as(bucket[i], E), dart.as(element, E)))
             return i;
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(object) {
+        dart.as(object, E);
         return super[_add](object);
       }
       [core.$contains](object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return false;
         return super[_contains](object);
       }
       lookup(object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return null;
@@ skipping 103 matching lines @@
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0)
           return null;
         return dart.as(dart.dload(bucket[core.$get](index), _element), E);
       }
       [core.$forEach](action) {
+        dart.as(action, dart.functionType(dart.void, [E]));
         let cell = this[_first];
         let modifications = this[_modifications];
         while (cell != null) {
           action(dart.as(cell[_element], E));
           if (modifications != this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           cell = cell[_next];
         }
       }
       get [core.$first]() {
         if (this[_first] == null)
           throw new core.StateError("No elements");
         return dart.as(this[_first][_element], E);
       }
       get [core.$last]() {
         if (this[_last] == null)
           throw new core.StateError("No elements");
         return dart.as(this[_last][_element], E);
       }
       add(element) {
+        dart.as(element, E);
         if (_LinkedHashSet._isStringElement(element)) {
           let strings = this[_strings];
           if (strings == null)
             this[_strings] = strings = _LinkedHashSet._newHashTable();
           return this[_addHashTableEntry](strings, element);
         } else if (_LinkedHashSet._isNumericElement(element)) {
           let nums = this[_nums];
           if (nums == null)
             this[_nums] = nums = _LinkedHashSet._newHashTable();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
+        dart.as(element, E);
         let rest = this[_rest];
         if (rest == null)
           this[_rest] = rest = _LinkedHashSet._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
           let cell = this[_newLinkedCell](element);
           _LinkedHashSet._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
@@ skipping 19 matching lines @@
           return false;
         let bucket = this[_getBucket](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0)
           return false;
         let cell = dart.as(bucket.splice(index, 1)[0], LinkedHashSetCell);
         this[_unlinkCell](cell);
         return true;
       }
       removeWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, true);
       }
       retainWhere(test) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, false);
       }
       [_filterWhere](test, removeMatching) {
+        dart.as(test, dart.functionType(core.bool, [E]));
         let cell = this[_first];
         while (cell != null) {
           let element = dart.as(cell[_element], E);
           let next = cell[_next];
           let modifications = this[_modifications];
           let shouldRemove = removeMatching == test(element);
           if (modifications != this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           if (shouldRemove)
             this.remove(element);
           cell = next;
         }
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
           this[_length] = 0;
           this[_modified]();
         }
       }
       [_addHashTableEntry](table, element) {
+        dart.as(element, E);
         let cell = dart.as(_LinkedHashSet._getTableEntry(table, element), LinkedHashSetCell);
         if (cell != null)
           return false;
         _LinkedHashSet._setTableEntry(table, element, this[_newLinkedCell](element));
         return true;
       }
       [_removeHashTableEntry](table, element) {
         if (table == null)
           return false;
         let cell = dart.as(_LinkedHashSet._getTableEntry(table, element), LinkedHashSetCell);
         if (cell == null)
           return false;
         this[_unlinkCell](cell);
         _LinkedHashSet._deleteTableEntry(table, element);
         return true;
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](element) {
+        dart.as(element, E);
         let cell = new LinkedHashSetCell(element);
         if (this[_first] == null) {
           this[_first] = this[_last] = cell;
         } else {
           let last = this[_last];
           cell[_previous] = last;
           this[_last] = last[_next] = cell;
         }
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_modified]();
@@ skipping 105 matching lines @@
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (this[_equality](dart.as(cell[_element], E), dart.as(element, E)))
             return i;
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(element) {
+        dart.as(element, E);
         return super[_add](element);
       }
       [core.$contains](object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return false;
         return super[_contains](object);
       }
       lookup(object) {
         if (!dart.notNull(dart.dcall(this[_validKey], object)))
           return null;
@@ skipping 117 matching lines @@
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
 })(collection || (collection = {}));