Tag closures with their types

lib/runtime/dart/collection.js

 var collection = dart.defineLibrary(collection, {});
 var _internal = dart.lazyImport(_internal);
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 var math = dart.lazyImport(math);
 (function(exports, _internal, core, _js_helper, math) {
   '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]() {
         return this[_source][core.$length];
       }
       [core.$get](index) {
         return this[_source][core.$elementAt](index);
       }
     }
+    dart.setSignature(UnmodifiableListView, {
+      methods: () => ({[core.$get]: dart.functionType(E, [core.int])})
+    });
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
-  // Function _defaultEquals: (Object, Object) → bool
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
-  // Function _defaultHashCode: (Object) → int
+  dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
     return dart.hashCode(a);
   }
+  dart.fn(_defaultHashCode, core.int, [core.Object]);
   let _Equality$ = dart.generic(function(K) {
     let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [K, K]));
     return _Equality;
   });
   let _Equality = _Equality$();
   let _Hasher$ = dart.generic(function(K) {
     let _Hasher = dart.typedef('_Hasher', () => dart.functionType(core.int, [K]));
     return _Hasher;
   });
   let _Hasher = _Hasher$();
@@ skipping 25 matching lines @@
             equals = _defaultEquals;
           }
         }
         return new (_CustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       identity() {
         return new (_IdentityHashMap$(K, V))();
       }
       from(other) {
         let result = new (HashMap$(K, V))();
-        other.forEach((k, v) => {
+        other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
-        });
+        }));
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let map = new (HashMap$(K, V))();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values) {
         let map = new (HashMap$(K, V))();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(HashMap, 'identity');
     dart.defineNamedConstructor(HashMap, 'from');
     dart.defineNamedConstructor(HashMap, 'fromIterable');
     dart.defineNamedConstructor(HashMap, 'fromIterables');
+    dart.setSignature(HashMap, {});
     return HashMap;
   });
   let HashMap = HashMap$();
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
@@ skipping 253 matching lines @@
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
     }
     SetMixin[dart.implements] = () => [core.Set$(E)];
+    dart.setSignature(SetMixin, {
+      methods: () => ({
+        clear: dart.functionType(dart.void, []),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        removeAll: dart.functionType(dart.void, [core.Iterable$(core.Object)]),
+        retainAll: dart.functionType(dart.void, [core.Iterable$(core.Object)]),
+        removeWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        retainWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        containsAll: dart.functionType(core.bool, [core.Iterable$(core.Object)]),
+        union: dart.functionType(core.Set$(E), [core.Set$(E)]),
+        intersection: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        difference: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool}),
+        [core.$map]: dart.functionType(core.Iterable, [dart.functionType(dart.dynamic, [E])]),
+        toString: dart.functionType(core.String, []),
+        [core.$where]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$expand]: dart.functionType(core.Iterable, [dart.functionType(core.Iterable, [E])]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [core.$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
+        [core.$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
+        [core.$every]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$join]: dart.functionType(core.String, [], [core.String]),
+        [core.$any]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$take]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$takeWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$skip]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$skipWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$firstWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$lastWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$singleWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])]),
+        [core.$elementAt]: dart.functionType(E, [core.int])
+      })
+    });
     return SetMixin;
   });
   let SetMixin = SetMixin$();
   let SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
+    dart.setSignature(SetBase, {
+      statics: () => ({setToString: dart.functionType(core.String, [core.Set])}),
+      names: ['setToString']
+    });
     return SetBase;
   });
   let SetBase = SetBase$();
   let _newSet = Symbol('_newSet');
   let _HashSetBase$ = dart.generic(function(E) {
     class _HashSetBase extends SetBase$(E) {
       difference(other) {
         let result = this[_newSet]();
         for (let element of this) {
           if (!dart.notNull(other[core.$contains](element)))
@@ skipping 10 matching lines @@
         return result;
       }
       [core.$toSet]() {
         return (() => {
           let _ = this[_newSet]();
           _.addAll(this);
           return _;
         }).bind(this)();
       }
     }
+    dart.setSignature(_HashSetBase, {
+      methods: () => ({
+        difference: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        intersection: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        [core.$toSet]: dart.functionType(core.Set$(E), [])
+      })
+    });
     return _HashSetBase;
   });
   let _HashSetBase = _HashSetBase$();
   let HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
       HashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
@@ skipping 29 matching lines @@
           result.add(e);
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     HashSet[dart.implements] = () => [core.Set$(E)];
     dart.defineNamedConstructor(HashSet, 'identity');
     dart.defineNamedConstructor(HashSet, 'from');
+    dart.setSignature(HashSet, {});
     return HashSet;
   });
   let HashSet = HashSet$();
   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) {
@@ skipping 194 matching lines @@
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase.iterableToShortString(this, '(', ')');
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     IterableMixin[dart.implements] = () => [core.Iterable$(E)];
+    dart.setSignature(IterableMixin, {
+      methods: () => ({
+        [core.$map]: dart.functionType(core.Iterable, [dart.functionType(dart.dynamic, [E])]),
+        [core.$where]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$expand]: dart.functionType(core.Iterable, [dart.functionType(core.Iterable, [E])]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [core.$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
+        [core.$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
+        [core.$every]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$join]: dart.functionType(core.String, [], [core.String]),
+        [core.$any]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool}),
+        [core.$toSet]: dart.functionType(core.Set$(E), []),
+        [core.$take]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$takeWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$skip]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$skipWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$firstWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$lastWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$singleWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])]),
+        [core.$elementAt]: dart.functionType(E, [core.int]),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     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);
@@ skipping 326 matching lines @@
           parts[core.$add](elision);
         }
         parts[core.$add](penultimateString);
         parts[core.$add](ultimateString);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     IterableBase[dart.implements] = () => [core.Iterable$(E)];
+    dart.setSignature(IterableBase, {
+      methods: () => ({
+        [core.$map]: dart.functionType(core.Iterable, [dart.functionType(dart.dynamic, [E])]),
+        [core.$where]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$expand]: dart.functionType(core.Iterable, [dart.functionType(core.Iterable, [E])]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [core.$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
+        [core.$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
+        [core.$every]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$join]: dart.functionType(core.String, [], [core.String]),
+        [core.$any]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool}),
+        [core.$toSet]: dart.functionType(core.Set$(E), []),
+        [core.$take]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$takeWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$skip]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$skipWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$firstWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$lastWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$singleWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])]),
+        [core.$elementAt]: dart.functionType(E, [core.int]),
+        toString: dart.functionType(core.String, [])
+      }),
+      statics: () => ({
+        iterableToShortString: dart.functionType(core.String, [core.Iterable], [core.String, core.String]),
+        iterableToFullString: dart.functionType(core.String, [core.Iterable], [core.String, core.String]),
+        _isToStringVisiting: dart.functionType(core.bool, [core.Object]),
+        _iterablePartsToStrings: dart.functionType(dart.void, [core.Iterable, core.List])
+      }),
+      names: ['iterableToShortString', 'iterableToFullString', '_isToStringVisiting', '_iterablePartsToStrings']
+    });
     return IterableBase;
   });
   let IterableBase = IterableBase$();
   dart.defineLazyProperties(IterableBase, {
     get _toStringVisiting() {
       return [];
     }
   });
   let _iterator = Symbol('_iterator');
   let _state = Symbol('_state');
