No dynamic at runtime

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) {
@@ skipping 179 matching lines @@
         let i = 0;
         for (let element of this)
           result[core.$set]((() => {
             let x = i;
             i = dart.notNull(x) + 1;
             return x;
           })(), element);
         return result;
       }
       [core.$map](f) {
-        dart.as(f, dart.functionType(dart.dynamic, [E]));
-        return new (_internal.EfficientLengthMappedIterable$(E, dart.dynamic))(this, f);
+        dart.as(f, dart.functionType(core.Object, [E]));
+        return new (_internal.EfficientLengthMappedIterable$(E, core.Object))(this, f);
       }
       get [core.$single]() {
         if (dart.notNull(this[core.$length]) > 1)
           throw _internal.IterableElementError.tooMany();
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = it.current;
         return result;
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
       [core.$where](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
+        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$forEach](f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
+        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
@@ skipping 127 matching lines @@
         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])]],
+        [core.$map]: [core.Iterable, [dart.functionType(core.Object, [E])]],
         [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.$fold]: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, 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])]],
@@ skipping 98 matching lines @@
     }
     HashSet[dart.implements] = () => [core.Set$(E)];
     dart.defineNamedConstructor(HashSet, 'identity');
     dart.defineNamedConstructor(HashSet, 'from');
     return HashSet;
   });
   let HashSet = HashSet$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       [core.$map](f) {
-        dart.as(f, dart.functionType(dart.dynamic, [E]));
-        return new (_internal.MappedIterable$(E, dart.dynamic))(this, f);
+        dart.as(f, dart.functionType(core.Object, [E]));
+        return new (_internal.MappedIterable$(E, core.Object))(this, f);
       }
       [core.$where](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
+        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$contains](element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       [core.$forEach](f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
+        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
@@ skipping 153 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]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        [core.$map]: [core.Iterable, [dart.functionType(core.Object, [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.$fold]: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, 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]]
       })
     });
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       [core.$map](f) {
-        dart.as(f, dart.functionType(dart.dynamic, [E]));
-        return new (_internal.MappedIterable$(E, dart.dynamic))(this, f);
+        dart.as(f, dart.functionType(core.Object, [E]));
+        return new (_internal.MappedIterable$(E, core.Object))(this, f);
       }
       [core.$where](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
+        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$contains](element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       [core.$forEach](f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       [core.$reduce](combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this[core.$iterator];
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
+        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       [core.$every](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
@@ skipping 283 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]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
+        [core.$map]: [core.Iterable, [dart.functionType(core.Object, [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.$fold]: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, 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, [])}],
@@ skipping 198 matching lines @@
       addFirst(entry) {
         dart.as(entry, E);
         this[_insertAfter](this, entry);
       }
       add(entry) {
         dart.as(entry, E);
         this[_insertAfter](this[_previous], entry);
       }
       addAll(entries) {
         dart.as(entries, core.Iterable$(E));
-        entries[core.$forEach](dart.fn((entry => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this), dart.void, [dart.dynamic]));
+        entries[core.$forEach](dart.fn((entry => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this), dart.void, [core.Object]));
       }
       remove(entry) {
         dart.as(entry, E);
         if (!dart.equals(entry[_list], this))
           return false;
         this[_unlink](entry);
         return true;
       }
       get [core.$iterator]() {
         return new (_LinkedListIterator$(E))(this);
@@ skipping 312 matching lines @@
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
       [core.$where](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, test);
       }
       [core.$map](f) {
-        dart.as(f, dart.functionType(dart.dynamic, [E]));
+        dart.as(f, dart.functionType(core.Object, [E]));
         return new _internal.MappedListIterable(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
+        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$reduce](combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let length = this[core.$length];
         if (length == 0)
           throw _internal.IterableElementError.noElement();
         let value = this[core.$get](0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = combine(value, this[core.$get](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       [core.$fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
+        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
         let value = initialValue;
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = dart.dcall(combine, value, this[core.$get](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
@@ skipping 62 matching lines @@
       }
       [core.$removeWhere](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin$()._filter(this, test, false);
       }
       [core.$retainWhere](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin$()._filter(this, test, true);
       }
       static _filter(source, test, retainMatching) {
-        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
+        dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         let retained = [];
         let length = source[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source[core.$get](i);
           if (dart.dcall(test, element) == retainMatching) {
             retained[core.$add](element);
           }
           if (length != source[core.$length]) {
             throw new core.ConcurrentModificationError(source);
           }
@@ skipping 221 matching lines @@
         [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.$map]: [core.Iterable, [dart.functionType(core.Object, [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.$fold]: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, 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)]]
       }),
-      statics: () => ({_filter: [dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic]), core.bool]]}),
+      statics: () => ({_filter: [dart.void, [core.List, dart.functionType(core.bool, [dart.bottom]), 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, '[', ']');
       }
@@ skipping 345 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: [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])]],
+      containsValue: [core.bool, [core.Map, core.Object]],
+      containsKey: [core.bool, [core.Map, core.Object]],
+      putIfAbsent: [core.Object, [core.Map, core.Object, dart.functionType(core.Object, [])]],
+      clear: [core.Object, [core.Map]],
+      forEach: [core.Object, [core.Map, dart.functionType(dart.void, [dart.bottom, dart.bottom])]],
       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])]],
+      _id: [core.Object, [core.Object]],
+      _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(core.Object, [dart.bottom]), dart.functionType(core.Object, [dart.bottom])]],
       _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) {
@@ skipping 837 matching lines @@
   let _comparator = Symbol('_comparator');
   let _validKey = Symbol('_validKey');
   let SplayTreeMap$ = dart.generic(function(K, V) {
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(K));
-        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]);
         super._SplayTree();
       }
       from(other, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeMap$(K, V))();
         other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
