Add constructors to signatures

lib/runtime/dart/collection.js

 var collection = dart.defineLibrary(collection, {});
 var _internal = dart.lazyImport(_internal);
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 var math = dart.lazyImport(math);
 (function(exports, _internal, core, _js_helper, math) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
       }
       get [core.$length]() {
         return this[_source][core.$length];
       }
       [core.$get](index) {
         return this[_source][core.$elementAt](index);
       }
     }
     dart.setSignature(UnmodifiableListView, {
+      constructors: () => ({UnmodifiableListView: [exports.UnmodifiableListView$(E), [core.Iterable$(E)]]}),
       methods: () => ({[core.$get]: [E, [core.int]]})
     });
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
@@ skipping 61 matching lines @@
         let map = new (HashMap$(K, V))();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(HashMap, 'identity');
     dart.defineNamedConstructor(HashMap, 'from');
     dart.defineNamedConstructor(HashMap, 'fromIterable');
     dart.defineNamedConstructor(HashMap, 'fromIterables');
+    dart.setSignature(HashMap, {
+      constructors: () => ({
+        HashMap: [HashMap$(K, V), [], {qual: dart.functionType(core.bool, [K, K]), ashCod: dart.functionType(core.int, [K]), sValidKe: dart.functionType(core.bool, [core.Object])}],
+        identity: [HashMap$(K, V), []],
+        from: [HashMap$(K, V), [core.Map]],
+        fromIterable: [HashMap$(K, V), [core.Iterable], {e: dart.functionType(K, [dart.bottom]), alu: dart.functionType(V, [dart.bottom])}],
+        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[core.$iterator]);
       }
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
@@ skipping 384 matching lines @@
           result.add(e);
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     HashSet[dart.implements] = () => [core.Set$(E)];
     dart.defineNamedConstructor(HashSet, 'identity');
     dart.defineNamedConstructor(HashSet, 'from');
+    dart.setSignature(HashSet, {
+      constructors: () => ({
+        HashSet: [HashSet$(E), [], {qual: dart.functionType(core.bool, [E, E]), ashCod: dart.functionType(core.int, [E]), sValidKe: dart.functionType(core.bool, [core.Object])}],
+        identity: [HashSet$(E), []],
+        from: [HashSet$(E), [core.Iterable]]
+      })
+    });
     return HashSet;
   });
   let HashSet = HashSet$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       [core.$map](f) {
         dart.as(f, dart.functionType(core.Object, [E]));
         return new (_internal.MappedIterable$(E, core.Object))(this, f);
       }
       [core.$where](f) {
@@ skipping 565 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, {
+      constructors: () => ({IterableBase: [IterableBase$(E), []]}),
       methods: () => ({
         [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]: [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]],
@@ skipping 49 matching lines @@
       }
       [_move]() {
         if (this[_iterator].moveNext()) {
           this[_state] = HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT;
         } else {
           this[_state] = HasNextIterator$()._NO_NEXT;
         }
       }
     }
     dart.setSignature(HasNextIterator, {
+      constructors: () => ({HasNextIterator: [HasNextIterator$(E), [core.Iterator]]}),
       methods: () => ({
         next: [E, []],
         [_move]: [dart.void, []]
       })
     });
     return HasNextIterator;
   });
   let HasNextIterator = HasNextIterator$();
   HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
   HasNextIterator._NO_NEXT = 1;
@@ skipping 57 matching lines @@
         return new (_LinkedHashMap$(K, V))();
       }
     }
     LinkedHashMap[dart.implements] = () => [HashMap$(K, V)];
     dart.defineNamedConstructor(LinkedHashMap, 'identity');
     dart.defineNamedConstructor(LinkedHashMap, 'from');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterable');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterables');
     dart.defineNamedConstructor(LinkedHashMap, '_literal');
     dart.defineNamedConstructor(LinkedHashMap, '_empty');