@@ skipping 18 matching lines @@
         return result;
       }
       [_move]() {
         if (this[_iterator].moveNext()) {
           this[_state] = HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT;
         } else {
           this[_state] = HasNextIterator$()._NO_NEXT;
         }
       }
     }
+    dart.setSignature(HasNextIterator, {
+      methods: () => ({
+        next: dart.functionType(E, []),
+        [_move]: dart.functionType(dart.void, [])
+      })
+    });
     return HasNextIterator;
   });
   let HasNextIterator = HasNextIterator$();
   HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
   HasNextIterator._NO_NEXT = 1;
   HasNextIterator._NOT_MOVED_YET = 2;
   let LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
       LinkedHashMap(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
@@ skipping 21 matching lines @@
             equals = _defaultEquals;
           }
         }
         return new (_LinkedCustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       identity() {
         return new (_LinkedIdentityHashMap$(K, V))();
       }
       from(other) {
         let result = new (LinkedHashMap$(K, V))();
-        other.forEach((k, v) => {
+        other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
-        });
+        }));
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let map = new (LinkedHashMap$(K, V))();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values) {
         let map = new (LinkedHashMap$(K, V))();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       _literal(keyValuePairs) {
         return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new (_LinkedHashMap$(K, V))()), LinkedHashMap$(K, V));
       }
       _empty() {
         return new (_LinkedHashMap$(K, V))();
       }
     }
     LinkedHashMap[dart.implements] = () => [HashMap$(K, V)];
     dart.defineNamedConstructor(LinkedHashMap, 'identity');
     dart.defineNamedConstructor(LinkedHashMap, 'from');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterable');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterables');
     dart.defineNamedConstructor(LinkedHashMap, '_literal');
     dart.defineNamedConstructor(LinkedHashMap, '_empty');
+    dart.setSignature(LinkedHashMap, {});
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$();
   let LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
       LinkedHashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
@@ skipping 30 matching lines @@
         }
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     LinkedHashSet[dart.implements] = () => [HashSet$(E)];
     dart.defineNamedConstructor(LinkedHashSet, 'identity');
     dart.defineNamedConstructor(LinkedHashSet, 'from');
+    dart.setSignature(LinkedHashSet, {});
     return LinkedHashSet;
   });
   let LinkedHashSet = LinkedHashSet$();
   let _modificationCount = Symbol('_modificationCount');
   let _length = Symbol('_length');
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   let _insertAfter = Symbol('_insertAfter');
   let _list = Symbol('_list');
   let _unlink = Symbol('_unlink');
@@ skipping 10 matching lines @@
       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));
+        entries[core.$forEach](dart.fn((entry => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this), dart.void, [dart.dynamic]));
       }
       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);
@@ skipping 66 matching lines @@
       [_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];
+    dart.setSignature(LinkedList, {
+      methods: () => ({
+        addFirst: dart.functionType(dart.void, [E]),
+        add: dart.functionType(dart.void, [E]),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        remove: dart.functionType(core.bool, [E]),
+        clear: dart.functionType(dart.void, []),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [_insertAfter]: dart.functionType(dart.void, [_LinkedListLink, E]),
+        [_unlink]: dart.functionType(dart.void, [LinkedListEntry$(E)])
+      })
+    });
     return LinkedList;
   });
   let LinkedList = LinkedList$();
   let _current = Symbol('_current');
   let _LinkedListIterator$ = dart.generic(function(E) {
     class _LinkedListIterator extends core.Object {
       _LinkedListIterator(list) {
         this[_list] = list;
         this[_modificationCount] = list[_modificationCount];
         this[_next] = list[_next];
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (core.identical(this[_next], this[_list])) {
           this[_current] = null;
           return false;
         }
         if (this[_modificationCount] != this[_list][_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         this[_current] = dart.as(this[_next], E);
         this[_next] = this[_next][_next];
         return true;
       }
     }
     _LinkedListIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(_LinkedListIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return _LinkedListIterator;
   });
   let _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(_LinkedListLink, {});
   let LinkedListEntry$ = dart.generic(function(E) {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
         this[_next] = null;
         this[_previous] = null;
       }
       get list() {
         return this[_list];
       }
@@ skipping 14 matching lines @@
       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];
+    dart.setSignature(LinkedListEntry, {
+      methods: () => ({
+        unlink: dart.functionType(dart.void, []),
+        insertAfter: dart.functionType(dart.void, [E]),
+        insertBefore: dart.functionType(dart.void, [E])
+      })
+    });
     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);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
@@ skipping 467 matching lines @@
         }
       }
       get [core.$reversed]() {
         return new (_internal.ReversedListIterable$(E))(this);
       }
       [core.$toString]() {
         return IterableBase.iterableToFullString(this, '[', ']');
       }
     }
     ListMixin[dart.implements] = () => [core.List$(E)];
+    dart.setSignature(ListMixin, {
+      methods: () => ({
+        [core.$elementAt]: dart.functionType(E, [core.int]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [core.$every]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$any]: dart.functionType(core.bool, [dart.functionType(core.bool, [E])]),
+        [core.$firstWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$lastWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}),
+        [core.$singleWhere]: dart.functionType(E, [dart.functionType(core.bool, [E])]),
+        [core.$join]: dart.functionType(core.String, [], [core.String]),
+        [core.$where]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$map]: dart.functionType(core.Iterable, [dart.functionType(dart.dynamic, [E])]),
+        [core.$expand]: dart.functionType(core.Iterable, [dart.functionType(core.Iterable, [E])]),
+        [core.$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
+        [core.$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
+        [core.$skip]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$skipWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$take]: dart.functionType(core.Iterable$(E), [core.int]),
+        [core.$takeWhile]: dart.functionType(core.Iterable$(E), [dart.functionType(core.bool, [E])]),
+        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool}),
+        [core.$toSet]: dart.functionType(core.Set$(E), []),
+        [core.$add]: dart.functionType(dart.void, [E]),
+        [core.$addAll]: dart.functionType(dart.void, [core.Iterable$(E)]),
+        [core.$remove]: dart.functionType(core.bool, [core.Object]),
+        [core.$removeWhere]: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        [core.$retainWhere]: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        [core.$clear]: dart.functionType(dart.void, []),
+        [core.$removeLast]: dart.functionType(E, []),
+        [core.$sort]: dart.functionType(dart.void, [], [dart.functionType(core.int, [E, E])]),
+        [core.$shuffle]: dart.functionType(dart.void, [], [math.Random]),
+        [core.$asMap]: dart.functionType(core.Map$(core.int, E), []),
+        [core.$sublist]: dart.functionType(core.List$(E), [core.int], [core.int]),
+        [core.$getRange]: dart.functionType(core.Iterable$(E), [core.int, core.int]),
+        [core.$removeRange]: dart.functionType(dart.void, [core.int, core.int]),
+        [core.$fillRange]: dart.functionType(dart.void, [core.int, core.int], [E]),
+        [core.$setRange]: dart.functionType(dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]),
+        [core.$replaceRange]: dart.functionType(dart.void, [core.int, core.int, core.Iterable$(E)]),
+        [core.$indexOf]: dart.functionType(core.int, [core.Object], [core.int]),
+        [core.$lastIndexOf]: dart.functionType(core.int, [core.Object], [core.int]),
+        [core.$insert]: dart.functionType(dart.void, [core.int, E]),
+        [core.$removeAt]: dart.functionType(E, [core.int]),
+        [core.$insertAll]: dart.functionType(dart.void, [core.int, core.Iterable$(E)]),
+        [core.$setAll]: dart.functionType(dart.void, [core.int, core.Iterable$(E)]),
+        [core.$toString]: dart.functionType(core.String, [])
+      }),
+      statics: () => ({_filter: dart.functionType(dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic]), core.bool])}),
+      names: ['_filter']
+    });
     return ListMixin;
   });
   let ListMixin = ListMixin$();
   let ListBase$ = dart.generic(function(E) {
     class ListBase extends dart.mixin(core.Object, ListMixin$(E)) {
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
+    dart.setSignature(ListBase, {
+      statics: () => ({listToString: dart.functionType(core.String, [core.List])}),
+      names: ['listToString']
+    });
     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));
         }