@@ skipping 54 matching lines @@
         dart.as(key, K);
         dart.as(value, V);
         if (key == null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
         if (comp == 0) {
           let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
           mapRoot.value = value;
           return;
         }
-        this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
+        this[_addNewRoot](new (_SplayTreeMapNode$(K, core.Object))(key, value), comp);
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
         if (key == null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
         if (comp == 0) {
           let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
           return dart.as(mapRoot.value, V);
         }
         let modificationCount = this[_modificationCount];
         let splayCount = this[_splayCount];
         let value = ifAbsent();
         if (modificationCount != this[_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         if (splayCount != this[_splayCount]) {
           comp = this[_splay](key);
           dart.assert(comp != 0);
         }
-        this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
+        this[_addNewRoot](new (_SplayTreeMapNode$(K, core.Object))(key, value), comp);
         return value;
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this), dart.dynamic, [K, V]));
+        }).bind(this), core.Object, [K, V]));
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [K, V]));
         let nodes = new (_SplayTreeNodeIterator$(K))(this);
@@ skipping 294 matching lines @@
   let _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
   let _clone = Symbol('_clone');
   let SplayTreeSet$ = dart.generic(function(E) {
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(E));
-        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [dart.dynamic]);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [core.Object]);
         super._SplayTree();
       }
       from(elements, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeSet$(E))(compare, isValidKey);
         for (let element of dart.as(elements, core.Iterable$(E))) {
           result.add(element);
@@ skipping 189 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (HashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [dart.dynamic]));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
       }
       containsKey(key) {
         if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           return strings == null ? false : _HashMap$()._hasTableEntry(strings, key);
         } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           return nums == null ? false : _HashMap$()._hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
-        return this[_computeKeys]()[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [dart.dynamic]));
+        return this[_computeKeys]()[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [core.Object]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this), dart.dynamic, [K, V]));
+        }).bind(this), core.Object, [K, V]));
       }
       get(key) {
         if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           return strings == null ? null : dart.as(_HashMap$()._getTableEntry(strings, key), V);
         } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           return nums == null ? null : dart.as(_HashMap$()._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
@@ skipping 216 matching lines @@
         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]]
+        [_addHashTableEntry]: [dart.void, [core.Object, K, V]],
+        [_removeHashTableEntry]: [V, [core.Object, core.Object]],
+        [_computeHashCode]: [core.int, [core.Object]],
+        [_getBucket]: [core.List, [core.Object, core.Object]],
+        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringKey: [core.bool, [core.Object]],
+        _isNumericKey: [core.bool, [core.Object]],
+        _hasTableEntry: [core.bool, [core.Object, core.Object]],
+        _getTableEntry: [core.Object, [core.Object, core.Object]],
+        _setTableEntry: [dart.void, [core.Object, core.Object, core.Object]],
+        _deleteTableEntry: [dart.void, [core.Object, core.Object]],
+        _newHashTable: [core.Object, []]
       }),
       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();
