Use short array syntax in method signatures

lib/runtime/dart/_internal.js

 var _internal = dart.defineLibrary(_internal, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var math = dart.lazyImport(math);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_primitives = dart.lazyImport(_js_primitives);
 (function(exports, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   class EfficientLength extends core.Object {}
   dart.setSignature(EfficientLength, {});
@@ skipping 223 matching lines @@
         let result = new (core.Set$(E))();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$elementAt](i));
         }
         return result;
       }
     }
     ListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(ListIterable, {
       methods: () => ({
-        [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.$reduce]: dart.functionType(E, [dart.functionType(E, [dart.dynamic, 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.$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.$reduce]: [E, [dart.functionType(E, [dart.dynamic, 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), []]
       })
     });
     return ListIterable;
   });
   let ListIterable = ListIterable$();
   let _iterable = dart.JsSymbol('_iterable');
   let _start = dart.JsSymbol('_start');
   let _endOrLength = dart.JsSymbol('_endOrLength');
   let _endIndex = dart.JsSymbol('_endIndex');
   let _startIndex = dart.JsSymbol('_startIndex');
@@ skipping 76 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[_iterable][core.$elementAt](dart.notNull(start) + dart.notNull(i)));
           if (dart.notNull(this[_iterable][core.$length]) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     dart.setSignature(SubListIterable, {
       methods: () => ({
-        [core.$elementAt]: dart.functionType(E, [core.int]),
-        [core.$skip]: dart.functionType(core.Iterable$(E), [core.int]),
-        [core.$take]: dart.functionType(core.Iterable$(E), [core.int]),
-        [core.$toList]: dart.functionType(core.List$(E), [], {rowabl: core.bool})
+        [core.$elementAt]: [E, [core.int]],
+        [core.$skip]: [core.Iterable$(E), [core.int]],
+        [core.$take]: [core.Iterable$(E), [core.int]],
+        [core.$toList]: [core.List$(E), [], {rowabl: core.bool}]
       })
     });
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$();
   let _length = dart.JsSymbol('_length');
   let _index = dart.JsSymbol('_index');
   let _current = dart.JsSymbol('_current');
   let ListIterator$ = dart.generic(function(E) {
     class ListIterator extends core.Object {
@@ skipping 15 matching lines @@
           this[_current] = null;
           return false;
         }
         this[_current] = this[_iterable][core.$elementAt](this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(ListIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return ListIterator;
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
     let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _f = dart.JsSymbol('_f');
@@ skipping 27 matching lines @@
       }
       get [core.$single]() {
         return this[_f](this[_iterable][core.$single]);
       }
       [core.$elementAt](index) {
         return this[_f](this[_iterable][core.$elementAt](index));
       }
     }
     dart.defineNamedConstructor(MappedIterable, '_');
     dart.setSignature(MappedIterable, {
-      methods: () => ({[core.$elementAt]: dart.functionType(T, [core.int])})
+      methods: () => ({[core.$elementAt]: [T, [core.int]]})
     });
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$();
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         super._(dart.as(iterable, core.Iterable$(S)), func);
       }
     }
@@ skipping 16 matching lines @@
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     dart.setSignature(MappedIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return MappedIterator;
   });
   let MappedIterator = MappedIterator$();
   let _source = dart.JsSymbol('_source');
   let MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f) {
         this[_source] = source;
         this[_f] = f;
         super.ListIterable();
       }
       get [core.$length]() {
         return this[_source][core.$length];
       }
       [core.$elementAt](index) {
         return this[_f](this[_source][core.$elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(MappedListIterable, {
-      methods: () => ({[core.$elementAt]: dart.functionType(T, [core.int])})
+      methods: () => ({[core.$elementAt]: [T, [core.int]]})
     });
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$();
   let _ElementPredicate$ = dart.generic(function(E) {
     let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
     return _ElementPredicate;
   });
   let _ElementPredicate = _ElementPredicate$();
   let WhereIterable$ = dart.generic(function(E) {
@@ skipping 23 matching lines @@
             return true;
           }
         }
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(WhereIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return WhereIterator;
   });
   let WhereIterator = WhereIterator$();
   let _ExpandFunction$ = dart.generic(function(S, T) {
     let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
     return _ExpandFunction;
   });
   let _ExpandFunction = _ExpandFunction$();
   let ExpandIterable$ = dart.generic(function(S, T) {
@@ skipping 37 matching lines @@
             return false;
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
     ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.setSignature(ExpandIterator, {
       methods: () => ({
-        [_nextExpansion]: dart.functionType(dart.void, []),
-        moveNext: dart.functionType(core.bool, [])
+        [_nextExpansion]: [dart.void, []],
+        moveNext: [core.bool, []]
       })
     });
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$();
   let _takeCount = dart.JsSymbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       TakeIterable(iterable, takeCount) {
         if (!(typeof takeCount == 'number') || dart.notNull(takeCount) < 0) {
@@ skipping 51 matching lines @@
         this[_remaining] = -1;
         return false;
       }
       get current() {
         if (dart.notNull(this[_remaining]) < 0)
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeIterator;
   });
   let TakeIterator = TakeIterator$();
   let TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
@@ skipping 23 matching lines @@
         }
         return true;
       }
       get current() {
         if (this[_isFinished])
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeWhileIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeWhileIterator;
   });
   let TakeWhileIterator = TakeWhileIterator$();
   let _skipCount = dart.JsSymbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
@@ skipping 15 matching lines @@
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
         return new (SkipIterable$(E))._(this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get [core.$iterator]() {
         return new (SkipIterator$(E))(this[_iterable][core.$iterator], this[_skipCount]);
       }
     }
     dart.defineNamedConstructor(SkipIterable, '_');
     dart.setSignature(SkipIterable, {
-      methods: () => ({[core.$skip]: dart.functionType(core.Iterable$(E), [core.int])})
+      methods: () => ({[core.$skip]: [core.Iterable$(E), [core.int]]})
     });
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super._(iterable, skipCount);
       }
       get [core.$length]() {
@@ skipping 19 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = dart.notNull(i) + 1)
           this[_iterator].moveNext();
         this[_skipCount] = 0;
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipIterator;
   });
   let SkipIterator = SkipIterator$();
   let SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
