Use short array syntax in method signatures

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])})
+      methods: () => ({[core.$get]: [E, [core.int]]})
     });
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
     return dart.hashCode(a);
@@ skipping 336 matching lines @@
           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])
+        clear: [dart.void, []],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        removeAll: [dart.void, [core.Iterable$(core.Object)]],
+        retainAll: [dart.void, [core.Iterable$(core.Object)]],
+        removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        containsAll: [core.bool, [core.Iterable$(core.Object)]],
+        union: [core.Set$(E), [core.Set$(E)]],
+        intersection: [core.Set$(E), [core.Set$(core.Object)]],
+        difference: [core.Set$(E), [core.Set$(core.Object)]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
+        [core.$map]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        toString: [core.String, []],
+        [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$expand]: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$reduce]: [E, [dart.functionType(E, [E, E])]],
+        [core.$fold]: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
+        [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$join]: [core.String, [], [core.String]],
+        [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$take]: [core.Iterable$(E), [core.int]],
+        [core.$takeWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$skip]: [core.Iterable$(E), [core.int]],
+        [core.$skipWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])]],
+        [core.$elementAt]: [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])}),
+      statics: () => ({setToString: [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]();
@@ skipping 14 matching lines @@
       [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), [])
+        difference: [core.Set$(E), [core.Set$(core.Object)]],
+        intersection: [core.Set$(E), [core.Set$(core.Object)]],
+        [core.$toSet]: [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;
@@ skipping 248 matching lines @@
       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, [])
+        [core.$map]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$expand]: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
+        [core.$contains]: [core.bool, [core.Object]],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$reduce]: [E, [dart.functionType(E, [E, E])]],
+        [core.$fold]: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
+        [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$join]: [core.String, [], [core.String]],
+        [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
+        [core.$toSet]: [core.Set$(E), []],
+        [core.$take]: [core.Iterable$(E), [core.int]],
+        [core.$takeWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$skip]: [core.Iterable$(E), [core.int]],
+        [core.$skipWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])]],
+        [core.$elementAt]: [E, [core.int]],
+        toString: [core.String, []]
       })
     });
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       [core.$map](f) {
@@ skipping 330 matching lines @@
         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, [])
+        [core.$map]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$expand]: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
+        [core.$contains]: [core.bool, [core.Object]],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$reduce]: [E, [dart.functionType(E, [E, E])]],
+        [core.$fold]: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
+        [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$join]: [core.String, [], [core.String]],
+        [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
+        [core.$toSet]: [core.Set$(E), []],
+        [core.$take]: [core.Iterable$(E), [core.int]],
+        [core.$takeWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$skip]: [core.Iterable$(E), [core.int]],
+        [core.$skipWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])]],
+        [core.$elementAt]: [E, [core.int]],
+        toString: [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])
+        iterableToShortString: [core.String, [core.Iterable], [core.String, core.String]],
+        iterableToFullString: [core.String, [core.Iterable], [core.String, core.String]],
+        _isToStringVisiting: [core.bool, [core.Object]],
+        _iterablePartsToStrings: [dart.void, [core.Iterable, core.List]]
       }),
       names: ['iterableToShortString', 'iterableToFullString', '_isToStringVisiting', '_iterablePartsToStrings']
     });
     return IterableBase;
   });
   let IterableBase = IterableBase$();
   dart.defineLazyProperties(IterableBase, {
     get _toStringVisiting() {
       return [];
     }
@@ skipping 23 matching lines @@
       [_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, [])
+        next: [E, []],
+        [_move]: [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 {
@@ skipping 225 matching lines @@
         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)])
+        addFirst: [dart.void, [E]],
+        add: [dart.void, [E]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        remove: [core.bool, [E]],
+        clear: [dart.void, []],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [_insertAfter]: [dart.void, [_LinkedListLink, E]],
+        [_unlink]: [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;
@@ skipping 12 matching lines @@
         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, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return _LinkedListIterator;
   });
   let _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
@@ skipping 27 matching lines @@
         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])
+        unlink: [dart.void, []],
+        insertAfter: [dart.void, [E]],
+        insertBefore: [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);
       }