+    dart.setSignature(LinkedHashMap, {
+      constructors: () => ({
+        LinkedHashMap: [LinkedHashMap$(K, V), [], {qual: dart.functionType(core.bool, [K, K]), ashCod: dart.functionType(core.int, [K]), sValidKe: dart.functionType(core.bool, [core.Object])}],
+        identity: [LinkedHashMap$(K, V), []],
+        from: [LinkedHashMap$(K, V), [core.Map]],
+        fromIterable: [LinkedHashMap$(K, V), [core.Iterable], {e: dart.functionType(K, [dart.bottom]), alu: dart.functionType(V, [dart.bottom])}],
+        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 {
       LinkedHashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
@@ skipping 30 matching lines @@
         }
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     LinkedHashSet[dart.implements] = () => [HashSet$(E)];
     dart.defineNamedConstructor(LinkedHashSet, 'identity');
     dart.defineNamedConstructor(LinkedHashSet, 'from');
+    dart.setSignature(LinkedHashSet, {
+      constructors: () => ({
+        LinkedHashSet: [LinkedHashSet$(E), [], {qual: dart.functionType(core.bool, [E, E]), ashCod: dart.functionType(core.int, [E]), sValidKe: dart.functionType(core.bool, [core.Object])}],
+        identity: [LinkedHashSet$(E), []],
+        from: [LinkedHashSet$(E), [core.Iterable$(E)]]
+      })
+    });
     return LinkedHashSet;
   });
   let LinkedHashSet = LinkedHashSet$();
   let _modificationCount = Symbol('_modificationCount');
   let _length = Symbol('_length');
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   let _insertAfter = Symbol('_insertAfter');
   let _list = Symbol('_list');
   let _unlink = Symbol('_unlink');
@@ skipping 98 matching lines @@
         dart.as(entry, LinkedListEntry$(E));
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         entry[_next][_previous] = entry[_previous];
         entry[_previous][_next] = entry[_next];
         this[_length] = dart.notNull(this[_length]) - 1;
         entry[_list] = entry[_next] = entry[_previous] = null;
       }
     }
     LinkedList[dart.implements] = () => [_LinkedListLink];
     dart.setSignature(LinkedList, {
+      constructors: () => ({LinkedList: [LinkedList$(E), []]}),
       methods: () => ({
         addFirst: [dart.void, [E]],
         add: [dart.void, [E]],
         addAll: [dart.void, [core.Iterable$(E)]],
         remove: [core.bool, [E]],
         clear: [dart.void, []],
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [_insertAfter]: [dart.void, [_LinkedListLink, E]],
         [_unlink]: [dart.void, [LinkedListEntry$(E)]]
       })
@@ skipping 21 matching lines @@
         if (this[_modificationCount] != this[_list][_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
         this[_current] = dart.as(this[_next], E);
         this[_next] = this[_next][_next];
         return true;
       }
     }
     _LinkedListIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_LinkedListIterator, {
+      constructors: () => ({_LinkedListIterator: [_LinkedListIterator$(E), [LinkedList$(E)]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _LinkedListIterator;
   });
   let _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
@@ skipping 720 matching lines @@
         return dart.as(this[_map].get(this[_map].keys[core.$single]), V);
       }
       get [core.$last]() {
         return dart.as(this[_map].get(this[_map].keys[core.$last]), V);
       }
       get [core.$iterator]() {
         return new (_MapBaseValueIterator$(V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_MapBaseValueIterable, {
+      constructors: () => ({_MapBaseValueIterable: [_MapBaseValueIterable$(V), [core.Map]]})
+    });
     return _MapBaseValueIterable;
   });
   let _MapBaseValueIterable = _MapBaseValueIterable$();
   let _keys = Symbol('_keys');
   let _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
         this[_keys] = map.keys[core.$iterator];
         this[_current] = null;
       }
       moveNext() {
         if (this[_keys].moveNext()) {
           this[_current] = dart.as(this[_map].get(this[_keys].current), V);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _MapBaseValueIterator[dart.implements] = () => [core.Iterator$(V)];
     dart.setSignature(_MapBaseValueIterator, {
+      constructors: () => ({_MapBaseValueIterator: [_MapBaseValueIterator$(V), [core.Map]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _MapBaseValueIterator;
   });
   let _MapBaseValueIterator = _MapBaseValueIterator$();
   let MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
@@ skipping 44 matching lines @@
       }
       toString() {
         return dart.toString(this[_map]);
       }
       get values() {
         return this[_map].values;
       }
     }
     MapView[dart.implements] = () => [core.Map$(K, V)];
     dart.setSignature(MapView, {
+      constructors: () => ({MapView: [MapView$(K, V), [core.Map$(K, V)]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         addAll: [dart.void, [core.Map$(K, V)]],
         clear: [dart.void, []],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         containsKey: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         remove: [V, [core.Object]]
@@ skipping 131 matching lines @@
       }
       from(elements) {
         return new (ListQueue$(E)).from(elements);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     Queue[dart.implements] = () => [core.Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(Queue, 'from');
+    dart.setSignature(Queue, {
+      constructors: () => ({
+        Queue: [Queue$(E), []],
+        from: [Queue$(E), [core.Iterable]]
+      })
+    });
     return Queue;
   });
   let Queue = Queue$();
   let _element = Symbol('_element');
   let _link = Symbol('_link');
   let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
   let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
@@ skipping 34 matching lines @@
       }
       get element() {
         return this[_element];
       }
       set element(e) {
         dart.as(e, E);
         this[_element] = e;
       }
     }
     dart.setSignature(DoubleLinkedQueueEntry, {
+      constructors: () => ({DoubleLinkedQueueEntry: [DoubleLinkedQueueEntry$(E), [E]]}),
       methods: () => ({
         [_link]: [dart.void, [DoubleLinkedQueueEntry$(E), DoubleLinkedQueueEntry$(E)]],
         append: [dart.void, [E]],
         prepend: [dart.void, [E]],
         remove: [E, []],
         [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []],
         previousEntry: [DoubleLinkedQueueEntry$(E), []],
         nextEntry: [DoubleLinkedQueueEntry$(E), []]
       })
     });
@@ skipping 14 matching lines @@
       }
       set element(e) {
         dart.as(e, E);
         dart.assert(false);
       }
       get element() {
         throw _internal.IterableElementError.noElement();
       }
     }
     dart.setSignature(_DoubleLinkedQueueEntrySentinel, {
+      constructors: () => ({_DoubleLinkedQueueEntrySentinel: [_DoubleLinkedQueueEntrySentinel$(E), []]}),
       methods: () => ({
         remove: [E, []],
         [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []]
       })
     });
     return _DoubleLinkedQueueEntrySentinel;
   });
   let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
   let _sentinel = Symbol('_sentinel');
   let _elementCount = Symbol('_elementCount');
@@ skipping 118 matching lines @@
       get [core.$iterator]() {
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     dart.setSignature(DoubleLinkedQueue, {
+      constructors: () => ({
+        DoubleLinkedQueue: [DoubleLinkedQueue$(E), []],
+        from: [DoubleLinkedQueue$(E), [core.Iterable]]
+      }),
       methods: () => ({
         addLast: [dart.void, [E]],
         addFirst: [dart.void, [E]],
         add: [dart.void, [E]],
         addAll: [dart.void, [core.Iterable$(E)]],
         removeLast: [E, []],
         removeFirst: [E, []],
         remove: [core.bool, [core.Object]],
         [_filter]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
         removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
@@ skipping 24 matching lines @@
         this[_current] = null;
         this[_nextEntry] = this[_sentinel] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _DoubleLinkedQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_DoubleLinkedQueueIterator, {
+      constructors: () => ({_DoubleLinkedQueueIterator: [_DoubleLinkedQueueIterator$(E), [_DoubleLinkedQueueEntrySentinel$(E)]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _DoubleLinkedQueueIterator;
   });
   let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$();
   let _head = Symbol('_head');
   let _tail = Symbol('_tail');
   let _table = Symbol('_table');
   let _checkModification = Symbol('_checkModification');
   let _writeToList = Symbol('_writeToList');
@@ skipping 282 matching lines @@
         let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
         let newTable = new (core.List$(E))(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
     dart.setSignature(ListQueue, {
+      constructors: () => ({
+        ListQueue: [ListQueue$(E), [], [core.int]],
+        from: [ListQueue$(E), [core.Iterable]]
+      }),
       methods: () => ({
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [core.$elementAt]: [E, [core.int]],
         [core.$toList]: [core.List$(E), [], {rowabl: core.bool}],
         add: [dart.void, [E]],
         addAll: [dart.void, [core.Iterable$(E)]],
         remove: [core.bool, [core.Object]],
         [_filterWhere]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
         removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
@@ skipping 40 matching lines @@
           this[_current] = null;
           return false;
         }
         this[_current] = dart.as(this[_queue][_table][core.$get](this[_position]), E);
         this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][core.$length]) - 1;
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_ListQueueIterator, {
+      constructors: () => ({_ListQueueIterator: [_ListQueueIterator$(E), [ListQueue]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _ListQueueIterator;
   });
   let _ListQueueIterator = _ListQueueIterator$();
   let _Predicate$ = dart.generic(function(T) {
     let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   let _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
     }
+    dart.setSignature(_SplayTreeNode, {
+      constructors: () => ({_SplayTreeNode: [_SplayTreeNode$(K), [K]]})
+    });
     return _SplayTreeNode;
   });
   let _SplayTreeNode = _SplayTreeNode$();
   let _SplayTreeMapNode$ = dart.generic(function(K, V) {
     class _SplayTreeMapNode extends _SplayTreeNode$(K) {
       _SplayTreeMapNode(key, value) {
         this.value = value;
         super._SplayTreeNode(key);
       }
     }
+    dart.setSignature(_SplayTreeMapNode, {
+      constructors: () => ({_SplayTreeMapNode: [_SplayTreeMapNode$(K, V), [K, V]]})
+    });
     return _SplayTreeMapNode;
   });
   let _SplayTreeMapNode = _SplayTreeMapNode$();
   let _dummy = Symbol('_dummy');
   let _root = Symbol('_root');
   let _count = Symbol('_count');
   let _splayCount = Symbol('_splayCount');
   let _splay = Symbol('_splay');
   let _compare = Symbol('_compare');
   let _splayMin = Symbol('_splayMin');
@@ skipping 369 matching lines @@
         }
         return node.key;
       }
     }
     SplayTreeMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(SplayTreeMap, 'from');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterable');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterables');
     dart.defineNamedConstructor(SplayTreeMap, '_internal');
     dart.setSignature(SplayTreeMap, {
+      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], {e: dart.functionType(K, [dart.bottom]), alu: dart.functionType(V, [dart.bottom]), ompar: dart.functionType(core.int, [K, K]), sValidKe: 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)]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         clear: [dart.void, []],
         containsKey: [core.bool, [core.Object]],
@@ skipping 73 matching lines @@
           this[_rebuildWorkList](this[_currentNode]);
         }
         this[_currentNode] = this[_workList][core.$removeLast]();
         this[_findLeftMostDescendent](this[_currentNode].right);
         return true;
       }
     }
     _SplayTreeIterator[dart.implements] = () => [core.Iterator$(T)];
     dart.defineNamedConstructor(_SplayTreeIterator, 'startAt');
     dart.setSignature(_SplayTreeIterator, {
+      constructors: () => ({
+        _SplayTreeIterator: [_SplayTreeIterator$(T), [_SplayTree]],
+        startAt: [_SplayTreeIterator$(T), [_SplayTree, core.Object]]
+      }),
       methods: () => ({
         [_findLeftMostDescendent]: [dart.void, [_SplayTreeNode]],
         [_rebuildWorkList]: [dart.void, [_SplayTreeNode]],
         moveNext: [core.bool, []]
       })
     });
     return _SplayTreeIterator;
   });
   let _SplayTreeIterator = _SplayTreeIterator$();
   let _copyNode = Symbol('_copyNode');
@@ skipping 15 matching lines @@
       [core.$toSet]() {
         let setOrMap = this[_tree];
         let set = new (SplayTreeSet$(K))(dart.as(setOrMap[_comparator], __CastType0), dart.as(setOrMap[_validKey], __CastType3));
         set[_count] = this[_tree][_count];
         set[_root] = set[_copyNode](this[_tree][_root]);
         return set;
       }
     }
     _SplayTreeKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(_SplayTreeKeyIterable, {
+      constructors: () => ({_SplayTreeKeyIterable: [_SplayTreeKeyIterable$(K), [_SplayTree$(K)]]}),
       methods: () => ({[core.$toSet]: [core.Set$(K), []]})
     });
     return _SplayTreeKeyIterable;
   });
   let _SplayTreeKeyIterable = _SplayTreeKeyIterable$();
   let _SplayTreeValueIterable$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterable extends IterableBase$(V) {
       _SplayTreeValueIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$length]() {
         return this[_map][_count];
       }
       get [core.$isEmpty]() {
         return this[_map][_count] == 0;
       }
       get [core.$iterator]() {
         return new (_SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_SplayTreeValueIterable, {
+      constructors: () => ({_SplayTreeValueIterable: [_SplayTreeValueIterable$(K, V), [SplayTreeMap$(K, V)]]})
+    });
     return _SplayTreeValueIterable;
   });
   let _SplayTreeValueIterable = _SplayTreeValueIterable$();
   let _SplayTreeKeyIterator$ = dart.generic(function(K) {
     class _SplayTreeKeyIterator extends _SplayTreeIterator$(K) {
       _SplayTreeKeyIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.key, K);
       }
     }
     dart.setSignature(_SplayTreeKeyIterator, {
+      constructors: () => ({_SplayTreeKeyIterator: [_SplayTreeKeyIterator$(K), [_SplayTree$(K)]]}),
       methods: () => ({[_getValue]: [K, [_SplayTreeNode]]})
     });
     return _SplayTreeKeyIterator;
   });
   let _SplayTreeKeyIterator = _SplayTreeKeyIterator$();
   let _SplayTreeValueIterator$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterator extends _SplayTreeIterator$(V) {
       _SplayTreeValueIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.value, V);
       }
     }
     dart.setSignature(_SplayTreeValueIterator, {
+      constructors: () => ({_SplayTreeValueIterator: [_SplayTreeValueIterator$(K, V), [SplayTreeMap$(K, V)]]}),
       methods: () => ({[_getValue]: [V, [_SplayTreeMapNode]]})
     });
     return _SplayTreeValueIterator;
   });
   let _SplayTreeValueIterator = _SplayTreeValueIterator$();
   let _SplayTreeNodeIterator$ = dart.generic(function(K) {
     class _SplayTreeNodeIterator extends _SplayTreeIterator$(_SplayTreeNode$(K)) {
       _SplayTreeNodeIterator(tree) {
         super._SplayTreeIterator(tree);
       }
       startAt(tree, startKey) {
         super.startAt(tree, startKey);
       }
       [_getValue](node) {
         return dart.as(node, _SplayTreeNode$(K));
       }
     }
     dart.defineNamedConstructor(_SplayTreeNodeIterator, 'startAt');
     dart.setSignature(_SplayTreeNodeIterator, {
+      constructors: () => ({
+        _SplayTreeNodeIterator: [_SplayTreeNodeIterator$(K), [_SplayTree$(K)]],
+        startAt: [_SplayTreeNodeIterator$(K), [_SplayTree$(K), core.Object]]
+      }),
       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)
@@ skipping 146 matching lines @@
       }
       [core.$toSet]() {
         return this[_clone]();
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     dart.defineNamedConstructor(SplayTreeSet, 'from');
     dart.setSignature(SplayTreeSet, {
+      constructors: () => ({
+        SplayTreeSet: [SplayTreeSet$(E), [], [dart.functionType(core.int, [E, E]), dart.functionType(core.bool, [core.Object])]],
+        from: [SplayTreeSet$(E), [core.Iterable], [dart.functionType(core.int, [E, E]), dart.functionType(core.bool, [core.Object])]]
+      }),
       methods: () => ({
         [_compare]: [core.int, [E, E]],
         [core.$contains]: [core.bool, [core.Object]],
         add: [core.bool, [E]],
         remove: [core.bool, [core.Object]],
         addAll: [dart.void, [core.Iterable$(E)]],
         lookup: [E, [core.Object]],
         intersection: [core.Set$(E), [core.Set$(core.Object)]],
         difference: [core.Set$(E), [core.Set$(core.Object)]],
         union: [core.Set$(E), [core.Set$(E)]],
@@ skipping 289 matching lines @@
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashMap$()._setTableEntry(table, temporaryKey, table);
         _HashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashMap[dart.implements] = () => [HashMap$(K, V)];
     dart.setSignature(_HashMap, {
+      constructors: () => ({_HashMap: [_HashMap$(K, V), []]}),
       methods: () => ({
         containsKey: [core.bool, [core.Object]],
         [_containsKey]: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         addAll: [dart.void, [core.Map$(K, V)]],
         get: [V, [core.Object]],
         [_get]: [V, [core.Object]],
         set: [dart.void, [K, V]],
         [_set]: [dart.void, [K, V]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
@@ skipping 85 matching lines @@
           if (this[_equals](dart.as(bucket[i], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     dart.setSignature(_CustomHashMap, {
+      constructors: () => ({_CustomHashMap: [_CustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         remove: [V, [core.Object]]
       })
     });
     return _CustomHashMap;
   });
   let _CustomHashMap = _CustomHashMap$();
   let HashMapKeyIterable$ = dart.generic(function(E) {
@@ skipping 20 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]]}),
       methods: () => ({[core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]]})
     });
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$();
   let _offset = Symbol('_offset');
   let HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map, keys) {
         this[_map] = map;
@@ skipping 14 matching lines @@
           return false;
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashMapKeyIterator, {
+      constructors: () => ({HashMapKeyIterator: [HashMapKeyIterator$(E), [core.Object, 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 271 matching lines @@
         _LinkedHashMap$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     _LinkedHashMap[dart.implements] = () => [LinkedHashMap$(K, V), _js_helper.InternalMap];
     dart.setSignature(_LinkedHashMap, {
+      constructors: () => ({_LinkedHashMap: [_LinkedHashMap$(K, V), []]}),
       methods: () => ({
         containsKey: [core.bool, [core.Object]],
         [_containsKey]: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         addAll: [dart.void, [core.Map$(K, V)]],
         get: [V, [core.Object]],
         [_get]: [V, [core.Object]],
         set: [dart.void, [K, V]],
         [_set]: [dart.void, [K, V]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
@@ skipping 83 matching lines @@
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (this[_equals](dart.as(cell[_key], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
     }
     dart.setSignature(_LinkedCustomHashMap, {
+      constructors: () => ({_LinkedCustomHashMap: [_LinkedCustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         remove: [V, [core.Object]]
       })
     });
     return _LinkedCustomHashMap;
   });
   let _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(LinkedHashMapCell, {
+    constructors: () => ({LinkedHashMapCell: [LinkedHashMapCell, [core.Object, core.Object]]})
+  });
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
       LinkedHashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$length]() {
         return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get [core.$isEmpty]() {
@@ skipping 13 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]]}),
       methods: () => ({[core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]]})
     });
     return LinkedHashMapKeyIterable;
   });
   let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
   let _cell = Symbol('_cell');
   let LinkedHashMapKeyIterator$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map, modifications) {
         this[_map] = map;
@@ skipping 13 matching lines @@
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(LinkedHashMapKeyIterator, {
+      constructors: () => ({LinkedHashMapKeyIterator: [LinkedHashMapKeyIterator$(E), [core.Object, 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 221 matching lines @@
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _HashSet$()._setTableEntry(table, temporaryKey, table);
         _HashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashSet[dart.implements] = () => [HashSet$(E)];
     dart.setSignature(_HashSet, {
+      constructors: () => ({_HashSet: [_HashSet$(E), []]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         [core.$contains]: [core.bool, [core.Object]],
         [_contains]: [core.bool, [core.Object]],
         lookup: [E, [core.Object]],
         [_lookup]: [E, [core.Object]],
         add: [core.bool, [E]],
         [_add]: [core.bool, [E]],
         addAll: [dart.void, [core.Iterable$(E)]],
         remove: [core.bool, [core.Object]],
@@ skipping 86 matching lines @@
           return null;
         return super[_lookup](object);
       }
       remove(object) {
         if (!dart.notNull(this[_validKey](object)))
           return false;
         return super[_remove](object);
       }
     }
     dart.setSignature(_CustomHashSet, {
+      constructors: () => ({_CustomHashSet: [_CustomHashSet$(E), [_Equality$(E), _Hasher$(E), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         add: [core.bool, [E]],
         lookup: [E, [core.Object]]
       })
     });
     return _CustomHashSet;
   });
   let _CustomHashSet = _CustomHashSet$();
   let HashSetIterator$ = dart.generic(function(E) {
@@ skipping 17 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]]}),
       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 262 matching lines @@
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashSet$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _LinkedHashSet[dart.implements] = () => [LinkedHashSet$(E)];
     dart.setSignature(_LinkedHashSet, {
+      constructors: () => ({_LinkedHashSet: [_LinkedHashSet$(E), []]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         [_unsupported]: [dart.void, [core.String]],
         [core.$contains]: [core.bool, [core.Object]],
         [_contains]: [core.bool, [core.Object]],
         lookup: [E, [core.Object]],
         [_lookup]: [E, [core.Object]],
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         add: [core.bool, [E]],
         [_add]: [core.bool, [E]],
@@ skipping 106 matching lines @@
       }
       removeAll(elements) {
         for (let element of elements) {
           if (this[_validKey](element)) {
             super[_remove](element);
           }
         }
       }
     }
     dart.setSignature(_LinkedCustomHashSet, {
+      constructors: () => ({_LinkedCustomHashSet: [_LinkedCustomHashSet$(E), [_Equality$(E), _Hasher$(E), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         add: [core.bool, [E]],
         lookup: [E, [core.Object]]
       })
     });
     return _LinkedCustomHashSet;
   });
   let _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(LinkedHashSetCell, {
+    constructors: () => ({LinkedHashSetCell: [LinkedHashSetCell, [core.Object]]})
+  });
   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]]}),
       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;
 })(collection, _internal, core, _js_helper, math);