fixes browser/runtime_test, and a few extension member fixes

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 length() {
         return this[_source].length;
       }
       get(index) {
         return this[_source][dartx.elementAt](index);
       }
     }
     dart.setSignature(UnmodifiableListView, {
       constructors: () => ({UnmodifiableListView: [exports.UnmodifiableListView$(E), [core.Iterable$(E)]]}),
       methods: () => ({get: [E, [core.int]]})
     });
+    dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
     return dart.hashCode(a);
   }
@@ skipping 337 matching lines @@
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw core.RangeError.index(index, this, "index", null, elementIndex);
       }
     }
     SetMixin[dart.implements] = () => [core.Set$(E)];
-    dart.defineExtensionMembers(SetMixin, [
-      'toList',
-      'map',
-      'where',
-      'expand',
-      'forEach',
-      'reduce',
-      'fold',
-      'every',
-      'join',
-      'any',
-      'take',
-      'takeWhile',
-      'skip',
-      'skipWhile',
-      'firstWhere',
-      'lastWhere',
-      'singleWhere',
-      'elementAt',
-      'isEmpty',
-      'isNotEmpty',
-      'single',
-      'first',
-      'last'
-    ]);
     dart.setSignature(SetMixin, {
       methods: () => ({
         clear: [dart.void, []],
         addAll: [dart.void, [core.Iterable$(E)]],
         removeAll: [dart.void, [core.Iterable$(core.Object)]],
         retainAll: [dart.void, [core.Iterable$(core.Object)]],
         removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         containsAll: [core.bool, [core.Iterable$(core.Object)]],
         union: [core.Set$(E), [core.Set$(E)]],
@@ skipping 12 matching lines @@
         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])]],
         elementAt: [E, [core.int]]
       })
     });
+    dart.defineExtensionMembers(SetMixin, [
+      'toList',
+      'map',
+      'where',
+      'expand',
+      'forEach',
+      'reduce',
+      'fold',
+      'every',
+      'join',
+      'any',
+      'take',
+      'takeWhile',
+      'skip',
+      'skipWhile',
+      'firstWhere',
+      'lastWhere',
+      'singleWhere',
+      'elementAt',
+      'isEmpty',
+      'isNotEmpty',
+      'single',
+      'first',
+      'last'
+    ]);
     return SetMixin;
   });
   let SetMixin = SetMixin$();
   let SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
     dart.setSignature(SetBase, {
@@ skipping 30 matching lines @@
         })();
       }
     }
     dart.setSignature(_HashSetBase, {
       methods: () => ({
         difference: [core.Set$(E), [core.Set$(core.Object)]],
         intersection: [core.Set$(E), [core.Set$(core.Object)]],
         toSet: [core.Set$(E), []]
       })
     });
+    dart.defineExtensionMembers(_HashSetBase, ['toSet']);
     return _HashSetBase;
   });
   let _HashSetBase = _HashSetBase$();
   let HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
       static new(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 248 matching lines @@
         throw core.RangeError.index(index, this, "index", null, elementIndex);
       }
       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])]],
+        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])]],
+        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, [])}],
+        lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
+        singleWhere: [E, [dart.functionType(core.bool, [E])]],
+        elementAt: [E, [core.int]]
+      })
+    });
     dart.defineExtensionMembers(IterableMixin, [
       'map',
       'where',
       'expand',
       'contains',
       'forEach',
       'reduce',
       'fold',
       'every',
       'join',
       'any',
       'toList',
       'toSet',
       'take',
       'takeWhile',
       'skip',
       'skipWhile',
       'firstWhere',
       'lastWhere',
       'singleWhere',
       'elementAt',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
-    dart.setSignature(IterableMixin, {
-      methods: () => ({
-        map: [core.Iterable, [dart.functionType(core.Object, [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])]],
-        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, [])}],
-        lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
-        singleWhere: [E, [dart.functionType(core.bool, [E])]],
-        elementAt: [E, [core.int]]
-      })
-    });
     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);
@@ skipping 326 matching lines @@
           parts[dartx.add](elision);
         }
         parts[dartx.add](penultimateString);
         parts[dartx.add](ultimateString);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
       }
     }
     IterableBase[dart.implements] = () => [core.Iterable$(E)];