@@ skipping 32 matching lines @@
         return this.keys[core.$isNotEmpty];
       }
       get values() {
         return new (_MapBaseValueIterable$(V))(this);
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     MapMixin[dart.implements] = () => [core.Map$(K, V)];
+    dart.setSignature(MapMixin, {
+      methods: () => ({
+        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        containsValue: dart.functionType(core.bool, [core.Object]),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     return MapMixin;
   });
   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 {
@@ skipping 12 matching lines @@
       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)];
+    dart.setSignature(_UnmodifiableMapMixin, {
+      methods: () => ({
+        set: dart.functionType(dart.void, [K, V]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        clear: dart.functionType(dart.void, []),
+        remove: dart.functionType(V, [core.Object]),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(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;
   });
   let UnmodifiableMapBase = UnmodifiableMapBase$();
   let _map = Symbol('_map');
   let _MapBaseValueIterable$ = dart.generic(function(V) {
@@ skipping 18 matching lines @@
         return dart.as(this[_map].get(this[_map].keys[core.$single]), V);
       }
       get [core.$last]() {
         return dart.as(this[_map].get(this[_map].keys[core.$last]), V);
       }
       get [core.$iterator]() {
         return new (_MapBaseValueIterator$(V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_MapBaseValueIterable, {});
     return _MapBaseValueIterable;
   });
   let _MapBaseValueIterable = _MapBaseValueIterable$();
   let _keys = Symbol('_keys');
   let _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
         this[_keys] = map.keys[core.$iterator];
         this[_current] = null;
       }
       moveNext() {
         if (this[_keys].moveNext()) {
           this[_current] = dart.as(this[_map].get(this[_keys].current), V);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _MapBaseValueIterator[dart.implements] = () => [core.Iterator$(V)];
+    dart.setSignature(_MapBaseValueIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return _MapBaseValueIterator;
   });
   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);
@@ skipping 41 matching lines @@
         return this[_map].remove(key);
       }
       toString() {
         return dart.toString(this[_map]);
       }
       get values() {
         return this[_map].values;
       }
     }
     MapView[dart.implements] = () => [core.Map$(K, V)];
+    dart.setSignature(MapView, {
+      methods: () => ({
+        get: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        clear: dart.functionType(dart.void, []),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        containsValue: dart.functionType(core.bool, [core.Object]),
+        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])]),
+        remove: dart.functionType(V, [core.Object]),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     return MapView;
   });
   let MapView = MapView$();
   let UnmodifiableMapView$ = dart.generic(function(K, V) {
     class UnmodifiableMapView extends dart.mixin(MapView$(K, V), _UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$();
   class Maps extends core.Object {
     static containsValue(map, value) {
@@ skipping 24 matching lines @@
       for (let k of map.keys[core.$toList]()) {
         map.remove(k);
       }
     }
     static forEach(map, f) {
       for (let k of map.keys) {
         dart.dcall(f, k, map.get(k));
       }
     }
     static getValues(map) {
-      return map.keys[core.$map](key => map.get(key));
+      return map.keys[core.$map](dart.fn(key => map.get(key)));
     }
     static length(map) {
       return map.keys[core.$length];
     }
     static isEmpty(map) {
       return map.keys[core.$isEmpty];
     }
     static isNotEmpty(map) {
       return map.keys[core.$isNotEmpty];
     }
     static mapToString(m) {
       if (IterableBase._isToStringVisiting(m)) {
         return '{...}';
       }
       let result = new core.StringBuffer();
       try {
         IterableBase._toStringVisiting[core.$add](m);
         result.write('{');
         let first = true;
-        m.forEach((k, v) => {
+        m.forEach(dart.fn((k, v) => {
           if (!dart.notNull(first)) {
             result.write(', ');
           }
           first = false;
           result.write(k);
           result.write(': ');
           result.write(v);
-        });
+        }));
         result.write('}');
       } finally {
         dart.assert(core.identical(IterableBase._toStringVisiting[core.$last], m));
         IterableBase._toStringVisiting[core.$removeLast]();
       }
       return dart.toString(result);
     }
     static _id(x) {
       return x;
     }
@@ skipping 14 matching lines @@
       while (dart.notNull(hasNextKey) && dart.notNull(hasNextValue)) {
         map.set(keyIterator.current, valueIterator.current);
         hasNextKey = keyIterator.moveNext();
         hasNextValue = valueIterator.moveNext();
       }
       if (dart.notNull(hasNextKey) || dart.notNull(hasNextValue)) {
         throw new core.ArgumentError("Iterables do not have same length.");
       }
     }
   }
+  dart.setSignature(Maps, {
+    statics: () => ({
+      containsValue: dart.functionType(core.bool, [core.Map, dart.dynamic]),
+      containsKey: dart.functionType(core.bool, [core.Map, dart.dynamic]),
+      putIfAbsent: dart.functionType(dart.dynamic, [core.Map, dart.dynamic, dart.functionType(dart.dynamic, [])]),
+      clear: dart.functionType(dart.dynamic, [core.Map]),
+      forEach: dart.functionType(dart.dynamic, [core.Map, dart.functionType(dart.void, [dart.dynamic, dart.dynamic])]),
+      getValues: dart.functionType(core.Iterable, [core.Map]),
+      length: dart.functionType(core.int, [core.Map]),
+      isEmpty: dart.functionType(core.bool, [core.Map]),
+      isNotEmpty: dart.functionType(core.bool, [core.Map]),
+      mapToString: dart.functionType(core.String, [core.Map]),
+      _id: dart.functionType(dart.dynamic, [dart.dynamic]),
+      _fillMapWithMappedIterable: dart.functionType(dart.void, [core.Map, core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic])]),
+      _fillMapWithIterables: dart.functionType(dart.void, [core.Map, core.Iterable, core.Iterable])
+    }),
+    names: ['containsValue', 'containsKey', 'putIfAbsent', 'clear', 'forEach', 'getValues', 'length', 'isEmpty', 'isNotEmpty', 'mapToString', '_id', '_fillMapWithMappedIterable', '_fillMapWithIterables']
+  });
   let Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
       Queue() {
         return new (ListQueue$(E))();
       }
       from(elements) {
         return new (ListQueue$(E)).from(elements);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     Queue[dart.implements] = () => [core.Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(Queue, 'from');
+    dart.setSignature(Queue, {});
     return Queue;
   });
   let Queue = Queue$();
   let _element = Symbol('_element');
   let _link = Symbol('_link');
   let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
   let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
@@ skipping 33 matching lines @@
         return this[_next][_asNonSentinelEntry]();
       }
       get element() {
         return this[_element];
       }
       set element(e) {
         dart.as(e, E);
         this[_element] = e;
       }
     }
