keep mixin and interface implementation info at runtime

lib/runtime/dart/collection.js

 var collection;
 (function(exports) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
         super.UnmodifiableListBase();
       }
@@ skipping 61 matching lines @@
         let map = new HashMap();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values) {
         let map = new HashMap();
         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');
     return HashMap;
   });
   let HashMap = HashMap$(dart.dynamic, dart.dynamic);
   let _newSet = Symbol('_newSet');
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
@@ skipping 231 matching lines @@
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index === elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
     }
+    SetMixin[dart.implements] = [core.Set$(E)];
     return SetMixin;
   });
   let SetMixin = SetMixin$(dart.dynamic);
   let SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
     return SetBase;
@@ skipping 60 matching lines @@
       identity() {
         return new _IdentityHashSet();
       }
       from(elements) {
         let result = new HashSet();
         for (let e of elements)
           result.add(e);
         return result;
       }
     }
+    HashSet[dart.implements] = [core.Set$(E)];
     dart.defineNamedConstructor(HashSet, 'identity');
     dart.defineNamedConstructor(HashSet, 'from');
     return HashSet;
   });
   let HashSet = HashSet$(dart.dynamic);
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       map(f) {
         return new _internal.MappedIterable(this, f);
       }
@@ skipping 177 matching lines @@
           if (index === elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase.iterableToShortString(this, '(', ')');
       }
     }
+    IterableMixin[dart.implements] = [core.Iterable$(E)];
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$(dart.dynamic);
   let _isToStringVisiting = Symbol('_isToStringVisiting');
   let _toStringVisiting = Symbol('_toStringVisiting');
   let _iterablePartsToStrings = Symbol('_iterablePartsToStrings');
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
@@ skipping 309 matching lines @@
             length = dart.notNull(ELLIPSIS_SIZE) + dart.notNull(OVERHEAD);
           }
         }
         if (elision !== null) {
           parts.add(elision);
         }
         parts.add(penultimateString);
         parts.add(ultimateString);
       }
     }
+    IterableBase[dart.implements] = [core.Iterable$(E)];
     dart.defineLazyProperties(IterableBase, {
       get _toStringVisiting() {
         return new core.List.from([]);
       }
     });
     return IterableBase;
   });
   let IterableBase = IterableBase$(dart.dynamic);
   let _iterator = Symbol('_iterator');
   let _NOT_MOVED_YET = Symbol('_NOT_MOVED_YET');
@@ skipping 88 matching lines @@
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       [_literal](keyValuePairs) {
         return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new _LinkedHashMap()), LinkedHashMap$(K, V));
       }
       [_empty]() {
         return new _LinkedHashMap();
       }
     }
+    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);
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$(dart.dynamic, dart.dynamic);
   let LinkedHashSet$ = dart.generic(function(E) {
@@ skipping 30 matching lines @@
         return new _LinkedIdentityHashSet();
       }
       from(elements) {
         let result = new LinkedHashSet();
         for (let element of elements) {
           result.add(element);
         }
         return result;
       }
     }
+    LinkedHashSet[dart.implements] = [HashSet$(E)];
     dart.defineNamedConstructor(LinkedHashSet, 'identity');
     dart.defineNamedConstructor(LinkedHashSet, 'from');
     return LinkedHashSet;
   });
   let LinkedHashSet = LinkedHashSet$(dart.dynamic);
   let _modificationCount = Symbol('_modificationCount');
   let _length = Symbol('_length');
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   let _insertAfter = Symbol('_insertAfter');
@@ skipping 91 matching lines @@
         this[_length] = dart.notNull(this[_length]) + 1;
       }
       [_unlink](entry) {
         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];
     return LinkedList;
   });
   let LinkedList = LinkedList$(dart.dynamic);
   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];
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (core.identical(this[_next], this[_list])) {
           this[_current] = null;
           return false;
         }
         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)];
     return _LinkedListIterator;
   });
   let _LinkedListIterator = _LinkedListIterator$(dart.dynamic);
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let LinkedListEntry$ = dart.generic(function(E) {
@@ skipping 20 matching lines @@
           return null;
         return dart.as(this[_previous], E);
       }
       insertAfter(entry) {
         this[_list]._insertAfter(this, entry);
       }
       insertBefore(entry) {
         this[_list]._insertAfter(this[_previous], entry);
       }
     }