@@ skipping 471 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, [])
+        [core.$elementAt]: [E, [core.int]],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$contains]: [core.bool, [core.Object]],
+        [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
+        [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
+        [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])]],
+        [core.$join]: [core.String, [], [core.String]],
+        [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$map]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        [core.$expand]: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
+        [core.$reduce]: [E, [dart.functionType(E, [E, E])]],
+        [core.$fold]: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
+        [core.$skip]: [core.Iterable$(E), [core.int]],
+        [core.$skipWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$take]: [core.Iterable$(E), [core.int]],
+        [core.$takeWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
+        [core.$toSet]: [core.Set$(E), []],
+        [core.$add]: [dart.void, [E]],
+        [core.$addAll]: [dart.void, [core.Iterable$(E)]],
+        [core.$remove]: [core.bool, [core.Object]],
+        [core.$removeWhere]: [dart.void, [dart.functionType(core.bool, [E])]],
+        [core.$retainWhere]: [dart.void, [dart.functionType(core.bool, [E])]],
+        [core.$clear]: [dart.void, []],
+        [core.$removeLast]: [E, []],
+        [core.$sort]: [dart.void, [], [dart.functionType(core.int, [E, E])]],
+        [core.$shuffle]: [dart.void, [], [math.Random]],
+        [core.$asMap]: [core.Map$(core.int, E), []],
+        [core.$sublist]: [core.List$(E), [core.int], [core.int]],
+        [core.$getRange]: [core.Iterable$(E), [core.int, core.int]],
+        [core.$removeRange]: [dart.void, [core.int, core.int]],
+        [core.$fillRange]: [dart.void, [core.int, core.int], [E]],
+        [core.$setRange]: [dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]],
+        [core.$replaceRange]: [dart.void, [core.int, core.int, core.Iterable$(E)]],
+        [core.$indexOf]: [core.int, [core.Object], [core.int]],
+        [core.$lastIndexOf]: [core.int, [core.Object], [core.int]],
+        [core.$insert]: [dart.void, [core.int, E]],
+        [core.$removeAt]: [E, [core.int]],
+        [core.$insertAll]: [dart.void, [core.int, core.Iterable$(E)]],
+        [core.$setAll]: [dart.void, [core.int, core.Iterable$(E)]],
+        [core.$toString]: [core.String, []]
       }),
-      statics: () => ({_filter: dart.functionType(dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic]), core.bool])}),
+      statics: () => ({_filter: [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])}),
+      statics: () => ({listToString: [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) {
@@ skipping 36 matching lines @@
       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, [])
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        containsValue: [core.bool, [core.Object]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        containsKey: [core.bool, [core.Object]],
+        toString: [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$();
@@ skipping 16 matching lines @@
       }
       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, [])])
+        set: [dart.void, [K, V]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        clear: [dart.void, []],
+        remove: [V, [core.Object]],
+        putIfAbsent: [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$();
@@ skipping 46 matching lines @@
         }
         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, [])})
+      methods: () => ({moveNext: [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) {
@@ skipping 44 matching lines @@
       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, [])
+        get: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        clear: [dart.void, []],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        containsKey: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        remove: [V, [core.Object]],
+        toString: [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$();
@@ skipping 91 matching lines @@
         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])
+      containsValue: [core.bool, [core.Map, dart.dynamic]],
+      containsKey: [core.bool, [core.Map, dart.dynamic]],
+      putIfAbsent: [dart.dynamic, [core.Map, dart.dynamic, dart.functionType(dart.dynamic, [])]],
+      clear: [dart.dynamic, [core.Map]],
+      forEach: [dart.dynamic, [core.Map, dart.functionType(dart.void, [dart.dynamic, dart.dynamic])]],
+      getValues: [core.Iterable, [core.Map]],
+      length: [core.int, [core.Map]],
+      isEmpty: [core.bool, [core.Map]],
+      isNotEmpty: [core.bool, [core.Map]],
+      mapToString: [core.String, [core.Map]],
+      _id: [dart.dynamic, [dart.dynamic]],
+      _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic])]],
+      _fillMapWithIterables: [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);
@@ skipping 53 matching lines @@
       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), [])
+        [_link]: [dart.void, [DoubleLinkedQueueEntry$(E), DoubleLinkedQueueEntry$(E)]],
+        append: [dart.void, [E]],
+        prepend: [dart.void, [E]],
+        remove: [E, []],
+        [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []],
+        previousEntry: [DoubleLinkedQueueEntry$(E), []],
+        nextEntry: [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), [])
+        remove: [E, []],
+        [_asNonSentinelEntry]: [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) {
@@ skipping 116 matching lines @@
         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, [])
