Handle dynamic as bottom inside of function type reps

lib/runtime/dart/collection.js

 dart_library.library('dart/collection', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core'
 ], /* Lazy imports */[
   'dart/_internal',
   'dart/_js_helper',
   'dart/math'
 ], function(exports, dart, core, _internal, _js_helper, math) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 88 matching lines @@
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
     dart.setSignature(HashMap, {
       constructors: () => ({
         new: [HashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [HashMap$(K, V), []],
         from: [HashMap$(K, V), [core.Map]],
-        fromIterable: [HashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
+        fromIterable: [HashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [HashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]]
       })
     });
     return HashMap;
   });
   let HashMap = HashMap$();
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
@@ skipping 80 matching lines @@
         let i = 0;
         for (let element of this)
           result[dartx.set]((() => {
             let x = i;
             i = dart.notNull(x) + 1;
             return x;
           })(), element);
         return result;
       }
       map(f) {
-        dart.as(f, dart.functionType(core.Object, [E]));
-        return new (_internal.EfficientLengthMappedIterable$(E, core.Object))(this, f);
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
+        return new (_internal.EfficientLengthMappedIterable$(E, dart.dynamic))(this, f);
       }
       get single() {
         if (dart.notNull(this.length) > 1)
           throw _internal.IterableElementError.tooMany();
         let it = this.iterator;
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = it.current;
         return result;
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
       where(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
+        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this.iterator;
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (dart.notNull(iterator.moveNext())) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       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)]],
         toList: [core.List$(E), [], {growable: core.bool}],
-        map: [core.Iterable, [dart.functionType(core.Object, [E])]],
+        map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
         where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         expand: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         reduce: [E, [dart.functionType(E, [E, E])]],
-        fold: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, E])]],
+        fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
         every: [core.bool, [dart.functionType(core.bool, [E])]],
         join: [core.String, [], [core.String]],
         any: [core.bool, [dart.functionType(core.bool, [E])]],
         take: [core.Iterable$(E), [core.int]],
         takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         skip: [core.Iterable$(E), [core.int]],
         skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         singleWhere: [E, [dart.functionType(core.bool, [E])]],