+    LinkedListEntry[dart.implements] = [_LinkedListLink];
     return LinkedListEntry;
   });
   let LinkedListEntry = LinkedListEntry$(dart.dynamic);
   let _filter = Symbol('_filter');
   let ListMixin$ = dart.generic(function(E) {
     class ListMixin extends core.Object {
       get iterator() {
         return new _internal.ListIterator(this);
       }
       elementAt(index) {
@@ skipping 431 matching lines @@
           }
         }
       }
       get reversed() {
         return new _internal.ReversedListIterable(this);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '[', ']');
       }
     }
+    ListMixin[dart.implements] = [core.List$(E)];
     return ListMixin;
   });
   let ListMixin = ListMixin$(dart.dynamic);
   let ListBase$ = dart.generic(function(E) {
     class ListBase extends dart.mixin(core.Object, ListMixin$(E)) {
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
     return ListBase;
@@ skipping 36 matching lines @@
       get isNotEmpty() {
         return this.keys.isNotEmpty;
       }
       get values() {
         return new _MapBaseValueIterable(this);
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
+    MapMixin[dart.implements] = [core.Map$(K, V)];
     return MapMixin;
   });
   let MapMixin = MapMixin$(dart.dynamic, dart.dynamic);
   let MapBase$ = dart.generic(function(K, V) {
     class MapBase extends dart.mixin(MapMixin$(K, V)) {
     }
     return MapBase;
   });
   let MapBase = MapBase$(dart.dynamic, dart.dynamic);
   let _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
     class _UnmodifiableMapMixin extends core.Object {
       set(key, value) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       addAll(other) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       clear() {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       remove(key) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
       putIfAbsent(key, ifAbsent) {
         throw new core.UnsupportedError("Cannot modify unmodifiable map");
       }
     }
+    _UnmodifiableMapMixin[dart.implements] = [core.Map$(K, V)];
     return _UnmodifiableMapMixin;
   });
   let _UnmodifiableMapMixin = _UnmodifiableMapMixin$(dart.dynamic, dart.dynamic);
   let UnmodifiableMapBase$ = dart.generic(function(K, V) {
     class UnmodifiableMapBase extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {
     }
     return UnmodifiableMapBase;
   });
   let UnmodifiableMapBase = UnmodifiableMapBase$(dart.dynamic, dart.dynamic);
   let _map = Symbol('_map');
@@ skipping 18 matching lines @@
       get single() {
         return dart.as(this[_map].get(this[_map].keys.single), V);
       }
       get last() {
         return dart.as(this[_map].get(this[_map].keys.last), V);
       }
       get iterator() {
         return new _MapBaseValueIterator(this[_map]);
       }
     }
+    _MapBaseValueIterable[dart.implements] = [_internal.EfficientLength];
     return _MapBaseValueIterable;
   });
   let _MapBaseValueIterable = _MapBaseValueIterable$(dart.dynamic);
   let _keys = Symbol('_keys');
   let _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
         this[_keys] = map.keys.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)];
     return _MapBaseValueIterator;
   });
   let _MapBaseValueIterator = _MapBaseValueIterator$(dart.dynamic);
   let MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
       get(key) {
         return this[_map].get(key);
@@ skipping 34 matching lines @@
       remove(key) {
         return this[_map].remove(key);
       }
       toString() {
         return this[_map].toString();
       }
       get values() {
         return this[_map].values;
       }
     }
+    MapView[dart.implements] = [core.Map$(K, V)];
     return MapView;
   });
   let MapView = MapView$(dart.dynamic, dart.dynamic);
   let UnmodifiableMapView$ = dart.generic(function(K, V) {
     class UnmodifiableMapView extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {
     }
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$(dart.dynamic, dart.dynamic);
   let _id = Symbol('_id');
@@ skipping 100 matching lines @@
   }
   let Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
       Queue() {
         return new ListQueue();
       }
       from(elements) {
         return new ListQueue.from(elements);
       }
     }