+    dart.setSignature(DoubleLinkedQueueEntry, {
+      methods: () => ({
+        [_link]: dart.functionType(dart.void, [DoubleLinkedQueueEntry$(E), DoubleLinkedQueueEntry$(E)]),
+        append: dart.functionType(dart.void, [E]),
+        prepend: dart.functionType(dart.void, [E]),
+        remove: dart.functionType(E, []),
+        [_asNonSentinelEntry]: dart.functionType(DoubleLinkedQueueEntry$(E), []),
+        previousEntry: dart.functionType(DoubleLinkedQueueEntry$(E), []),
+        nextEntry: dart.functionType(DoubleLinkedQueueEntry$(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();
       }
     }
+    dart.setSignature(_DoubleLinkedQueueEntrySentinel, {
+      methods: () => ({
+        remove: dart.functionType(E, []),
+        [_asNonSentinelEntry]: dart.functionType(DoubleLinkedQueueEntry$(E), [])
+      })
+    });
     return _DoubleLinkedQueueEntrySentinel;
   });
   let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
   let _sentinel = Symbol('_sentinel');
   let _elementCount = Symbol('_elementCount');
   let _filter = Symbol('_filter');
   let DoubleLinkedQueue$ = dart.generic(function(E) {
     class DoubleLinkedQueue extends IterableBase$(E) {
       DoubleLinkedQueue() {
         this[_sentinel] = null;
@@ skipping 112 matching lines @@
       }
       get [core.$iterator]() {
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
+    dart.setSignature(DoubleLinkedQueue, {
+      methods: () => ({
+        addLast: dart.functionType(dart.void, [E]),
+        addFirst: dart.functionType(dart.void, [E]),
+        add: dart.functionType(dart.void, [E]),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        removeLast: dart.functionType(E, []),
+        removeFirst: dart.functionType(E, []),
+        remove: dart.functionType(core.bool, [core.Object]),
+        [_filter]: dart.functionType(dart.void, [dart.functionType(core.bool, [E]), core.bool]),
+        removeWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        retainWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        lastEntry: dart.functionType(DoubleLinkedQueueEntry$(E), []),
+        firstEntry: dart.functionType(DoubleLinkedQueueEntry$(E), []),
+        clear: dart.functionType(dart.void, []),
+        forEachEntry: dart.functionType(dart.void, [dart.functionType(dart.void, [DoubleLinkedQueueEntry$(E)])]),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     return DoubleLinkedQueue;
   });
   let DoubleLinkedQueue = DoubleLinkedQueue$();
   let _nextEntry = Symbol('_nextEntry');
   let _DoubleLinkedQueueIterator$ = dart.generic(function(E) {
     class _DoubleLinkedQueueIterator extends core.Object {
       _DoubleLinkedQueueIterator(sentinel) {
         this[_sentinel] = sentinel;
         this[_nextEntry] = sentinel[_next];
         this[_current] = null;
       }
       moveNext() {
         if (!dart.notNull(core.identical(this[_nextEntry], this[_sentinel]))) {
           this[_current] = this[_nextEntry][_element];
           this[_nextEntry] = this[_nextEntry][_next];
           return true;
         }
         this[_current] = null;
         this[_nextEntry] = this[_sentinel] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _DoubleLinkedQueueIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(_DoubleLinkedQueueIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return _DoubleLinkedQueueIterator;
   });
   let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$();
   let _head = Symbol('_head');
   let _tail = Symbol('_tail');
   let _table = Symbol('_table');
   let _checkModification = Symbol('_checkModification');
   let _writeToList = Symbol('_writeToList');
   let _add = Symbol('_add');
   let _preGrow = Symbol('_preGrow');
@@ skipping 279 matching lines @@
         newElementCount = dart.notNull(newElementCount) + (dart.notNull(newElementCount) >> 1);
         let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
         let newTable = new (core.List$(E))(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
+    dart.setSignature(ListQueue, {
+      methods: () => ({
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [core.$elementAt]: dart.functionType(E, [core.int]),
+        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool}),
+        add: dart.functionType(dart.void, [E]),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        remove: dart.functionType(core.bool, [core.Object]),
+        [_filterWhere]: dart.functionType(dart.void, [dart.functionType(core.bool, [E]), core.bool]),
+        removeWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        retainWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        clear: dart.functionType(dart.void, []),
+        toString: dart.functionType(core.String, []),
+        addLast: dart.functionType(dart.void, [E]),
+        addFirst: dart.functionType(dart.void, [E]),
+        removeFirst: dart.functionType(E, []),
+        removeLast: dart.functionType(E, []),
+        [_checkModification]: dart.functionType(dart.void, [core.int]),
+        [_add]: dart.functionType(dart.void, [E]),
+        [_remove]: dart.functionType(core.int, [core.int]),
+        [_grow]: dart.functionType(dart.void, []),
+        [_writeToList]: dart.functionType(core.int, [core.List$(E)]),
+        [_preGrow]: dart.functionType(dart.void, [core.int])
+      }),
+      statics: () => ({
+        _isPowerOf2: dart.functionType(core.bool, [core.int]),
+        _nextPowerOf2: dart.functionType(core.int, [core.int])
+      }),
+      names: ['_isPowerOf2', '_nextPowerOf2']
+    });
     return ListQueue;
   });
   let ListQueue = ListQueue$();
   ListQueue._INITIAL_CAPACITY = 8;
   let _queue = Symbol('_queue');
   let _end = Symbol('_end');
   let _position = Symbol('_position');
   let _ListQueueIterator$ = dart.generic(function(E) {
     class _ListQueueIterator extends core.Object {
       _ListQueueIterator(queue) {
@@ skipping 11 matching lines @@
         if (this[_position] == this[_end]) {
           this[_current] = null;
           return false;
         }
         this[_current] = dart.as(this[_queue][_table][core.$get](this[_position]), E);
         this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][core.$length]) - 1;
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(_ListQueueIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return _ListQueueIterator;
   });
   let _ListQueueIterator = _ListQueueIterator$();
   let _Predicate$ = dart.generic(function(T) {
     let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   let _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
     }
+    dart.setSignature(_SplayTreeNode, {});
     return _SplayTreeNode;
   });
   let _SplayTreeNode = _SplayTreeNode$();
   let _SplayTreeMapNode$ = dart.generic(function(K, V) {
     class _SplayTreeMapNode extends _SplayTreeNode$(K) {
       _SplayTreeMapNode(key, value) {
         this.value = value;
         super._SplayTreeNode(key);
       }
     }
+    dart.setSignature(_SplayTreeMapNode, {});
     return _SplayTreeMapNode;
   });
   let _SplayTreeMapNode = _SplayTreeMapNode$();
   let _dummy = Symbol('_dummy');
   let _root = Symbol('_root');
   let _count = Symbol('_count');
   let _splayCount = Symbol('_splayCount');
   let _splay = Symbol('_splay');
   let _compare = Symbol('_compare');
   let _splayMin = Symbol('_splayMin');
@@ skipping 136 matching lines @@
           return null;
         this[_root] = this[_splayMax](this[_root]);
         return this[_root];
       }
       [_clear]() {
         this[_root] = null;
         this[_count] = 0;
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
     }
+    dart.setSignature(_SplayTree, {
+      methods: () => ({
+        [_splay]: dart.functionType(core.int, [K]),
+        [_splayMin]: dart.functionType(_SplayTreeNode$(K), [_SplayTreeNode$(K)]),
+        [_splayMax]: dart.functionType(_SplayTreeNode$(K), [_SplayTreeNode$(K)]),
+        [_remove]: dart.functionType(_SplayTreeNode, [K]),
+        [_addNewRoot]: dart.functionType(dart.void, [_SplayTreeNode$(K), core.int]),
+        [_clear]: dart.functionType(dart.void, [])
+      })
+    });
     return _SplayTree;
   });
   let _SplayTree = _SplayTree$();
   let _comparator = Symbol('_comparator');
   let _validKey = Symbol('_validKey');
   let SplayTreeMap$ = dart.generic(function(K, V) {
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? dart.bind(core.Comparable, 'compare') : compare, core.Comparator$(K));
-        this[_validKey] = isValidKey != null ? isValidKey : v => dart.is(v, K);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
       from(other, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeMap$(K, V))();
-        other.forEach((k, v) => {
+        other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
-        });
+        }));
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let compare = opts && 'compare' in opts ? opts.compare : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
@@ skipping 70 matching lines @@
         }
         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) => {
+        other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this));
+        }).bind(this), dart.dynamic, [K, V]));
       }
       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() {
         this[_clear]();
       }
       containsKey(key) {
         return dart.notNull(this[_validKey](key)) && this[_splay](dart.as(key, K)) == 0;
       }
       containsValue(value) {
         let found = false;
         let initialSplayCount = this[_splayCount];
-        // Function visit: (_SplayTreeMapNode<dynamic, dynamic>) → bool
         let visit = (node => {
           while (node != null) {
             if (dart.equals(node.value, value))
               return true;
             if (initialSplayCount != this[_splayCount]) {
               throw new core.ConcurrentModificationError(this);
             }
             if (dart.notNull(node.right != null) && dart.notNull(visit(dart.as(node.right, _SplayTreeMapNode))))
               return true;
             node = dart.as(node.left, _SplayTreeMapNode);
           }
           return false;
         }).bind(this);
+        dart.fn(visit, core.bool, [_SplayTreeMapNode]);
         return visit(dart.as(this[_root], _SplayTreeMapNode));
       }
       get keys() {
         return new (_SplayTreeKeyIterable$(K))(this);
       }
       get values() {
         return new (_SplayTreeValueIterable$(K, V))(this);
       }
       toString() {
         return Maps.mapToString(this);
@@ skipping 41 matching lines @@
           node = node.left;
         }
         return node.key;
       }
     }
     SplayTreeMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(SplayTreeMap, 'from');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterable');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterables');
     dart.defineNamedConstructor(SplayTreeMap, '_internal');