@@ skipping 22 matching lines @@
               return true;
           }
         }
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipWhileIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipWhileIterator;
   });
   let SkipWhileIterator = SkipWhileIterator$();
   let EmptyIterable$ = dart.generic(function(E) {
     class EmptyIterable extends collection.IterableBase$(E) {
       EmptyIterable() {
         super.IterableBase();
       }
       get [core.$iterator]() {
@@ skipping 96 matching lines @@
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return growable ? dart.setType([], core.List$(E)) : new (core.List$(E))(0);
       }
       [core.$toSet]() {
         return new (core.Set$(E))();
       }
     }
     EmptyIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EmptyIterable, {
       methods: () => ({
-        [core.$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
-        [core.$elementAt]: dart.functionType(E, [core.int]),
-        [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])], {rEls: dart.functionType(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.$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.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
+        [core.$elementAt]: [E, [core.int]],
+        [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])], {rEls: dart.functionType(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.$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), []]
       })
     });
     return EmptyIterable;
   });
   let EmptyIterable = EmptyIterable$();
   let EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(EmptyIterator, {
-      methods: () => ({moveNext: dart.functionType(core.bool, [])})
+      methods: () => ({moveNext: [core.bool, []]})
     });
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$();
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {}
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.setSignature(BidirectionalIterator, {});
     return BidirectionalIterator;
   });