@@ skipping 129 matching lines @@
         identity: [HashSet$(E), []],
         from: [HashSet$(E), [core.Iterable]]
       })
     });
     return HashSet;
   });
   let HashSet = HashSet$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       map(f) {
-        dart.as(f, dart.functionType(core.Object, [E]));
-        return _internal.MappedIterable$(E, core.Object).new(this, f);
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
+        return _internal.MappedIterable$(E, dart.dynamic).new(this, f);
       }
       where(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
+        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       contains(element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this.iterator;
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (dart.notNull(iterator.moveNext())) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       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.iterator);
       }
     }
     IterableMixin[dart.implements] = () => [core.Iterable$(E)];
     dart.setSignature(IterableMixin, {
       methods: () => ({
-        map: [core.Iterable, [dart.functionType(core.Object, [E])]],
+        map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
         where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         expand: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
         contains: [core.bool, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         reduce: [E, [dart.functionType(E, [E, E])]],
-        fold: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, E])]],
+        fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
         every: [core.bool, [dart.functionType(core.bool, [E])]],
         join: [core.String, [], [core.String]],
         any: [core.bool, [dart.functionType(core.bool, [E])]],
         toList: [core.List$(E), [], {growable: core.bool}],
         toSet: [core.Set$(E), []],
         take: [core.Iterable$(E), [core.int]],
         takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         skip: [core.Iterable$(E), [core.int]],
         skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
@@ skipping 31 matching lines @@
       'single'
     ]);
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       map(f) {
-        dart.as(f, dart.functionType(core.Object, [E]));
-        return _internal.MappedIterable$(E, core.Object).new(this, f);
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
+        return _internal.MappedIterable$(E, dart.dynamic).new(this, f);
       }
       where(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
+        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       contains(element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         for (let element of this)
           f(element);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let iterator = this.iterator;
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let value = iterator.current;
         while (dart.notNull(iterator.moveNext())) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         for (let element of this)
           value = dart.dcall(combine, value, element);
         return value;
       }
       every(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
@@ skipping 284 matching lines @@
         parts[dartx.add](ultimateString);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
       }
     }
     IterableBase[dart.implements] = () => [core.Iterable$(E)];
     dart.setSignature(IterableBase, {
       constructors: () => ({IterableBase: [IterableBase$(E), []]}),
       methods: () => ({
-        map: [core.Iterable, [dart.functionType(core.Object, [E])]],
+        map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
         where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         expand: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
         contains: [core.bool, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         reduce: [E, [dart.functionType(E, [E, E])]],
-        fold: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, E])]],
+        fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
         every: [core.bool, [dart.functionType(core.bool, [E])]],
         join: [core.String, [], [core.String]],
         any: [core.bool, [dart.functionType(core.bool, [E])]],
         toList: [core.List$(E), [], {growable: core.bool}],
         toSet: [core.Set$(E), []],
         take: [core.Iterable$(E), [core.int]],
         takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         skip: [core.Iterable$(E), [core.int]],
         skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
@@ skipping 146 matching lines @@
       static _empty() {
         return new (_LinkedHashMap$(K, V))();
       }
     }
     LinkedHashMap[dart.implements] = () => [HashMap$(K, V)];
     dart.setSignature(LinkedHashMap, {
       constructors: () => ({
         new: [LinkedHashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [LinkedHashMap$(K, V), []],
         from: [LinkedHashMap$(K, V), [core.Map]],
-        fromIterable: [LinkedHashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
+        fromIterable: [LinkedHashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [LinkedHashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]],
         _literal: [LinkedHashMap$(K, V), [core.List]],
         _empty: [LinkedHashMap$(K, V), []]
       })
     });
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$();
   let LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
@@ skipping 70 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[dartx.forEach](dart.fn(entry => this[_insertAfter](this[_previous], dart.as(entry, E)), dart.void, [core.Object]));
+        entries[dartx.forEach](dart.fn(entry => this[_insertAfter](this[_previous], dart.as(entry, E)), dart.void, [dart.dynamic]));
       }
       remove(entry) {
         dart.as(entry, E);
         if (!dart.equals(entry[_list], this))
           return false;
         this[_unlink](entry);
         return true;
       }
       get iterator() {
         return new (_LinkedListIterator$(E))(this);
@@ skipping 323 matching lines @@
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
       where(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, test);
       }
       map(f) {
-        dart.as(f, dart.functionType(core.Object, [E]));
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return new _internal.MappedListIterable(this, f);
       }
       expand(f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
-        return new (_internal.ExpandIterable$(E, core.Object))(this, f);
+        return new (_internal.ExpandIterable$(E, dart.dynamic))(this, f);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         let length = this.length;
         if (length == 0)
           throw _internal.IterableElementError.noElement();
         let value = this.get(0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = combine(value, this.get(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       fold(initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         let value = initialValue;
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = dart.dcall(combine, value, this.get(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
@@ skipping 62 matching lines @@
       }
       removeWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin$()._filter(this, test, false);
       }
       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.bottom]));
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let retained = [];
         let length = source[dartx.length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source[dartx.get](i);
           if (dart.dcall(test, element) == retainMatching) {
             retained[dartx.add](element);
           }
           if (length != source[dartx.length]) {
             throw new core.ConcurrentModificationError(source);
           }
@@ skipping 221 matching lines @@
         elementAt: [E, [core.int]],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         contains: [core.bool, [core.Object]],
         every: [core.bool, [dart.functionType(core.bool, [E])]],
         any: [core.bool, [dart.functionType(core.bool, [E])]],
         firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         singleWhere: [E, [dart.functionType(core.bool, [E])]],
         join: [core.String, [], [core.String]],
         where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
-        map: [core.Iterable, [dart.functionType(core.Object, [E])]],
+        map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
         expand: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
         reduce: [E, [dart.functionType(E, [E, E])]],
-        fold: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, E])]],
+        fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
         skip: [core.Iterable$(E), [core.int]],
         skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         take: [core.Iterable$(E), [core.int]],
         takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         toList: [core.List$(E), [], {growable: core.bool}],
         toSet: [core.Set$(E), []],
         add: [dart.void, [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, []],
         removeLast: [E, []],
         sort: [dart.void, [], [dart.functionType(core.int, [E, E])]],
         shuffle: [dart.void, [], [math.Random]],
         asMap: [core.Map$(core.int, E), []],
         sublist: [core.List$(E), [core.int], [core.int]],
         getRange: [core.Iterable$(E), [core.int, core.int]],
         removeRange: [dart.void, [core.int, core.int]],
         fillRange: [dart.void, [core.int, core.int], [E]],
         setRange: [dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]],
         replaceRange: [dart.void, [core.int, core.int, core.Iterable$(E)]],
         indexOf: [core.int, [core.Object], [core.int]],
         lastIndexOf: [core.int, [core.Object], [core.int]],
         insert: [dart.void, [core.int, E]],
         removeAt: [E, [core.int]],
         insertAll: [dart.void, [core.int, core.Iterable$(E)]],
         setAll: [dart.void, [core.int, core.Iterable$(E)]]
       }),