+    dart.setSignature(SplayTreeMap, {
+      methods: () => ({
+        [_compare]: dart.functionType(core.int, [K, K]),
+        get: dart.functionType(V, [core.Object]),
+        remove: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])]),
+        clear: dart.functionType(dart.void, []),
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        containsValue: dart.functionType(core.bool, [core.Object]),
+        toString: dart.functionType(core.String, []),
+        firstKey: dart.functionType(K, []),
+        lastKey: dart.functionType(K, []),
+        lastKeyBefore: dart.functionType(K, [K]),
+        firstKeyAfter: dart.functionType(K, [K])
+      })
+    });
     return SplayTreeMap;
   });
   let SplayTreeMap = SplayTreeMap$();
   let _workList = Symbol('_workList');
   let _tree = Symbol('_tree');
   let _currentNode = Symbol('_currentNode');
   let _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
   let _getValue = Symbol('_getValue');
   let _rebuildWorkList = Symbol('_rebuildWorkList');
   let _SplayTreeIterator$ = dart.generic(function(T) {
@@ skipping 55 matching lines @@
         if (this[_tree][_splayCount] != this[_splayCount] && dart.notNull(this[_currentNode] != null)) {
           this[_rebuildWorkList](this[_currentNode]);
         }
         this[_currentNode] = this[_workList][core.$removeLast]();
         this[_findLeftMostDescendent](this[_currentNode].right);
         return true;
       }
     }
     _SplayTreeIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.defineNamedConstructor(_SplayTreeIterator, 'startAt');