@@ skipping 374 matching lines @@
         for (let element of set) {
           if (!dart.notNull(other[core.$contains](element))) {
             result.add(element);
           }
         }
         return result;
       }
     }
     dart.setSignature(IterableMixinWorkaround, {
       methods: () => ({
-        where: dart.functionType(core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        takeList: dart.functionType(core.Iterable$(T), [core.List, core.int]),
-        takeWhile: dart.functionType(core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        skipList: dart.functionType(core.Iterable$(T), [core.List, core.int]),
-        skipWhile: dart.functionType(core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        reversedList: dart.functionType(core.Iterable$(T), [core.List]),
-        getRangeList: dart.functionType(core.Iterable$(T), [core.List, core.int, core.int]),
-        asMapList: dart.functionType(core.Map$(core.int, T), [core.List])
+        where: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        takeList: [core.Iterable$(T), [core.List, core.int]],
+        takeWhile: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        skipList: [core.Iterable$(T), [core.List, core.int]],
+        skipWhile: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        reversedList: [core.Iterable$(T), [core.List]],
+        getRangeList: [core.Iterable$(T), [core.List, core.int, core.int]],
+        asMapList: [core.Map$(core.int, T), [core.List]]
       }),
       statics: () => ({
-        contains: dart.functionType(core.bool, [core.Iterable, dart.dynamic]),
-        forEach: dart.functionType(dart.void, [core.Iterable, dart.functionType(dart.void, [dart.dynamic])]),
-        any: dart.functionType(core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        every: dart.functionType(core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        reduce: dart.functionType(dart.dynamic, [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
-        fold: dart.functionType(dart.dynamic, [core.Iterable, dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
-        removeWhereList: dart.functionType(dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic])]),
-        isEmpty: dart.functionType(core.bool, [core.Iterable]),
-        first: dart.functionType(dart.dynamic, [core.Iterable]),
-        last: dart.functionType(dart.dynamic, [core.Iterable]),
-        single: dart.functionType(dart.dynamic, [core.Iterable]),
-        firstWhere: dart.functionType(dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]),
-        lastWhere: dart.functionType(dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]),
-        lastWhereList: dart.functionType(dart.dynamic, [core.List, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]),
-        singleWhere: dart.functionType(dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]),
-        elementAt: dart.functionType(dart.dynamic, [core.Iterable, core.int]),
-        join: dart.functionType(core.String, [core.Iterable], [core.String]),
-        joinList: dart.functionType(core.String, [core.List], [core.String]),
-        map: dart.functionType(core.Iterable, [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]),
-        mapList: dart.functionType(core.Iterable, [core.List, dart.functionType(dart.dynamic, [dart.dynamic])]),
-        expand: dart.functionType(core.Iterable, [core.Iterable, dart.functionType(core.Iterable, [dart.dynamic])]),
-        sortList: dart.functionType(dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]),
-        shuffleList: dart.functionType(dart.void, [core.List, math.Random]),
-        indexOfList: dart.functionType(core.int, [core.List, dart.dynamic, core.int]),
-        lastIndexOfList: dart.functionType(core.int, [core.List, dart.dynamic, core.int]),
-        _rangeCheck: dart.functionType(dart.void, [core.List, core.int, core.int]),
-        setRangeList: dart.functionType(dart.void, [core.List, core.int, core.int, core.Iterable, core.int]),
-        replaceRangeList: dart.functionType(dart.void, [core.List, core.int, core.int, core.Iterable]),
-        fillRangeList: dart.functionType(dart.void, [core.List, core.int, core.int, dart.dynamic]),
-        insertAllList: dart.functionType(dart.void, [core.List, core.int, core.Iterable]),
-        setAllList: dart.functionType(dart.void, [core.List, core.int, core.Iterable]),
-        setContainsAll: dart.functionType(core.bool, [core.Set, core.Iterable]),
-        setIntersection: dart.functionType(core.Set, [core.Set, core.Set, core.Set]),
-        setUnion: dart.functionType(core.Set, [core.Set, core.Set, core.Set]),
-        setDifference: dart.functionType(core.Set, [core.Set, core.Set, core.Set])
+        contains: [core.bool, [core.Iterable, dart.dynamic]],
+        forEach: [dart.void, [core.Iterable, dart.functionType(dart.void, [dart.dynamic])]],
+        any: [core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        every: [core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        reduce: [dart.dynamic, [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+        fold: [dart.dynamic, [core.Iterable, dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+        removeWhereList: [dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic])]],
+        isEmpty: [core.bool, [core.Iterable]],
+        first: [dart.dynamic, [core.Iterable]],
+        last: [dart.dynamic, [core.Iterable]],
+        single: [dart.dynamic, [core.Iterable]],
+        firstWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]],
+        lastWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]],
+        lastWhereList: [dart.dynamic, [core.List, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]],
+        singleWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
+        elementAt: [dart.dynamic, [core.Iterable, core.int]],
+        join: [core.String, [core.Iterable], [core.String]],
+        joinList: [core.String, [core.List], [core.String]],
+        map: [core.Iterable, [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
+        mapList: [core.Iterable, [core.List, dart.functionType(dart.dynamic, [dart.dynamic])]],
+        expand: [core.Iterable, [core.Iterable, dart.functionType(core.Iterable, [dart.dynamic])]],
+        sortList: [dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
+        shuffleList: [dart.void, [core.List, math.Random]],
+        indexOfList: [core.int, [core.List, dart.dynamic, core.int]],
+        lastIndexOfList: [core.int, [core.List, dart.dynamic, core.int]],
+        _rangeCheck: [dart.void, [core.List, core.int, core.int]],
+        setRangeList: [dart.void, [core.List, core.int, core.int, core.Iterable, core.int]],
+        replaceRangeList: [dart.void, [core.List, core.int, core.int, core.Iterable]],
+        fillRangeList: [dart.void, [core.List, core.int, core.int, dart.dynamic]],
+        insertAllList: [dart.void, [core.List, core.int, core.Iterable]],
+        setAllList: [dart.void, [core.List, core.int, core.Iterable]],
+        setContainsAll: [core.bool, [core.Set, core.Iterable]],
+        setIntersection: [core.Set, [core.Set, core.Set, core.Set]],
+        setUnion: [core.Set, [core.Set, core.Set, core.Set]],
+        setDifference: [core.Set, [core.Set, core.Set, core.Set]]
       }),
       names: ['contains', 'forEach', 'any', 'every', 'reduce', 'fold', 'removeWhereList', 'isEmpty', 'first', 'last', 'single', 'firstWhere', 'lastWhere', 'lastWhereList', 'singleWhere', 'elementAt', 'join', 'joinList', 'map', 'mapList', 'expand', 'sortList', 'shuffleList', 'indexOfList', 'lastIndexOfList', '_rangeCheck', 'setRangeList', 'replaceRangeList', 'fillRangeList', 'insertAllList', 'setAllList', 'setContainsAll', 'setIntersection', 'setUnion', 'setDifference']
     });
     return IterableMixinWorkaround;
   });
   let IterableMixinWorkaround = IterableMixinWorkaround$();
   class IterableElementError extends core.Object {
     static noElement() {
       return new core.StateError("No element");
     }
     static tooMany() {
       return new core.StateError("Too many elements");
     }
     static tooFew() {
       return new core.StateError("Too few elements");
     }
   }
   dart.setSignature(IterableElementError, {
     statics: () => ({
-      noElement: dart.functionType(core.StateError, []),
-      tooMany: dart.functionType(core.StateError, []),
-      tooFew: dart.functionType(core.StateError, [])
+      noElement: [core.StateError, []],
+      tooMany: [core.StateError, []],
+      tooFew: [core.StateError, []]
     }),
     names: ['noElement', 'tooMany', 'tooFew']
   });
   let __CastType0$ = dart.generic(function(S, T) {
     let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Iterable$(T), [S]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
   let __CastType2$ = dart.generic(function(E) {
     let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.bool, [E]));
@@ skipping 54 matching lines @@
       removeRange(start, end) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       replaceRange(start, end, iterable) {
         dart.as(iterable, core.Iterable$(E));
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
     }
     dart.setSignature(FixedLengthListMixin, {
       methods: () => ({
-        add: dart.functionType(dart.void, [E]),
-        insert: dart.functionType(dart.void, [core.int, E]),
-        insertAll: dart.functionType(dart.void, [core.int, core.Iterable$(E)]),
-        addAll: dart.functionType(dart.void, [core.Iterable$(E)]),
-        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])]),
-        clear: dart.functionType(dart.void, []),
-        removeAt: dart.functionType(E, [core.int]),
-        removeLast: dart.functionType(E, []),
-        removeRange: dart.functionType(dart.void, [core.int, core.int]),
-        replaceRange: dart.functionType(dart.void, [core.int, core.int, core.Iterable$(E)])
+        add: [dart.void, [E]],
+        insert: [dart.void, [core.int, E]],
+        insertAll: [dart.void, [core.int, core.Iterable$(E)]],
+        addAll: [dart.void, [core.Iterable$(E)]],
+        remove: [core.bool, [core.Object]],
+        removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
+        clear: [dart.void, []],
+        removeAt: [E, [core.int]],
+        removeLast: [E, []],
+        removeRange: [dart.void, [core.int, core.int]],
+        replaceRange: [dart.void, [core.int, core.int, core.Iterable$(E)]]
       })
     });
     return FixedLengthListMixin;
   });
   let FixedLengthListMixin = FixedLengthListMixin$();
   let UnmodifiableListMixin$ = dart.generic(function(E) {
     class UnmodifiableListMixin extends core.Object {
       [core.$set](index, value) {
         dart.as(value, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
@@ skipping 68 matching lines @@
       [core.$fillRange](start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
         dart.as(fillValue, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
     }
     UnmodifiableListMixin[dart.implements] = () => [core.List$(E)];
     dart.setSignature(UnmodifiableListMixin, {
       methods: () => ({
-        [core.$set]: dart.functionType(dart.void, [core.int, E]),
-        [core.$setAll]: dart.functionType(dart.void, [core.int, core.Iterable$(E)]),
-        [core.$add]: dart.functionType(dart.void, [E]),
-        [core.$insert]: dart.functionType(E, [core.int, E]),
-        [core.$insertAll]: dart.functionType(dart.void, [core.int, core.Iterable$(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.$sort]: dart.functionType(dart.void, [], [core.Comparator$(E)]),
-        [core.$shuffle]: dart.functionType(dart.void, [], [math.Random]),
-        [core.$clear]: dart.functionType(dart.void, []),
-        [core.$removeAt]: dart.functionType(E, [core.int]),
-        [core.$removeLast]: dart.functionType(E, []),
-        [core.$setRange]: dart.functionType(dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]),
-        [core.$removeRange]: dart.functionType(dart.void, [core.int, core.int]),
-        [core.$replaceRange]: dart.functionType(dart.void, [core.int, core.int, core.Iterable$(E)]),
-        [core.$fillRange]: dart.functionType(dart.void, [core.int, core.int], [E])
+        [core.$set]: [dart.void, [core.int, E]],
+        [core.$setAll]: [dart.void, [core.int, core.Iterable$(E)]],
+        [core.$add]: [dart.void, [E]],
+        [core.$insert]: [E, [core.int, E]],
+        [core.$insertAll]: [dart.void, [core.int, core.Iterable$(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.$sort]: [dart.void, [], [core.Comparator$(E)]],
+        [core.$shuffle]: [dart.void, [], [math.Random]],
+        [core.$clear]: [dart.void, []],
+        [core.$removeAt]: [E, [core.int]],
+        [core.$removeLast]: [E, []],
+        [core.$setRange]: [dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]],
+        [core.$removeRange]: [dart.void, [core.int, core.int]],
+        [core.$replaceRange]: [dart.void, [core.int, core.int, core.Iterable$(E)]],
+        [core.$fillRange]: [dart.void, [core.int, core.int], [E]]
       })
     });
     return UnmodifiableListMixin;
   });
   let UnmodifiableListMixin = UnmodifiableListMixin$();
   let FixedLengthListBase$ = dart.generic(function(E) {
     class FixedLengthListBase extends dart.mixin(collection.ListBase$(E), FixedLengthListMixin$(E)) {}
     return FixedLengthListBase;
   });
   let FixedLengthListBase = FixedLengthListBase$();
@@ skipping 10 matching lines @@
     }
     get [core.$length]() {
       return this[_backedList][core.$length];
     }
     [core.$elementAt](index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   dart.setSignature(_ListIndicesIterable, {
-    methods: () => ({[core.$elementAt]: dart.functionType(core.int, [core.int])})
+    methods: () => ({[core.$elementAt]: [core.int, [core.int]]})
   });
   let _values = dart.JsSymbol('_values');
   let ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
         this[_values] = values;
       }
       get(key) {
         return this.containsKey(key) ? this[_values][core.$get](key) : null;
       }
@@ skipping 46 matching lines @@
         dart.as(other, core.Map$(core.int, E));
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
     ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
     dart.setSignature(ListMapView, {
       methods: () => ({
-        get: dart.functionType(E, [core.Object]),
-        containsValue: dart.functionType(core.bool, [core.Object]),
-        containsKey: dart.functionType(core.bool, [core.Object]),
-        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [core.int, E])]),
-        set: dart.functionType(dart.void, [core.int, E]),
-        putIfAbsent: dart.functionType(E, [core.int, dart.functionType(E, [])]),
-        remove: dart.functionType(E, [core.Object]),
-        clear: dart.functionType(dart.void, []),
-        addAll: dart.functionType(dart.void, [core.Map$(core.int, E)]),
-        toString: dart.functionType(core.String, [])
+        get: [E, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        containsKey: [core.bool, [core.Object]],
+        forEach: [dart.void, [dart.functionType(dart.void, [core.int, E])]],
+        set: [dart.void, [core.int, E]],
+        putIfAbsent: [E, [core.int, dart.functionType(E, [])]],
+        remove: [E, [core.Object]],
+        clear: [dart.void, []],
+        addAll: [dart.void, [core.Map$(core.int, E)]],
+        toString: [core.String, []]
       })
     });
     return ListMapView;
   });
   let ListMapView = ListMapView$();
   let ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get [core.$length]() {
         return this[_source][core.$length];
       }
       [core.$elementAt](index) {
         return this[_source][core.$elementAt](dart.notNull(this[_source][core.$length]) - 1 - dart.notNull(index));
       }
     }
     dart.setSignature(ReversedListIterable, {
-      methods: () => ({[core.$elementAt]: dart.functionType(E, [core.int])})
+      methods: () => ({[core.$elementAt]: [E, [core.int]]})
     });
     return ReversedListIterable;
   });
   let ReversedListIterable = ReversedListIterable$();
   class UnmodifiableListError extends core.Object {
     static add() {
       return new core.UnsupportedError("Cannot add to unmodifiable List");
     }
     static change() {
       return new core.UnsupportedError("Cannot change the content of an unmodifiable List");
     }
     static length() {
       return new core.UnsupportedError("Cannot change length of unmodifiable List");
     }
     static remove() {
       return new core.UnsupportedError("Cannot remove from unmodifiable List");
     }
   }
   dart.setSignature(UnmodifiableListError, {
     statics: () => ({
-      add: dart.functionType(core.UnsupportedError, []),
-      change: dart.functionType(core.UnsupportedError, []),
-      length: dart.functionType(core.UnsupportedError, []),
-      remove: dart.functionType(core.UnsupportedError, [])
+      add: [core.UnsupportedError, []],
+      change: [core.UnsupportedError, []],
+      length: [core.UnsupportedError, []],
+      remove: [core.UnsupportedError, []]
     }),
     names: ['add', 'change', 'length', 'remove']
   });
   class NonGrowableListError extends core.Object {
     static add() {
       return new core.UnsupportedError("Cannot add to non-growable List");
     }
     static length() {
       return new core.UnsupportedError("Cannot change length of non-growable List");
     }
     static remove() {
       return new core.UnsupportedError("Cannot remove from non-growable List");
     }
   }
   dart.setSignature(NonGrowableListError, {
     statics: () => ({
-      add: dart.functionType(core.UnsupportedError, []),
-      length: dart.functionType(core.UnsupportedError, []),
-      remove: dart.functionType(core.UnsupportedError, [])
+      add: [core.UnsupportedError, []],
+      length: [core.UnsupportedError, []],
+      remove: [core.UnsupportedError, []]
     }),
     names: ['add', 'length', 'remove']
   });
   function makeListFixedLength(growableList) {
     _interceptors.JSArray.markFixedList(growableList);
     return growableList;
   }
   dart.fn(makeListFixedLength, core.List, [core.List]);
   class Lists extends core.Object {
     static copy(src, srcStart, dst, dstStart, count) {
@@ skipping 56 matching lines @@
       core.RangeError.checkNotNegative(length);
       core.RangeError.checkNotNegative(start);
       if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a[core.$length])) {
         let message = `${start} + ${length} must be in the range [0..${a[core.$length]}]`;
         throw new core.RangeError.range(length, 0, dart.notNull(a[core.$length]) - dart.notNull(start), "length", message);
       }
     }
   }
   dart.setSignature(Lists, {
     statics: () => ({
-      copy: dart.functionType(dart.void, [core.List, core.int, core.List, core.int, core.int]),
-      areEqual: dart.functionType(core.bool, [core.List, dart.dynamic]),
-      indexOf: dart.functionType(core.int, [core.List, core.Object, core.int, core.int]),
-      lastIndexOf: dart.functionType(core.int, [core.List, core.Object, core.int]),
-      indicesCheck: dart.functionType(dart.void, [core.List, core.int, core.int]),
-      rangeCheck: dart.functionType(dart.void, [core.List, core.int, core.int])
+      copy: [dart.void, [core.List, core.int, core.List, core.int, core.int]],
+      areEqual: [core.bool, [core.List, dart.dynamic]],
+      indexOf: [core.int, [core.List, core.Object, core.int, core.int]],
+      lastIndexOf: [core.int, [core.List, core.Object, core.int]],
+      indicesCheck: [dart.void, [core.List, core.int, core.int]],
+      rangeCheck: [dart.void, [core.List, core.int, core.int]]
     }),
     names: ['copy', 'areEqual', 'indexOf', 'lastIndexOf', 'indicesCheck', 'rangeCheck']
   });
   exports.printToZone = null;
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
   dart.fn(printToConsole, dart.void, [core.String]);
   class Sort extends core.Object {
     static sort(a, compare) {
@@ skipping 248 matching lines @@
           }
         }
         Sort._doSort(a, less, great, compare);
       } else {
         Sort._doSort(a, less, great, compare);
       }
     }
   }
   dart.setSignature(Sort, {
     statics: () => ({
-      sort: dart.functionType(dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]),
-      sortRange: dart.functionType(dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]),
-      _doSort: dart.functionType(dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]),
-      _insertionSort: dart.functionType(dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]),
-      _dualPivotQuicksort: dart.functionType(dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])])
+      sort: [dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
+      sortRange: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
+      _doSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
+      _insertionSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
+      _dualPivotQuicksort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]]
     }),
     names: ['sort', 'sortRange', '_doSort', '_insertionSort', '_dualPivotQuicksort']
   });
   Sort._INSERTION_SORT_THRESHOLD = 32;
   let _name = dart.JsSymbol('_name');
   class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     unvalidated(name) {
@@ skipping 25 matching lines @@
     }
     static isValidSymbol(name) {
       return dart.notNull(name.isEmpty) || dart.notNull(Symbol.symbolPattern.hasMatch(name));
     }
   }
   Symbol[dart.implements] = () => [core.Symbol];
   dart.defineNamedConstructor(Symbol, 'unvalidated');
   dart.defineNamedConstructor(Symbol, 'validated');
   dart.setSignature(Symbol, {
     methods: () => ({
-      '==': dart.functionType(core.bool, [core.Object]),
-      toString: dart.functionType(core.String, [])
+      '==': [core.bool, [core.Object]],
+      toString: [core.String, []]
     }),
     statics: () => ({
-      getName: dart.functionType(core.String, [Symbol]),
-      validatePublicSymbol: dart.functionType(core.String, [core.String]),
-      isValidSymbol: dart.functionType(core.bool, [core.String])
+      getName: [core.String, [Symbol]],
+      validatePublicSymbol: [core.String, [core.String]],
+      isValidSymbol: [core.bool, [core.String]]
     }),
     names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
   });
   Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
   Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
   Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
   let POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
@@ skipping 70 matching lines @@
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal, core, collection, math, _interceptors, _js_primitives);