-    dart.defineExtensionMembers(IterableBase, [
-      'map',
-      'where',
-      'expand',
-      'contains',
-      'forEach',
-      'reduce',
-      'fold',
-      'every',
-      'join',
-      'any',
-      'toList',
-      'toSet',
-      'take',
-      'takeWhile',
-      'skip',
-      'skipWhile',
-      'firstWhere',
-      'lastWhere',
-      'singleWhere',
-      'elementAt',
-      'length',
-      'isEmpty',
-      'isNotEmpty',
-      'first',
-      'last',
-      'single'
-    ]);
     dart.setSignature(IterableBase, {
       constructors: () => ({IterableBase: [IterableBase$(E), []]}),
       methods: () => ({
         map: [core.Iterable, [dart.functionType(core.Object, [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])]],
@@ skipping 12 matching lines @@
         elementAt: [E, [core.int]]
       }),
       statics: () => ({
         iterableToShortString: [core.String, [core.Iterable], [core.String, core.String]],
         iterableToFullString: [core.String, [core.Iterable], [core.String, core.String]],
         _isToStringVisiting: [core.bool, [core.Object]],
         _iterablePartsToStrings: [dart.void, [core.Iterable, core.List]]
       }),
       names: ['iterableToShortString', 'iterableToFullString', '_isToStringVisiting', '_iterablePartsToStrings']
     });
+    dart.defineExtensionMembers(IterableBase, [
+      'map',
+      'where',
+      'expand',
+      'contains',
+      'forEach',
+      'reduce',
+      'fold',
+      'every',
+      'join',
+      'any',
+      'toList',
+      'toSet',
+      'take',
+      'takeWhile',
+      'skip',
+      'skipWhile',
+      'firstWhere',
+      'lastWhere',
+      'singleWhere',
+      'elementAt',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'first',
+      'last',
+      'single'
+    ]);
     return IterableBase;
   });
   let IterableBase = IterableBase$();
   dart.defineLazyProperties(IterableBase, {
     get _toStringVisiting() {
       return [];
     }
   });
   let _iterator = Symbol('_iterator');
   let _state = Symbol('_state');
@@ skipping 274 matching lines @@
       [_unlink](entry) {
         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.defineExtensionMembers(LinkedList, [
-      'forEach',
-      'iterator',
-      'length',
-      'first',
-      'last',
-      'single',
-      'isEmpty'
-    ]);
     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, []],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         [_insertAfter]: [dart.void, [_LinkedListLink, E]],
         [_unlink]: [dart.void, [LinkedListEntry$(E)]]
       })
     });
+    dart.defineExtensionMembers(LinkedList, [
+      'forEach',
+      'iterator',
+      'length',
+      'first',
+      'last',
+      'single',
+      'isEmpty'
+    ]);
     return LinkedList;
   });
   let LinkedList = LinkedList$();
   let _current = Symbol('_current');
   let _LinkedListIterator$ = dart.generic(function(E) {
     class _LinkedListIterator extends core.Object {
       _LinkedListIterator(list) {
         this[_list] = list;
         this[_modificationCount] = list[_modificationCount];
         this[_next] = list[_next];
@@ skipping 550 matching lines @@
         }
       }
       get reversed() {
         return new (_internal.ReversedListIterable$(E))(this);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '[', ']');
       }
     }
     ListMixin[dart.implements] = () => [core.List$(E)];
+    dart.setSignature(ListMixin, {
+      methods: () => ({
+        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])]],
+        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])]],
+        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]]}),
+      names: ['_filter']
+    });
     dart.defineExtensionMembers(ListMixin, [
       'elementAt',
       'forEach',
       'contains',
       'every',
       'any',
       'firstWhere',
       'lastWhere',
       'singleWhere',
       'join',
@@ skipping 31 matching lines @@
       'insertAll',
       'setAll',
       'iterator',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single',
       'reversed'
     ]);
-    dart.setSignature(ListMixin, {
-      methods: () => ({
-        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])]],
-        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])]],
-        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]]}),
-      names: ['_filter']
-    });
     return ListMixin;
   });
   let ListMixin = ListMixin$();
   let ListBase$ = dart.generic(function(E) {
     class ListBase extends dart.mixin(core.Object, ListMixin$(E)) {
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
     dart.setSignature(ListBase, {
@@ skipping 133 matching lines @@
         return dart.as(this[_map].get(this[_map].keys[dartx.single]), V);
       }
       get last() {
         return dart.as(this[_map].get(this[_map].keys[dartx.last]), V);
       }
       get iterator() {
         return new (_MapBaseValueIterator$(V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(_MapBaseValueIterable, {
+      constructors: () => ({_MapBaseValueIterable: [_MapBaseValueIterable$(V), [core.Map]]})
+    });
     dart.defineExtensionMembers(_MapBaseValueIterable, [
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'single',
       'last',
       'iterator'
     ]);
-    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[dartx.iterator];
         this[_current] = null;
@@ skipping 453 matching lines @@
         }
       }
       get iterator() {
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
-    dart.defineExtensionMembers(DoubleLinkedQueue, [
-      'length',
-      'first',
-      'last',
-      'single',
-      'isEmpty',
-      'iterator'
-    ]);
     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])]],
         retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         lastEntry: [DoubleLinkedQueueEntry$(E), []],
         firstEntry: [DoubleLinkedQueueEntry$(E), []],
         clear: [dart.void, []],
         forEachEntry: [dart.void, [dart.functionType(dart.void, [DoubleLinkedQueueEntry$(E)])]]
       })
     });