+    dart.setSignature(_SplayTreeIterator, {
+      methods: () => ({
+        [_findLeftMostDescendent]: dart.functionType(dart.void, [_SplayTreeNode]),
+        [_rebuildWorkList]: dart.functionType(dart.void, [_SplayTreeNode]),
+        moveNext: dart.functionType(core.bool, [])
+      })
+    });
     return _SplayTreeIterator;
   });
   let _SplayTreeIterator = _SplayTreeIterator$();
   let _copyNode = Symbol('_copyNode');
   let _SplayTreeKeyIterable$ = dart.generic(function(K) {
     class _SplayTreeKeyIterable extends IterableBase$(K) {
       _SplayTreeKeyIterable(tree) {
         this[_tree] = tree;
         super.IterableBase();
       }
       get [core.$length]() {
         return this[_tree][_count];
       }
       get [core.$isEmpty]() {
         return this[_tree][_count] == 0;
       }
       get [core.$iterator]() {
         return new (_SplayTreeKeyIterator$(K))(this[_tree]);
       }
       [core.$toSet]() {
         let setOrMap = this[_tree];
         let set = new (SplayTreeSet$(K))(dart.as(setOrMap[_comparator], __CastType0), dart.as(setOrMap[_validKey], __CastType3));
         set[_count] = this[_tree][_count];
         set[_root] = set[_copyNode](this[_tree][_root]);
         return set;
       }
     }
     _SplayTreeKeyIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_SplayTreeKeyIterable, {
+      methods: () => ({[core.$toSet]: dart.functionType(core.Set$(K), [])})
+    });
     return _SplayTreeKeyIterable;
   });
   let _SplayTreeKeyIterable = _SplayTreeKeyIterable$();
   let _SplayTreeValueIterable$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterable extends IterableBase$(V) {
       _SplayTreeValueIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$length]() {
         return this[_map][_count];
       }
       get [core.$isEmpty]() {
         return this[_map][_count] == 0;
       }
       get [core.$iterator]() {
         return new (_SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_SplayTreeValueIterable, {});
     return _SplayTreeValueIterable;
   });
   let _SplayTreeValueIterable = _SplayTreeValueIterable$();
   let _SplayTreeKeyIterator$ = dart.generic(function(K) {
     class _SplayTreeKeyIterator extends _SplayTreeIterator$(K) {
       _SplayTreeKeyIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.key, K);
       }
     }
+    dart.setSignature(_SplayTreeKeyIterator, {
+      methods: () => ({[_getValue]: dart.functionType(K, [_SplayTreeNode])})
+    });
     return _SplayTreeKeyIterator;
   });
   let _SplayTreeKeyIterator = _SplayTreeKeyIterator$();
   let _SplayTreeValueIterator$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterator extends _SplayTreeIterator$(V) {
       _SplayTreeValueIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.value, V);
       }
     }
+    dart.setSignature(_SplayTreeValueIterator, {
+      methods: () => ({[_getValue]: dart.functionType(V, [_SplayTreeMapNode])})
+    });
     return _SplayTreeValueIterator;
   });
   let _SplayTreeValueIterator = _SplayTreeValueIterator$();
   let _SplayTreeNodeIterator$ = dart.generic(function(K) {
     class _SplayTreeNodeIterator extends _SplayTreeIterator$(_SplayTreeNode$(K)) {
       _SplayTreeNodeIterator(tree) {
         super._SplayTreeIterator(tree);
       }
       startAt(tree, startKey) {
         super.startAt(tree, startKey);
       }
       [_getValue](node) {
         return dart.as(node, _SplayTreeNode$(K));
       }
     }
     dart.defineNamedConstructor(_SplayTreeNodeIterator, 'startAt');
+    dart.setSignature(_SplayTreeNodeIterator, {
+      methods: () => ({[_getValue]: dart.functionType(_SplayTreeNode$(K), [_SplayTreeNode])})
+    });
     return _SplayTreeNodeIterator;
   });
   let _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
   let _clone = Symbol('_clone');
   let SplayTreeSet$ = dart.generic(function(E) {
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? dart.bind(core.Comparable, 'compare') : compare, core.Comparator$(E));
-        this[_validKey] = isValidKey != null ? isValidKey : v => dart.is(v, E);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
       from(elements, compare, isValidKey) {
         if (compare === void 0)
           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);
@@ skipping 130 matching lines @@
         this[_clear]();
       }
       [core.$toSet]() {
         return this[_clone]();
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     dart.defineNamedConstructor(SplayTreeSet, 'from');
+    dart.setSignature(SplayTreeSet, {
+      methods: () => ({
+        [_compare]: dart.functionType(core.int, [E, E]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        add: dart.functionType(core.bool, [E]),
+        remove: dart.functionType(core.bool, [core.Object]),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        removeAll: dart.functionType(dart.void, [core.Iterable$(core.Object)]),
+        retainAll: dart.functionType(dart.void, [core.Iterable$(core.Object)]),
+        lookup: dart.functionType(E, [core.Object]),
+        intersection: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        difference: dart.functionType(core.Set$(E), [core.Set$(core.Object)]),
+        union: dart.functionType(core.Set$(E), [core.Set$(E)]),
+        [_clone]: dart.functionType(SplayTreeSet$(E), []),
+        [_copyNode]: dart.functionType(_SplayTreeNode$(E), [_SplayTreeNode$(E)]),
+        clear: dart.functionType(dart.void, []),
+        [core.$toSet]: dart.functionType(core.Set$(E), []),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     return SplayTreeSet;
   });
   let SplayTreeSet = SplayTreeSet$();
   let __CastType0$ = dart.generic(function(K) {
     let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.int, [K, K]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
   let __CastType3 = dart.typedef('__CastType3', () => dart.functionType(core.bool, [core.Object]));
   let _strings = Symbol('_strings');
@@ skipping 23 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (HashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, (each => this.get(each)).bind(this));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [dart.dynamic]));
       }
       containsKey(key) {
         if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           return strings == null ? false : _HashMap$()._hasTableEntry(strings, key);
         } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           return nums == null ? false : _HashMap$()._hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         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));
+        return this[_computeKeys]()[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [dart.dynamic]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        other.forEach(((key, value) => {
+        other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this));
+        }).bind(this), dart.dynamic, [K, V]));
       }
       get(key) {
         if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           return strings == null ? null : dart.as(_HashMap$()._getTableEntry(strings, key), V);
         } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           return nums == null ? null : dart.as(_HashMap$()._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
@@ skipping 200 matching lines @@
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashMap$()._setTableEntry(table, temporaryKey, table);
         _HashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashMap[dart.implements] = () => [HashMap$(K, V)];
+    dart.setSignature(_HashMap, {
+      methods: () => ({
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        [_containsKey]: dart.functionType(core.bool, [core.Object]),
+        containsValue: dart.functionType(core.bool, [core.Object]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        get: dart.functionType(V, [core.Object]),
+        [_get]: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        [_set]: dart.functionType(dart.void, [K, V]),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
+        remove: dart.functionType(V, [core.Object]),
+        [_remove]: dart.functionType(V, [core.Object]),
+        clear: dart.functionType(dart.void, []),
+        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])]),
+        [_computeKeys]: dart.functionType(core.List, []),
+        [_addHashTableEntry]: dart.functionType(dart.void, [dart.dynamic, K, V]),
+        [_removeHashTableEntry]: dart.functionType(V, [dart.dynamic, core.Object]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_getBucket]: dart.functionType(core.List, [dart.dynamic, dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      }),
+      statics: () => ({
+        _isStringKey: dart.functionType(core.bool, [dart.dynamic]),
+        _isNumericKey: dart.functionType(core.bool, [dart.dynamic]),
+        _hasTableEntry: dart.functionType(core.bool, [dart.dynamic, dart.dynamic]),
+        _getTableEntry: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]),
+        _setTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
+        _deleteTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+        _newHashTable: dart.functionType(dart.dynamic, [])
+      }),
+      names: ['_isStringKey', '_isNumericKey', '_hasTableEntry', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
+    });
     return _HashMap;
   });
   let _HashMap = _HashMap$();
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _IdentityHashMap() {
         super._HashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
           if (core.identical(bucket[i], key))
             return i;
         }
         return -1;
       }
     }