@@ skipping 15 matching lines @@
     return _IdentityHashMap;
   });
   let _IdentityHashMap = _IdentityHashMap$();
   let _equals = Symbol('_equals');
   let _hashCode = Symbol('_hashCode');
   let _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
       _CustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
-        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]);
         super._HashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 129 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (LinkedHashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [dart.dynamic]));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
       }
       containsKey(key) {
         if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell != null;
         } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             return false;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(nums, key), LinkedHashMapCell);
           return cell != null;
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
-        return this.keys[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [dart.dynamic]));
+        return this.keys[core.$any](dart.fn((each => dart.equals(this.get(each), value)).bind(this), core.bool, [core.Object]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         other.forEach(dart.fn(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
-        }).bind(this), dart.dynamic, [K, V]));
+        }).bind(this), core.Object, [K, V]));
       }
       get(key) {
         if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return null;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell == null ? null : dart.as(cell[_value], V);
         } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
@@ skipping 214 matching lines @@
         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]],
+        [_addHashTableEntry]: [dart.void, [core.Object, K, V]],
+        [_removeHashTableEntry]: [V, [core.Object, 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]]
+        [_computeHashCode]: [core.int, [core.Object]],
+        [_getBucket]: [core.List, [core.Object, core.Object]],
+        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringKey: [core.bool, [core.Object]],
+        _isNumericKey: [core.bool, [core.Object]],
+        _getTableEntry: [core.Object, [core.Object, core.Object]],
+        _setTableEntry: [dart.void, [core.Object, core.Object, core.Object]],
+        _deleteTableEntry: [dart.void, [core.Object, core.Object]],
+        _newHashTable: [core.Object, []]
       }),
       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();
@@ skipping 14 matching lines @@
       }
     }
     return _LinkedIdentityHashMap;
   });
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
       _LinkedCustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
-        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 354 matching lines @@
         [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]],
         [_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]]
+        [_addHashTableEntry]: [core.bool, [core.Object, E]],
+        [_removeHashTableEntry]: [core.bool, [core.Object, core.Object]],
+        [_computeHashCode]: [core.int, [core.Object]],
+        [_getBucket]: [core.List, [core.Object, core.Object]],
+        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringElement: [core.bool, [core.Object]],
+        _isNumericElement: [core.bool, [core.Object]],
+        _hasTableEntry: [core.bool, [core.Object, core.Object]],
+        _setTableEntry: [dart.void, [core.Object, core.Object, core.Object]],
+        _deleteTableEntry: [dart.void, [core.Object, core.Object]],
+        _newHashTable: [core.Object, []]
       }),
       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 21 matching lines @@
     return _IdentityHashSet;
   });
   let _IdentityHashSet = _IdentityHashSet$();
   let _equality = Symbol('_equality');
   let _hasher = Symbol('_hasher');
   let _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
-        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [core.Object]);
         super._HashSet();
       }
       [_newSet]() {
         return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 353 matching lines @@
         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]],
-        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
-        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
+        [_addHashTableEntry]: [core.bool, [core.Object, E]],
+        [_removeHashTableEntry]: [core.bool, [core.Object, 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]]
+        [_computeHashCode]: [core.int, [core.Object]],
+        [_getBucket]: [core.List, [core.Object, core.Object]],
+        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringElement: [core.bool, [core.Object]],
+        _isNumericElement: [core.bool, [core.Object]],
+        _getTableEntry: [core.Object, [core.Object, core.Object]],
+        _setTableEntry: [dart.void, [core.Object, core.Object, core.Object]],
+        _deleteTableEntry: [dart.void, [core.Object, core.Object]],
+        _newHashTable: [core.Object, []]
       }),
       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 20 matching lines @@
       methods: () => ({[_newSet]: [core.Set$(E), []]})
     });
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
   let _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
-        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [core.Object]);
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 148 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);