+    dart.defineExtensionMembers(DoubleLinkedQueue, [
+      'length',
+      'first',
+      'last',
+      'single',
+      'isEmpty',
+      'iterator'
+    ]);
     return DoubleLinkedQueue;
   });
   let DoubleLinkedQueue = DoubleLinkedQueue$();
   let _nextEntry = Symbol('_nextEntry');
   let _DoubleLinkedQueueIterator$ = dart.generic(function(E) {
     class _DoubleLinkedQueueIterator extends core.Object {
       _DoubleLinkedQueueIterator(sentinel) {
         this[_sentinel] = sentinel;
         this[_nextEntry] = sentinel[_next];
         this[_current] = null;
@@ skipping 308 matching lines @@
         dart.assert(dart.notNull(newElementCount) >= dart.notNull(this.length));
         newElementCount = dart.notNull(newElementCount) + (dart.notNull(newElementCount) >> 1);
         let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
         let newTable = core.List$(E).new(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
-    dart.defineExtensionMembers(ListQueue, [
-      'forEach',
-      'elementAt',
-      'toList',
-      'iterator',
-      'isEmpty',
-      'length',
-      'first',
-      'last',
-      'single'
-    ]);
     dart.setSignature(ListQueue, {
       constructors: () => ({
         ListQueue: [ListQueue$(E), [], [core.int]],
         from: [ListQueue$(E), [core.Iterable]]
       }),
       methods: () => ({
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
         elementAt: [E, [core.int]],
         toList: [core.List$(E), [], {growable: core.bool}],
         add: [dart.void, [E]],
@@ skipping 13 matching lines @@
         [_grow]: [dart.void, []],
         [_writeToList]: [core.int, [core.List$(E)]],
         [_preGrow]: [dart.void, [core.int]]
       }),
       statics: () => ({
         _isPowerOf2: [core.bool, [core.int]],
         _nextPowerOf2: [core.int, [core.int]]
       }),
       names: ['_isPowerOf2', '_nextPowerOf2']
     });
+    dart.defineExtensionMembers(ListQueue, [
+      'forEach',
+      'elementAt',
+      'toList',
+      'iterator',
+      'isEmpty',
+      'length',
+      'first',
+      'last',
+      'single'
+    ]);
     return ListQueue;
   });
   let ListQueue = ListQueue$();
   ListQueue._INITIAL_CAPACITY = 8;
   let _queue = Symbol('_queue');
   let _end = Symbol('_end');
   let _position = Symbol('_position');
   let _ListQueueIterator$ = dart.generic(function(E) {
     class _ListQueueIterator extends core.Object {
       _ListQueueIterator(queue) {
@@ skipping 571 matching lines @@
       }
       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.defineExtensionMembers(_SplayTreeKeyIterable, ['toSet', 'length', 'isEmpty', 'iterator']);
     dart.setSignature(_SplayTreeKeyIterable, {
       constructors: () => ({_SplayTreeKeyIterable: [_SplayTreeKeyIterable$(K), [_SplayTree$(K)]]}),
       methods: () => ({toSet: [core.Set$(K), []]})
     });
+    dart.defineExtensionMembers(_SplayTreeKeyIterable, ['toSet', 'length', 'isEmpty', 'iterator']);
     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 length() {
         return this[_map][_count];
       }
       get isEmpty() {
         return this[_map][_count] == 0;
       }
       get iterator() {
         return new (_SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
-    dart.defineExtensionMembers(_SplayTreeValueIterable, ['length', 'isEmpty', 'iterator']);
     dart.setSignature(_SplayTreeValueIterable, {
       constructors: () => ({_SplayTreeValueIterable: [_SplayTreeValueIterable$(K, V), [SplayTreeMap$(K, V)]]})
     });
+    dart.defineExtensionMembers(_SplayTreeValueIterable, ['length', 'isEmpty', 'iterator']);
     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);
@@ skipping 217 matching lines @@
         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)]],
         [_clone]: [SplayTreeSet$(E), []],
         [_copyNode]: [_SplayTreeNode$(E), [_SplayTreeNode$(E)]],
         toSet: [core.Set$(E), []]
       })
     });