+    Queue[dart.implements] = [core.Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(Queue, 'from');
     return Queue;
   });
   let Queue = Queue$(dart.dynamic);
   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) {
@@ skipping 172 matching lines @@
           entry = nextEntry;
         }
       }
       get iterator() {
         return new _DoubleLinkedQueueIterator(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
+    DoubleLinkedQueue[dart.implements] = [Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     return DoubleLinkedQueue;
   });
   let DoubleLinkedQueue = DoubleLinkedQueue$(dart.dynamic);
   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;
       }
       moveNext() {
         if (!dart.notNull(core.identical(this[_nextEntry], this[_sentinel]))) {
           this[_current] = this[_nextEntry][_element];
           this[_nextEntry] = this[_nextEntry][_next];
           return true;
         }
         this[_current] = null;
         this[_nextEntry] = this[_sentinel] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
+    _DoubleLinkedQueueIterator[dart.implements] = [core.Iterator$(E)];
     return _DoubleLinkedQueueIterator;
   });
   let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$(dart.dynamic);
   let _head = Symbol('_head');
   let _tail = Symbol('_tail');
   let _table = Symbol('_table');
   let _INITIAL_CAPACITY = Symbol('_INITIAL_CAPACITY');
   let _isPowerOf2 = Symbol('_isPowerOf2');
   let _nextPowerOf2 = Symbol('_nextPowerOf2');
   let _checkModification = Symbol('_checkModification');
@@ skipping 272 matching lines @@
       [_preGrow](newElementCount) {
         dart.assert(dart.notNull(newElementCount) >= dart.notNull(this.length));
         newElementCount = dart.notNull(newElementCount) >> 1;
         let newCapacity = ListQueue[_nextPowerOf2](newElementCount);
         let newTable = new core.List(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
+    ListQueue[dart.implements] = [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
     ListQueue._INITIAL_CAPACITY = 8;
     return ListQueue;
   });
   let ListQueue = ListQueue$(dart.dynamic);
   let _queue = Symbol('_queue');
   let _end = Symbol('_end');
   let _position = Symbol('_position');
   let _ListQueueIterator$ = dart.generic(function(E) {
     class _ListQueueIterator extends core.Object {
@@ skipping 11 matching lines @@
         this[_queue]._checkModification(this[_modificationCount]);
         if (this[_position] === this[_end]) {
           this[_current] = null;
           return false;
         }
         this[_current] = dart.as(this[_queue][_table].get(this[_position]), E);
         this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table].length) - 1;
         return true;
       }
     }
+    _ListQueueIterator[dart.implements] = [core.Iterator$(E)];
     return _ListQueueIterator;
   });
   let _ListQueueIterator = _ListQueueIterator$(dart.dynamic);
   let _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
@@ skipping 367 matching lines @@
           return this[_root].key;
         let node = this[_root].right;
         if (node === null)
           return null;
         while (node.left !== null) {
           node = node.left;
         }
         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$);
     return SplayTreeMap;
   });
   let SplayTreeMap = SplayTreeMap$(dart.dynamic, dart.dynamic);
   let _workList = Symbol('_workList');
   let _tree = Symbol('_tree');
   let _currentNode = Symbol('_currentNode');
@@ skipping 57 matching lines @@
           return false;
         }
         if (this[_tree][_splayCount] !== this[_splayCount] && dart.notNull(this[_currentNode] !== null)) {
           this[_rebuildWorkList](this[_currentNode]);
         }
         this[_currentNode] = this[_workList].removeLast();
         this[_findLeftMostDescendent](this[_currentNode].right);
         return true;
       }
     }
+    _SplayTreeIterator[dart.implements] = [core.Iterator$(T)];
     dart.defineNamedConstructor(_SplayTreeIterator, 'startAt');
     return _SplayTreeIterator;
   });
   let _SplayTreeIterator = _SplayTreeIterator$(dart.dynamic);
   let _SplayTreeKeyIterable$ = dart.generic(function(K) {
     class _SplayTreeKeyIterable extends IterableBase$(K) {
       _SplayTreeKeyIterable(tree$) {
         this[_tree] = tree$;
         super.IterableBase();
       }
       get length() {
         return this[_tree][_count];
       }
       get isEmpty() {
         return this[_tree][_count] === 0;
       }
       get iterator() {
         return new _SplayTreeKeyIterator(this[_tree]);
       }
       toSet() {
         let setOrMap = this[_tree];
         let set = new SplayTreeSet(dart.as(setOrMap[_comparator], dart.throw_("Unimplemented type (K, K) → int")), dart.as(setOrMap[_validKey], dart.throw_("Unimplemented type (dynamic) → bool")));
         set[_count] = this[_tree][_count];
         set[_root] = set._copyNode(this[_tree][_root]);
         return set;
       }
     }
+    _SplayTreeKeyIterable[dart.implements] = [_internal.EfficientLength];
     return _SplayTreeKeyIterable;
   });
   let _SplayTreeKeyIterable = _SplayTreeKeyIterable$(dart.dynamic);
   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(this[_map]);
       }
     }