+    dart.setSignature(_IdentityHashMap, {
+      methods: () => ({
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      })
+    });
     return _IdentityHashMap;
   });
   let _IdentityHashMap = _IdentityHashMap$();
   let _equals = Symbol('_equals');
   let _hashCode = Symbol('_hashCode');
   let _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
       _CustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
-        this[_validKey] = validKey != null ? validKey : v => dart.is(v, K);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._HashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 19 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
           if (this[_equals](dart.as(bucket[i], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
+    dart.setSignature(_CustomHashMap, {
+      methods: () => ({
+        get: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        remove: dart.functionType(V, [core.Object]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic]),
+        toString: dart.functionType(core.String, [])
+      })
+    });
     return _CustomHashMap;
   });
   let _CustomHashMap = _CustomHashMap$();
   let HashMapKeyIterable$ = dart.generic(function(E) {
     class HashMapKeyIterable extends IterableBase$(E) {
       HashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$length]() {
@@ skipping 13 matching lines @@
         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];
+    dart.setSignature(HashMapKeyIterable, {
+      methods: () => ({
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])])
+      })
+    });
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$();
   let _offset = Symbol('_offset');
   let HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map, keys) {
         this[_map] = map;
         this[_keys] = keys;
         this[_offset] = 0;
@@ skipping 11 matching lines @@
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(HashMapKeyIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return HashMapKeyIterator;
   });
   let HashMapKeyIterator = HashMapKeyIterator$();
   let _modifications = Symbol('_modifications');
   let _value = Symbol('_value');
   let _newLinkedCell = Symbol('_newLinkedCell');
   let _unlinkCell = Symbol('_unlinkCell');
   let _modified = Symbol('_modified');
   let _key = Symbol('_key');
   let _LinkedHashMap$ = dart.generic(function(K, V) {
@@ skipping 13 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (LinkedHashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, (each => this.get(each)).bind(this));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [dart.dynamic]));
       }
       containsKey(key) {
         if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell != null;
         } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             return false;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(nums, key), LinkedHashMapCell);
           return cell != null;
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         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));
+        return this.keys[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [dart.dynamic]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        other.forEach(((key, value) => {
+        other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this));
+        }).bind(this), dart.dynamic, [K, V]));
       }
       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 cell == null ? null : dart.as(cell[_value], V);
         } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
@@ skipping 199 matching lines @@
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashMap$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     _LinkedHashMap[dart.implements] = () => [LinkedHashMap$(K, V), _js_helper.InternalMap];
+    dart.setSignature(_LinkedHashMap, {
+      methods: () => ({
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        [_containsKey]: dart.functionType(core.bool, [core.Object]),
+        containsValue: dart.functionType(core.bool, [core.Object]),
+        addAll: dart.functionType(dart.void, [core.Map$(K, V)]),
+        get: dart.functionType(V, [core.Object]),
+        [_get]: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        [_set]: dart.functionType(dart.void, [K, V]),
+        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
+        remove: dart.functionType(V, [core.Object]),
+        [_remove]: dart.functionType(V, [core.Object]),
+        clear: dart.functionType(dart.void, []),
+        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])]),
+        [_addHashTableEntry]: dart.functionType(dart.void, [dart.dynamic, K, V]),
+        [_removeHashTableEntry]: dart.functionType(V, [dart.dynamic, core.Object]),
+        [_modified]: dart.functionType(dart.void, []),
+        [_newLinkedCell]: dart.functionType(LinkedHashMapCell, [K, V]),
+        [_unlinkCell]: dart.functionType(dart.void, [LinkedHashMapCell]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_getBucket]: dart.functionType(core.List, [dart.dynamic, dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic]),
+        toString: dart.functionType(core.String, [])
+      }),
+      statics: () => ({
+        _isStringKey: dart.functionType(core.bool, [dart.dynamic]),
+        _isNumericKey: dart.functionType(core.bool, [dart.dynamic]),
+        _getTableEntry: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]),
+        _setTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
+        _deleteTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+        _newHashTable: dart.functionType(dart.dynamic, [])
+      }),
+      names: ['_isStringKey', '_isNumericKey', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
+    });
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$();
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       _LinkedIdentityHashMap() {
         super._LinkedHashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (core.identical(cell[_key], key))
             return i;
         }
         return -1;
       }
     }
+    dart.setSignature(_LinkedIdentityHashMap, {
+      methods: () => ({
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      })
+    });
     return _LinkedIdentityHashMap;
   });
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
       _LinkedCustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
-        this[_validKey] = validKey != null ? validKey : v => dart.is(v, K);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 17 matching lines @@
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (this[_equals](dart.as(cell[_key], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
     }
+    dart.setSignature(_LinkedCustomHashMap, {
+      methods: () => ({
+        get: dart.functionType(V, [core.Object]),
+        set: dart.functionType(dart.void, [K, V]),
+        containsKey: dart.functionType(core.bool, [core.Object]),
+        remove: dart.functionType(V, [core.Object]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      })
+    });
     return _LinkedCustomHashMap;
   });
   let _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(LinkedHashMapCell, {});
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
       LinkedHashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$length]() {
         return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get [core.$isEmpty]() {
@@ skipping 12 matching lines @@
         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];
         }
       }
     }
     LinkedHashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(LinkedHashMapKeyIterable, {
+      methods: () => ({
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])])
+      })
+    });
     return LinkedHashMapKeyIterable;
   });
   let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
   let _cell = Symbol('_cell');
   let LinkedHashMapKeyIterator$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map, modifications) {
         this[_map] = map;
         this[_modifications] = modifications;
         this[_cell] = null;
@@ skipping 10 matching lines @@
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(LinkedHashMapKeyIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return LinkedHashMapKeyIterator;
   });
   let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$();
   let _elements = Symbol('_elements');
   let _computeElements = Symbol('_computeElements');
   let _contains = Symbol('_contains');
   let _lookup = Symbol('_lookup');
   let _HashSet$ = dart.generic(function(E) {
     class _HashSet extends _HashSetBase$(E) {
       _HashSet() {
@@ skipping 218 matching lines @@
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashSet$()._setTableEntry(table, temporaryKey, table);
         _HashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashSet[dart.implements] = () => [HashSet$(E)];
+    dart.setSignature(_HashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [_contains]: dart.functionType(core.bool, [core.Object]),
+        lookup: dart.functionType(E, [core.Object]),
+        [_lookup]: dart.functionType(E, [core.Object]),
+        add: dart.functionType(core.bool, [E]),
+        [_add]: dart.functionType(core.bool, [E]),
+        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
+        remove: dart.functionType(core.bool, [core.Object]),
+        [_remove]: dart.functionType(core.bool, [core.Object]),
+        clear: dart.functionType(dart.void, []),
+        [_computeElements]: dart.functionType(core.List, []),
+        [_addHashTableEntry]: dart.functionType(core.bool, [dart.dynamic, E]),
+        [_removeHashTableEntry]: dart.functionType(core.bool, [dart.dynamic, core.Object]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_getBucket]: dart.functionType(core.List, [dart.dynamic, dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      }),
+      statics: () => ({
+        _isStringElement: dart.functionType(core.bool, [dart.dynamic]),
+        _isNumericElement: dart.functionType(core.bool, [dart.dynamic]),
+        _hasTableEntry: dart.functionType(core.bool, [dart.dynamic, dart.dynamic]),
+        _setTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
+        _deleteTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+        _newHashTable: dart.functionType(dart.dynamic, [])
+      }),
+      names: ['_isStringElement', '_isNumericElement', '_hasTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
+    });
     return _HashSet;
   });
   let _HashSet = _HashSet$();
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       _IdentityHashSet() {
         super._HashSet();
       }
       [_newSet]() {
         return new (_IdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (core.identical(bucket[i], element))
             return i;
         }
         return -1;
       }
     }
+    dart.setSignature(_IdentityHashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      })
+    });
     return _IdentityHashSet;
   });
   let _IdentityHashSet = _IdentityHashSet$();
   let _equality = Symbol('_equality');
   let _hasher = Symbol('_hasher');
   let _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