+    dart.defineExtensionMembers(SplayTreeSet, [
+      'contains',
+      'toSet',
+      'iterator',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'first',
+      'last',
+      'single'
+    ]);
     return SplayTreeSet;
   });
   let SplayTreeSet = SplayTreeSet$();
   let __CastType0$ = dart.generic(function(K) {
     let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.int, [K, K]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
   let __CastType3 = dart.typedef('__CastType3', () => dart.functionType(core.bool, [core.Object]));
   let _strings = Symbol('_strings');
@@ skipping 420 matching lines @@
         let keys = dart.as(dart.dsend(this[_map], _computeKeys), core.List);
         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: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
+    });
     dart.defineExtensionMembers(HashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
-    dart.setSignature(HashMapKeyIterable, {
-      constructors: () => ({HashMapKeyIterable: [HashMapKeyIterable$(E), [core.Object]]}),
-      methods: () => ({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;
         this[_keys] = keys;
         this[_offset] = 0;
@@ skipping 461 matching lines @@
         while (cell != null) {
           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: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
+    });
     dart.defineExtensionMembers(LinkedHashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
-    dart.setSignature(LinkedHashMapKeyIterable, {
-      constructors: () => ({LinkedHashMapKeyIterable: [LinkedHashMapKeyIterable$(E), [core.Object]]}),
-      methods: () => ({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;
         this[_modifications] = modifications;
         this[_cell] = null;
@@ skipping 252 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.defineExtensionMembers(_HashSet, [
-      'contains',
-      'iterator',
-      'length',
-      'isEmpty',
-      'isNotEmpty'
-    ]);
     dart.setSignature(_HashSet, {
       constructors: () => ({_HashSet: [_HashSet$(E), []]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         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]],
@@ skipping 10 matching lines @@
       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, []]
       }),
       names: ['_isStringElement', '_isNumericElement', '_hasTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
+    dart.defineExtensionMembers(_HashSet, [
+      'contains',
+      'iterator',
+      'length',
+      'isEmpty',
+      'isNotEmpty'
+    ]);
     return _HashSet;
   });
   let _HashSet = _HashSet$();
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       _IdentityHashSet() {
         super._HashSet();
       }
       [_newSet]() {
         return new (_IdentityHashSet$(E))();
@@ skipping 65 matching lines @@
       }
     }
     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]]
       })
     });
+    dart.defineExtensionMembers(_CustomHashSet, ['contains']);
     return _CustomHashSet;
   });
   let _CustomHashSet = _CustomHashSet$();
   let HashSetIterator$ = dart.generic(function(E) {
     class HashSetIterator extends core.Object {
       HashSetIterator(set, elements) {
         this[_set] = set;
         this[_elements] = elements;
         this[_offset] = 0;
         this[_current] = null;
@@ skipping 293 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.defineExtensionMembers(_LinkedHashSet, [
-      'contains',
-      'forEach',
-      'iterator',
-      'length',
-      'isEmpty',
-      'isNotEmpty',
-      'first',
-      'last'
-    ]);
     dart.setSignature(_LinkedHashSet, {
       constructors: () => ({_LinkedHashSet: [_LinkedHashSet$(E), []]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         [_unsupported]: [dart.void, [core.String]],
         contains: [core.bool, [core.Object]],
         [_contains]: [core.bool, [core.Object]],
         lookup: [E, [core.Object]],
         [_lookup]: [E, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [E])]],
@@ skipping 16 matching lines @@
       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, []]
       }),
       names: ['_isStringElement', '_isNumericElement', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
+    dart.defineExtensionMembers(_LinkedHashSet, [
+      'contains',
+      'forEach',
+      'iterator',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'first',
+      'last'
+    ]);
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$();
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       _LinkedIdentityHashSet() {
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedIdentityHashSet$(E))();
@@ skipping 79 matching lines @@
       }
     }
     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]]
       })
     });
+    dart.defineExtensionMembers(_LinkedCustomHashSet, ['contains']);
     return _LinkedCustomHashSet;
   });
   let _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
@@ skipping 92 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);