+    _SplayTreeValueIterable[dart.implements] = [_internal.EfficientLength];
     return _SplayTreeValueIterable;
   });
   let _SplayTreeValueIterable = _SplayTreeValueIterable$(dart.dynamic, dart.dynamic);
   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 461 matching lines @@
         return -1;
       }
       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)];
     return _HashMap;
   });
   let _HashMap = _HashMap$(dart.dynamic, dart.dynamic);
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
@@ skipping 78 matching lines @@
       forEach(f) {
         let keys = dart.as(dart.dinvoke(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];
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$(dart.dynamic);
   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 10 matching lines @@
         } else if (dart.notNull(offset) >= keys.length) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
+    HashMapKeyIterator[dart.implements] = [core.Iterator$(E)];
     return HashMapKeyIterator;
   });
   let HashMapKeyIterator = HashMapKeyIterator$(dart.dynamic);
   let _modifications = Symbol('_modifications');
   let _value = Symbol('_value');
   let _newLinkedCell = Symbol('_newLinkedCell');
   let _unlinkCell = Symbol('_unlinkCell');
   let _modified = Symbol('_modified');
   let _key = Symbol('_key');
   let _LinkedHashMap$ = dart.generic(function(K, V) {
@@ skipping 253 matching lines @@
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _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];
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$(dart.dynamic, dart.dynamic);
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
@@ skipping 85 matching lines @@
         let modifications = dart.as(dart.dload(this[_map], '_modifications'), core.int);
         while (cell !== null) {
           f(dart.as(cell[_key], E));
           if (modifications !== dart.dload(this[_map], '_modifications')) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
           cell = cell[_next];
         }
       }
     }
+    LinkedHashMapKeyIterable[dart.implements] = [_internal.EfficientLength];
     return LinkedHashMapKeyIterable;
   });
   let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$(dart.dynamic);
   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;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_modifications] !== dart.dload(this[_map], '_modifications')) {
           throw new core.ConcurrentModificationError(this[_map]);
         } else if (this[_cell] === null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
+    LinkedHashMapKeyIterator[dart.implements] = [core.Iterator$(E)];
     return LinkedHashMapKeyIterator;
   });
   let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$(dart.dynamic);
   let _elements = Symbol('_elements');
   let _computeElements = Symbol('_computeElements');
   let _isStringElement = Symbol('_isStringElement');
   let _isNumericElement = Symbol('_isNumericElement');
   let _contains = Symbol('_contains');
   let _lookup = Symbol('_lookup');
   let _HashSet$ = dart.generic(function(E) {
@@ skipping 216 matching lines @@
         return -1;
       }
       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)];
     return _HashSet;
   });
   let _HashSet = _HashSet$(dart.dynamic);
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       [_newSet]() {
         return new _IdentityHashSet();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
@@ skipping 79 matching lines @@
         } else if (dart.notNull(offset) >= elements.length) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(elements[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
+    HashSetIterator[dart.implements] = [core.Iterator$(E)];
     return HashSetIterator;
   });
   let HashSetIterator = HashSetIterator$(dart.dynamic);
   let _unsupported = Symbol('_unsupported');
   let _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
@@ skipping 251 matching lines @@
         return -1;
       }
       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)];
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$(dart.dynamic);
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       [_newSet]() {
         return new _LinkedIdentityHashSet();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
@@ skipping 99 matching lines @@
         } 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)];
     return LinkedHashSetIterator;
   });
   let LinkedHashSetIterator = LinkedHashSetIterator$(dart.dynamic);
   // Exports:
   exports.HashMap = HashMap;
   exports.HashMap$ = HashMap$;
   exports.SetBase = SetBase;
   exports.SetBase$ = SetBase$;
   exports.SetMixin = SetMixin;
   exports.SetMixin$ = SetMixin$;
@@ skipping 48 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 || (collection = {}));