+        addLast: [dart.void, [E]],
+        addFirst: [dart.void, [E]],
+        add: [dart.void, [E]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        removeLast: [E, []],
+        removeFirst: [E, []],
+        remove: [core.bool, [core.Object]],
+        [_filter]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
+        removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        lastEntry: [DoubleLinkedQueueEntry$(E), []],
+        firstEntry: [DoubleLinkedQueueEntry$(E), []],
+        clear: [dart.void, []],
+        forEachEntry: [dart.void, [dart.functionType(dart.void, [DoubleLinkedQueueEntry$(E)])]],
+        toString: [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, [])})
+      methods: () => ({moveNext: [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');
@@ skipping 282 matching lines @@
         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])
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$elementAt]: [E, [core.int]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
+        add: [dart.void, [E]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        remove: [core.bool, [core.Object]],
+        [_filterWhere]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
+        removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        clear: [dart.void, []],
+        toString: [core.String, []],
+        addLast: [dart.void, [E]],
+        addFirst: [dart.void, [E]],
+        removeFirst: [E, []],
+        removeLast: [E, []],
+        [_checkModification]: [dart.void, [core.int]],
+        [_add]: [dart.void, [E]],
+        [_remove]: [core.int, [core.int]],
+        [_grow]: [dart.void, []],
+        [_writeToList]: [core.int, [core.List$(E)]],
+        [_preGrow]: [dart.void, [core.int]]
       }),
       statics: () => ({
-        _isPowerOf2: dart.functionType(core.bool, [core.int]),
-        _nextPowerOf2: dart.functionType(core.int, [core.int])
+        _isPowerOf2: [core.bool, [core.int]],
+        _nextPowerOf2: [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');
@@ skipping 15 matching lines @@
           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, [])})
+      methods: () => ({moveNext: [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) {
@@ skipping 167 matching lines @@
         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, [])
+        [_splay]: [core.int, [K]],
+        [_splayMin]: [_SplayTreeNode$(K), [_SplayTreeNode$(K)]],
+        [_splayMax]: [_SplayTreeNode$(K), [_SplayTreeNode$(K)]],
+        [_remove]: [_SplayTreeNode, [K]],
+        [_addNewRoot]: [dart.void, [_SplayTreeNode$(K), core.int]],
+        [_clear]: [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) {
@@ skipping 206 matching lines @@
         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])
+        [_compare]: [core.int, [K, K]],
+        get: [V, [core.Object]],
+        remove: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        clear: [dart.void, []],
+        containsKey: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        toString: [core.String, []],
+        firstKey: [K, []],
+        lastKey: [K, []],
+        lastKeyBefore: [K, [K]],
+        firstKeyAfter: [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');
@@ skipping 59 matching lines @@
         }
         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, [])
+        [_findLeftMostDescendent]: [dart.void, [_SplayTreeNode]],
+        [_rebuildWorkList]: [dart.void, [_SplayTreeNode]],
+        moveNext: [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;
@@ skipping 11 matching lines @@
       [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), [])})
+      methods: () => ({[core.$toSet]: [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();
       }
@@ skipping 15 matching lines @@
   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])})
+      methods: () => ({[_getValue]: [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])})
+      methods: () => ({[_getValue]: [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])})
+      methods: () => ({[_getValue]: [_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;
@@ skipping 146 matching lines @@
       [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, [])
+        [_compare]: [core.int, [E, E]],
+        [core.$contains]: [core.bool, [core.Object]],
+        add: [core.bool, [E]],
+        remove: [core.bool, [core.Object]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        removeAll: [dart.void, [core.Iterable$(core.Object)]],
+        retainAll: [dart.void, [core.Iterable$(core.Object)]],
+        lookup: [E, [core.Object]],
+        intersection: [core.Set$(E), [core.Set$(core.Object)]],
+        difference: [core.Set$(E), [core.Set$(core.Object)]],
+        union: [core.Set$(E), [core.Set$(E)]],
+        [_clone]: [SplayTreeSet$(E), []],
+        [_copyNode]: [_SplayTreeNode$(E), [_SplayTreeNode$(E)]],
+        clear: [dart.void, []],
+        [core.$toSet]: [core.Set$(E), []],
+        toString: [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$();
@@ skipping 277 matching lines @@
         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])
+        containsKey: [core.bool, [core.Object]],
+        [_containsKey]: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        get: [V, [core.Object]],
+        [_get]: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        [_set]: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        remove: [V, [core.Object]],
+        [_remove]: [V, [core.Object]],
+        clear: [dart.void, []],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        [_computeKeys]: [core.List, []],
+        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [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, [])
+        _isStringKey: [core.bool, [dart.dynamic]],
+        _isNumericKey: [core.bool, [dart.dynamic]],
+        _hasTableEntry: [core.bool, [dart.dynamic, dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [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])
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [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) {
@@ skipping 34 matching lines @@
             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, [])
+        get: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        containsKey: [core.bool, [core.Object]],
+        remove: [V, [core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]],
+        toString: [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();
@@ skipping 17 matching lines @@
           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])])
+        [core.$contains]: [core.bool, [core.Object]],
+        [core.$forEach]: [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;
@@ skipping 14 matching lines @@
           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, [])})