-      statics: () => ({_filter: [dart.void, [core.List, dart.functionType(core.bool, [dart.bottom]), core.bool]]}),
+      statics: () => ({_filter: [dart.void, [core.List, dart.functionType(core.bool, [dart.dynamic]), core.bool]]}),
       names: ['_filter']
     });
     dart.defineExtensionMembers(ListMixin, [
       'elementAt',
       'forEach',
       'contains',
       'every',
       'any',
       'firstWhere',
       'lastWhere',
@@ skipping 410 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, 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])]],
+      containsValue: [core.bool, [core.Map, dart.dynamic]],
+      containsKey: [core.bool, [core.Map, dart.dynamic]],
+      putIfAbsent: [dart.dynamic, [core.Map, dart.dynamic, dart.functionType(dart.dynamic, [])]],
+      clear: [dart.dynamic, [core.Map]],
+      forEach: [dart.dynamic, [core.Map, dart.functionType(dart.void, [dart.dynamic, dart.dynamic])]],
       getValues: [core.Iterable, [core.Map]],
       length: [core.int, [core.Map]],
       isEmpty: [core.bool, [core.Map]],
       isNotEmpty: [core.bool, [core.Map]],
       mapToString: [core.String, [core.Map]],
-      _id: [core.Object, [core.Object]],
-      _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(core.Object, [dart.bottom]), dart.functionType(core.Object, [dart.bottom])]],
+      _id: [dart.dynamic, [dart.dynamic]],
+      _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic])]],
       _fillMapWithIterables: [dart.void, [core.Map, core.Iterable, core.Iterable]]
     }),
     names: ['containsValue', 'containsKey', 'putIfAbsent', 'clear', 'forEach', 'getValues', 'length', 'isEmpty', 'isNotEmpty', 'mapToString', '_id', '_fillMapWithMappedIterable', '_fillMapWithIterables']
   });
   let Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
       static new() {
         return new (ListQueue$(E))();
       }
       static from(elements) {
@@ skipping 877 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, [core.Object]);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
       static 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(dart.as(k, 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, core.Object))(key, value), comp);
+        this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
         if (key == null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
         if (comp == 0) {
           let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
           return dart.as(mapRoot.value, V);
         }
         let modificationCount = this[_modificationCount];
         let splayCount = this[_splayCount];
         let value = ifAbsent();
         if (modificationCount != this[_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         if (splayCount != this[_splayCount]) {
           comp = this[_splay](key);
           dart.assert(comp != 0);
         }
-        this[_addNewRoot](new (_SplayTreeMapNode$(K, core.Object))(key, value), comp);
+        this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(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);
-        }, core.Object, [K, V]));
+        }, dart.dynamic, [K, V]));
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [K, V]));
         let nodes = new (_SplayTreeNodeIterator$(K))(this);