-        this[_validKey] = validKey != null ? validKey : x => dart.is(x, E);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._HashSet();
       }
       [_newSet]() {
         return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 18 matching lines @@
         if (!dart.notNull(this[_validKey](object)))
           return null;
         return super[_lookup](object);
       }
       remove(object) {
         if (!dart.notNull(this[_validKey](object)))
           return false;
         return super[_remove](object);
       }
     }
+    dart.setSignature(_CustomHashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        add: dart.functionType(core.bool, [E]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        lookup: dart.functionType(E, [core.Object]),
+        remove: dart.functionType(core.bool, [core.Object])
+      })
+    });
     return _CustomHashSet;
   });
   let _CustomHashSet = _CustomHashSet$();
   let HashSetIterator$ = dart.generic(function(E) {
     class HashSetIterator extends core.Object {
       HashSetIterator(set, elements) {
         this[_set] = set;
         this[_elements] = elements;
         this[_offset] = 0;
         this[_current] = null;
@@ skipping 10 matching lines @@
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(elements[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashSetIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(HashSetIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return HashSetIterator;
   });
   let HashSetIterator = HashSetIterator$();
   let _unsupported = Symbol('_unsupported');
   let _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
@@ skipping 259 matching lines @@
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashSet$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _LinkedHashSet[dart.implements] = () => [LinkedHashSet$(E)];
+    dart.setSignature(_LinkedHashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [_unsupported]: dart.functionType(dart.void, [core.String]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        [_contains]: dart.functionType(core.bool, [core.Object]),
+        lookup: dart.functionType(E, [core.Object]),
+        [_lookup]: dart.functionType(E, [core.Object]),
+        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        add: dart.functionType(core.bool, [E]),
+        [_add]: dart.functionType(core.bool, [E]),
+        remove: dart.functionType(core.bool, [core.Object]),
+        [_remove]: dart.functionType(core.bool, [core.Object]),
+        removeWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        retainWhere: dart.functionType(dart.void, [dart.functionType(core.bool, [E])]),
+        [_filterWhere]: dart.functionType(dart.void, [dart.functionType(core.bool, [E]), core.bool]),
+        clear: dart.functionType(dart.void, []),
+        [_addHashTableEntry]: dart.functionType(core.bool, [dart.dynamic, E]),
+        [_removeHashTableEntry]: dart.functionType(core.bool, [dart.dynamic, core.Object]),
+        [_modified]: dart.functionType(dart.void, []),
+        [_newLinkedCell]: dart.functionType(LinkedHashSetCell, [E]),
+        [_unlinkCell]: dart.functionType(dart.void, [LinkedHashSetCell]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_getBucket]: dart.functionType(core.List, [dart.dynamic, dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      }),
+      statics: () => ({
+        _isStringElement: dart.functionType(core.bool, [dart.dynamic]),
+        _isNumericElement: dart.functionType(core.bool, [dart.dynamic]),
+        _getTableEntry: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]),
+        _setTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
+        _deleteTableEntry: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+        _newHashTable: dart.functionType(dart.dynamic, [])
+      }),
+      names: ['_isStringElement', '_isNumericElement', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
+    });
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$();
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       _LinkedIdentityHashSet() {
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedIdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (core.identical(cell[_element], element))
             return i;
         }
         return -1;
       }
     }
+    dart.setSignature(_LinkedIdentityHashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic])
+      })
+    });
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
   let _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
-        this[_validKey] = validKey != null ? validKey : x => dart.is(x, E);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 33 matching lines @@
         return true;
       }
       removeAll(elements) {
         for (let element of elements) {
           if (this[_validKey](element)) {
             super[_remove](element);
           }
         }
       }
     }
+    dart.setSignature(_LinkedCustomHashSet, {
+      methods: () => ({
+        [_newSet]: dart.functionType(core.Set$(E), []),
+        [_findBucketIndex]: dart.functionType(core.int, [dart.dynamic, dart.dynamic]),
+        [_computeHashCode]: dart.functionType(core.int, [dart.dynamic]),
+        add: dart.functionType(core.bool, [E]),
+        [core.$contains]: dart.functionType(core.bool, [core.Object]),
+        lookup: dart.functionType(E, [core.Object]),
+        remove: dart.functionType(core.bool, [core.Object]),
+        containsAll: dart.functionType(core.bool, [core.Iterable$(core.Object)]),
+        removeAll: dart.functionType(dart.void, [core.Iterable$(core.Object)])
+      })
+    });
     return _LinkedCustomHashSet;
   });
   let _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(LinkedHashSetCell, {});
   let LinkedHashSetIterator$ = dart.generic(function(E) {
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set, modifications) {
         this[_set] = set;
         this[_modifications] = modifications;
         this[_cell] = null;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_set], _first), LinkedHashSetCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (!dart.equals(this[_modifications], dart.dload(this[_set], _modifications))) {
           throw new core.ConcurrentModificationError(this[_set]);
         } else if (this[_cell] == null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_element], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashSetIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(LinkedHashSetIterator, {
+      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    });
     return LinkedHashSetIterator;
   });
   let LinkedHashSetIterator = LinkedHashSetIterator$();
   // Exports:
   exports.UnmodifiableListView$ = UnmodifiableListView$;
   exports.HashMap$ = HashMap$;
   exports.HashMap = HashMap;
   exports.SetMixin$ = SetMixin$;
   exports.SetMixin = SetMixin;
   exports.SetBase$ = SetBase$;
@@ skipping 49 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, _internal, core, _js_helper, math);