+      methods: () => ({moveNext: [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');
@@ skipping 271 matching lines @@
         _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, [])
+        containsKey: [core.bool, [core.Object]],
+        [_containsKey]: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        get: [V, [core.Object]],
+        [_get]: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        [_set]: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        remove: [V, [core.Object]],
+        [_remove]: [V, [core.Object]],
+        clear: [dart.void, []],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
+        [_modified]: [dart.void, []],
+        [_newLinkedCell]: [LinkedHashMapCell, [K, V]],
+        [_unlinkCell]: [dart.void, [LinkedHashMapCell]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]],
+        toString: [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, [])
+        _isStringKey: [core.bool, [dart.dynamic]],
+        _isNumericKey: [core.bool, [dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [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])
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [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;
@@ skipping 30 matching lines @@
         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])
+        get: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        containsKey: [core.bool, [core.Object]],
+        remove: [V, [core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [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;
@@ skipping 28 matching lines @@
           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])])
+        [core.$contains]: [core.bool, [core.Object]],
+        [core.$forEach]: [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;
@@ skipping 13 matching lines @@
           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, [])})
+      methods: () => ({moveNext: [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) {
@@ skipping 221 matching lines @@
         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])
+        [_newSet]: [core.Set$(E), []],
+        [core.$contains]: [core.bool, [core.Object]],
+        [_contains]: [core.bool, [core.Object]],
+        lookup: [E, [core.Object]],
+        [_lookup]: [E, [core.Object]],
+        add: [core.bool, [E]],
+        [_add]: [core.bool, [E]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        remove: [core.bool, [core.Object]],
+        [_remove]: [core.bool, [core.Object]],
+        clear: [dart.void, []],
+        [_computeElements]: [core.List, []],
+        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [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, [])
+        _isStringElement: [core.bool, [dart.dynamic]],
+        _isNumericElement: [core.bool, [dart.dynamic]],
+        _hasTableEntry: [core.bool, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [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();
@@ skipping 10 matching lines @@
         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])
+        [_newSet]: [core.Set$(E), []],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [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) {
@@ skipping 33 matching lines @@
         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])
+        [_newSet]: [core.Set$(E), []],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        add: [core.bool, [E]],
+        [core.$contains]: [core.bool, [core.Object]],
+        lookup: [E, [core.Object]],
+        remove: [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;
@@ skipping 13 matching lines @@
           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, [])})
+      methods: () => ({moveNext: [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;
@@ skipping 262 matching lines @@
         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])
+        [_newSet]: [core.Set$(E), []],
+        [_unsupported]: [dart.void, [core.String]],
+        [core.$contains]: [core.bool, [core.Object]],
+        [_contains]: [core.bool, [core.Object]],
+        lookup: [E, [core.Object]],
+        [_lookup]: [E, [core.Object]],
+        [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        add: [core.bool, [E]],
+        [_add]: [core.bool, [E]],
+        remove: [core.bool, [core.Object]],
+        [_remove]: [core.bool, [core.Object]],
+        removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        [_filterWhere]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
+        clear: [dart.void, []],
+        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
+        [_modified]: [dart.void, []],
+        [_newLinkedCell]: [LinkedHashSetCell, [E]],
+        [_unlinkCell]: [dart.void, [LinkedHashSetCell]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [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, [])
+        _isStringElement: [core.bool, [dart.dynamic]],
+        _isNumericElement: [core.bool, [dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [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();
@@ skipping 11 matching lines @@
         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])
+        [_newSet]: [core.Set$(E), []],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_findBucketIndex]: [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;
@@ skipping 46 matching lines @@
       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)])
+        [_newSet]: [core.Set$(E), []],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        add: [core.bool, [E]],
+        [core.$contains]: [core.bool, [core.Object]],
+        lookup: [E, [core.Object]],
+        remove: [core.bool, [core.Object]],
+        containsAll: [core.bool, [core.Iterable$(core.Object)]],
+        removeAll: [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;
@@ skipping 20 matching lines @@
           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, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return LinkedHashSetIterator;
   });
   let LinkedHashSetIterator = LinkedHashSetIterator$();
   // Exports:
   exports.UnmodifiableListView$ = UnmodifiableListView$;
   exports.HashMap$ = HashMap$;
   exports.HashMap = HashMap;
   exports.SetMixin$ = SetMixin$;
   exports.SetMixin = SetMixin;
@@ skipping 50 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);