@@ skipping 83 matching lines @@
         }
         return node.key;
       }
     }
     SplayTreeMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(SplayTreeMap, '_internal');
     dart.setSignature(SplayTreeMap, {
       constructors: () => ({
         SplayTreeMap: [SplayTreeMap$(K, V), [], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
         from: [SplayTreeMap$(K, V), [core.Map], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
-        fromIterable: [SplayTreeMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom]), compare: dart.functionType(core.int, [K, K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
+        fromIterable: [SplayTreeMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic]), compare: dart.functionType(core.int, [K, K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         fromIterables: [SplayTreeMap$(K, V), [core.Iterable$(K), core.Iterable$(V)], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
         _internal: [SplayTreeMap$(K, V), []]
       }),
       methods: () => ({
         [_compare]: [core.int, [K, K]],
         get: [V, [core.Object]],
         remove: [V, [core.Object]],
         set: [dart.void, [K, V]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         addAll: [dart.void, [core.Map$(K, V)]],
@@ skipping 78 matching lines @@
         this[_currentNode] = this[_workList][dartx.removeLast]();
         this[_findLeftMostDescendent](this[_currentNode].right);
         return true;
       }
     }
     _SplayTreeIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.defineNamedConstructor(_SplayTreeIterator, 'startAt');
     dart.setSignature(_SplayTreeIterator, {
       constructors: () => ({
         _SplayTreeIterator: [_SplayTreeIterator$(T), [_SplayTree]],
-        startAt: [_SplayTreeIterator$(T), [_SplayTree, core.Object]]
+        startAt: [_SplayTreeIterator$(T), [_SplayTree, dart.dynamic]]
       }),
       methods: () => ({
         [_findLeftMostDescendent]: [dart.void, [_SplayTreeNode]],
         [_rebuildWorkList]: [dart.void, [_SplayTreeNode]],
         moveNext: [core.bool, []]
       })
     });
     return _SplayTreeIterator;
   });
   let _SplayTreeIterator = _SplayTreeIterator$();
@@ skipping 95 matching lines @@
         super.startAt(tree, startKey);
       }
       [_getValue](node) {
         return dart.as(node, _SplayTreeNode$(K));
       }
     }
     dart.defineNamedConstructor(_SplayTreeNodeIterator, 'startAt');
     dart.setSignature(_SplayTreeNodeIterator, {
       constructors: () => ({
         _SplayTreeNodeIterator: [_SplayTreeNodeIterator$(K), [_SplayTree$(K)]],
-        startAt: [_SplayTreeNodeIterator$(K), [_SplayTree$(K), core.Object]]
+        startAt: [_SplayTreeNodeIterator$(K), [_SplayTree$(K), dart.dynamic]]
       }),
       methods: () => ({[_getValue]: [_SplayTreeNode$(K), [_SplayTreeNode]]})
     });
     return _SplayTreeNodeIterator;
   });
   let _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
   let _clone = Symbol('_clone');
   let SplayTreeSet$ = dart.generic(function(E) {
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         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, [core.Object]);
+        this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
       static 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 203 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 _internal.MappedIterable$(K, V).new(this.keys, dart.fn(each => this.get(each), V, [core.Object]));
+        return _internal.MappedIterable$(K, V).new(this.keys, dart.fn(each => this.get(each), V, [dart.dynamic]));
       }
       containsKey(key) {
         if (dart.notNull(_HashMap$()._isStringKey(key))) {
           let strings = this[_strings];
           return strings == null ? false : _HashMap$()._hasTableEntry(strings, key);
         } else if (dart.notNull(_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]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [core.Object]));
+        return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [dart.dynamic]));
       }
       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);
-        }, core.Object, [K, V]));
+        }, dart.dynamic, [K, V]));
       }
       get(key) {
         if (dart.notNull(_HashMap$()._isStringKey(key))) {
           let strings = this[_strings];
           return strings == null ? null : dart.as(_HashMap$()._getTableEntry(strings, key), V);
         } else if (dart.notNull(_HashMap$()._isNumericKey(key))) {
           let nums = this[_nums];
           return nums == null ? null : dart.as(_HashMap$()._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
@@ skipping 217 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, [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]]
+        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
-        _isStringKey: [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, []]
+        _isStringKey: [core.bool, [dart.dynamic]],
+        _isNumericKey: [core.bool, [dart.dynamic]],
+        _hasTableEntry: [core.bool, [dart.dynamic, dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_hasTableEntry', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     return _HashMap;
   });
   let _HashMap = _HashMap$();
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _IdentityHashMap() {
         super._HashMap();
@@ 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, [core.Object]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._HashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 61 matching lines @@
         for (let i = 0, length = keys.length; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(dart.as(keys[i], E));
           if (keys !== dart.dload(this[_map], _keys)) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
         }
       }
     }
     HashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(HashMapKeyIterable, {
-      constructors: () => ({HashMapKeyIterable: [HashMapKeyIterable$(E), [core.Object]]}),
+      constructors: () => ({HashMapKeyIterable: [HashMapKeyIterable$(E), [dart.dynamic]]}),
       methods: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
     });
     dart.defineExtensionMembers(HashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return HashMapKeyIterable;
@@ skipping 21 matching lines @@
           return false;
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashMapKeyIterator, {
-      constructors: () => ({HashMapKeyIterator: [HashMapKeyIterator$(E), [core.Object, core.List]]}),
+      constructors: () => ({HashMapKeyIterator: [HashMapKeyIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return HashMapKeyIterator;
   });
   let HashMapKeyIterator = HashMapKeyIterator$();
   let _modifications = Symbol('_modifications');
   let _value = Symbol('_value');
   let _newLinkedCell = Symbol('_newLinkedCell');
   let _unlinkCell = Symbol('_unlinkCell');
   let _modified = Symbol('_modified');
@@ skipping 15 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 _internal.MappedIterable$(K, V).new(this.keys, dart.fn(each => this.get(each), V, [core.Object]));
+        return _internal.MappedIterable$(K, V).new(this.keys, dart.fn(each => this.get(each), V, [dart.dynamic]));
       }
       containsKey(key) {
         if (dart.notNull(_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 (dart.notNull(_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[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [core.Object]));
+        return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [dart.dynamic]));
       }
       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);
-        }, core.Object, [K, V]));
+        }, dart.dynamic, [K, V]));
       }
       get(key) {
         if (dart.notNull(_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 (dart.notNull(_LinkedHashMap$()._isNumericKey(key))) {
           let nums = this[_nums];
@@ skipping 215 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, [core.Object, K, V]],
-        [_removeHashTableEntry]: [V, [core.Object, core.Object]],
+        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
         [_modified]: [dart.void, []],
         [_newLinkedCell]: [LinkedHashMapCell, [K, V]],
         [_unlinkCell]: [dart.void, [LinkedHashMapCell]],
-        [_computeHashCode]: [core.int, [core.Object]],
-        [_getBucket]: [core.List, [core.Object, core.Object]],
-        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringKey: [core.bool, [dart.dynamic]],
+        _isNumericKey: [core.bool, [dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$();
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       _LinkedIdentityHashMap() {
         super._LinkedHashMap();
@@ 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, [core.Object]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
         return super[_get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 37 matching lines @@
   let _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   dart.setSignature(LinkedHashMapCell, {
-    constructors: () => ({LinkedHashMapCell: [LinkedHashMapCell, [core.Object, core.Object]]})
+    constructors: () => ({LinkedHashMapCell: [LinkedHashMapCell, [dart.dynamic, dart.dynamic]]})
   });
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
       LinkedHashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], _length), core.int);
       }
@@ skipping 14 matching lines @@
           f(dart.as(cell[_key], E));
           if (!dart.equals(modifications, dart.dload(this[_map], _modifications))) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
           cell = cell[_next];
         }
       }
     }
     LinkedHashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(LinkedHashMapKeyIterable, {
-      constructors: () => ({LinkedHashMapKeyIterable: [LinkedHashMapKeyIterable$(E), [core.Object]]}),
+      constructors: () => ({LinkedHashMapKeyIterable: [LinkedHashMapKeyIterable$(E), [dart.dynamic]]}),
       methods: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
     });
     dart.defineExtensionMembers(LinkedHashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return LinkedHashMapKeyIterable;
@@ skipping 20 matching lines @@
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(LinkedHashMapKeyIterator, {
-      constructors: () => ({LinkedHashMapKeyIterator: [LinkedHashMapKeyIterator$(E), [core.Object, core.int]]}),
+      constructors: () => ({LinkedHashMapKeyIterator: [LinkedHashMapKeyIterator$(E), [dart.dynamic, core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return LinkedHashMapKeyIterator;
   });
   let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$();
   let _elements = Symbol('_elements');
   let _computeElements = Symbol('_computeElements');
   let _contains = Symbol('_contains');
   let _lookup = Symbol('_lookup');
   let _HashSet$ = dart.generic(function(E) {
@@ skipping 234 matching lines @@
         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, [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]]
+        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
-        _isStringElement: [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, []]
+        _isStringElement: [core.bool, [dart.dynamic]],
+        _isNumericElement: [core.bool, [dart.dynamic]],
+        _hasTableEntry: [core.bool, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringElement', '_isNumericElement', '_hasTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     dart.defineExtensionMembers(_HashSet, [
       'contains',
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty'
     ]);
@@ skipping 28 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, [core.Object]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._HashSet();
       }
       [_newSet]() {
         return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 58 matching lines @@
           return false;
         } else {
           this[_current] = dart.as(elements[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashSetIterator, {
-      constructors: () => ({HashSetIterator: [HashSetIterator$(E), [core.Object, core.List]]}),
+      constructors: () => ({HashSetIterator: [HashSetIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return HashSetIterator;
   });
   let HashSetIterator = HashSetIterator$();
   let _unsupported = Symbol('_unsupported');
   let _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
         this[_length] = 0;
@@ skipping 278 matching lines @@
         lookup: [E, [core.Object]],
         [_lookup]: [E, [core.Object]],
         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, [core.Object, E]],
-        [_removeHashTableEntry]: [core.bool, [core.Object, core.Object]],
+        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
         [_modified]: [dart.void, []],
         [_newLinkedCell]: [LinkedHashSetCell, [E]],
         [_unlinkCell]: [dart.void, [LinkedHashSetCell]],
-        [_computeHashCode]: [core.int, [core.Object]],
-        [_getBucket]: [core.List, [core.Object, core.Object]],
-        [_findBucketIndex]: [core.int, [core.Object, core.Object]]
+        [_computeHashCode]: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
-        _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, []]
+        _isStringElement: [core.bool, [dart.dynamic]],
+        _isNumericElement: [core.bool, [dart.dynamic]],
+        _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
+        _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringElement', '_isNumericElement', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     dart.defineExtensionMembers(_LinkedHashSet, [
       'contains',
       'forEach',
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty',
@@ skipping 30 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, [core.Object]);
+        this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
@@ skipping 53 matching lines @@
   });
   let _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   dart.setSignature(LinkedHashSetCell, {
-    constructors: () => ({LinkedHashSetCell: [LinkedHashSetCell, [core.Object]]})
+    constructors: () => ({LinkedHashSetCell: [LinkedHashSetCell, [dart.dynamic]]})
   });
   let LinkedHashSetIterator$ = dart.generic(function(E) {
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set, modifications) {
         this[_set] = set;
         this[_modifications] = modifications;
         this[_cell] = null;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_set], _first), LinkedHashSetCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (!dart.equals(this[_modifications], dart.dload(this[_set], _modifications))) {
           throw new core.ConcurrentModificationError(this[_set]);
         } else if (this[_cell] == null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_element], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(LinkedHashSetIterator, {
-      constructors: () => ({LinkedHashSetIterator: [LinkedHashSetIterator$(E), [core.Object, core.int]]}),
+      constructors: () => ({LinkedHashSetIterator: [LinkedHashSetIterator$(E), [dart.dynamic, core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return LinkedHashSetIterator;
   });
   let LinkedHashSetIterator = LinkedHashSetIterator$();
   // Exports:
   exports.UnmodifiableListView$ = UnmodifiableListView$;
   exports.HashMap$ = HashMap$;
   exports.HashMap = HashMap;
   exports.SetMixin$ = SetMixin$;
@@ skipping 51 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;
 });