emit interfaces before use

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 1095 matching lines @@
     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');
   let _list = Symbol('_list');
   let _unlink = Symbol('_unlink');
+  class _LinkedListLink extends core.Object {
+    _LinkedListLink() {
+      this[_next] = null;
+      this[_previous] = null;
+    }
+  }
   let LinkedList$ = dart.generic(function(E) {
     class LinkedList extends IterableBase$(E) {
       LinkedList() {
         this[_modificationCount] = 0;
         this[_length] = 0;
         this[_next] = null;
         this[_previous] = null;
         super.IterableBase();
         this[_next] = this[_previous] = this;
       }
@@ skipping 112 matching lines @@
         }
         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) {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
         this[_next] = null;
         this[_previous] = null;
       }
       get list() {
         return this[_list];
       }
@@ skipping 525 matching lines @@
       }
       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)) {
-    }
+    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)) {
-    }
+    class UnmodifiableMapBase extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapBase;
   });
   let UnmodifiableMapBase = UnmodifiableMapBase$(dart.dynamic, dart.dynamic);
   let _map = Symbol('_map');
   let _MapBaseValueIterable$ = dart.generic(function(V) {
     class _MapBaseValueIterable extends IterableBase$(V) {
       _MapBaseValueIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
@@ skipping 15 matching lines @@
       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);
+  dart.defineLazyClassGeneric(exports, '_MapBaseValueIterable', {get: _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.iterator;
         this[_current] = null;
       }
       moveNext() {
         if (this[_keys].moveNext()) {
@@ skipping 60 matching lines @@
       }
       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)) {
-    }
+    class UnmodifiableMapView extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {}
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$(dart.dynamic, dart.dynamic);
   let _id = Symbol('_id');
   let _fillMapWithMappedIterable = Symbol('_fillMapWithMappedIterable');
   let _fillMapWithIterables = Symbol('_fillMapWithIterables');
   class Maps extends core.Object {
     static containsValue(map, value) {
       for (let v of map.values) {
         if (dart.equals(value, v)) {
@@ skipping 98 matching lines @@
         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);
+  dart.defineLazyClassGeneric(exports, 'Queue', {get: 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;
         this[_previous] = null;
         this[_next] = null;
       }
@@ skipping 61 matching lines @@
   let _elementCount = Symbol('_elementCount');
   let DoubleLinkedQueue$ = dart.generic(function(E) {
     class DoubleLinkedQueue extends IterableBase$(E) {
       DoubleLinkedQueue() {
         this[_sentinel] = null;
         this[_elementCount] = 0;
         super.IterableBase();
         this[_sentinel] = new _DoubleLinkedQueueEntrySentinel();
       }
       from(elements) {
-        let list = dart.as(new DoubleLinkedQueue(), Queue$(E));
+        let list = dart.as(new DoubleLinkedQueue(), exports.Queue$(E));
         for (let e of dart.as(elements, core.Iterable$(E))) {
           list.addLast(e);
         }
-        return dart.as(list, DoubleLinkedQueue$(E));
+        return dart.as(list, exports.DoubleLinkedQueue$(E));
       }
       get length() {
         return this[_elementCount];
       }
       addLast(value) {
         this[_sentinel].prepend(value);
         this[_elementCount] = dart.notNull(this[_elementCount]) + 1;
       }
       addFirst(value) {
         this[_sentinel].append(value);
@@ skipping 82 matching lines @@
           entry = nextEntry;
         }
       }
       get iterator() {
         return new _DoubleLinkedQueueIterator(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
-    DoubleLinkedQueue[dart.implements] = [Queue$(E)];
+    DoubleLinkedQueue[dart.implements] = [exports.Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     return DoubleLinkedQueue;
   });
-  let DoubleLinkedQueue = DoubleLinkedQueue$(dart.dynamic);
+  dart.defineLazyClassGeneric(exports, 'DoubleLinkedQueue', {get: 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;
       }
       moveNext() {
         if (!dart.notNull(core.identical(this[_nextEntry], this[_sentinel]))) {
@@ skipping 40 matching lines @@
           initialCapacity = ListQueue[_INITIAL_CAPACITY];
         } else if (!dart.notNull(ListQueue[_isPowerOf2](initialCapacity))) {
           initialCapacity = ListQueue[_nextPowerOf2](initialCapacity);
         }
         dart.assert(ListQueue[_isPowerOf2](initialCapacity));
         this[_table] = new core.List(initialCapacity);
       }
       from(elements) {
         if (dart.is(elements, core.List)) {
           let length = elements.length;
-          let queue = dart.as(new ListQueue(dart.notNull(length) + 1), ListQueue$(E));
+          let queue = dart.as(new ListQueue(dart.notNull(length) + 1), exports.ListQueue$(E));
           dart.assert(dart.notNull(queue[_table].length) > dart.notNull(length));
           let sourceList = elements;
           queue[_table].setRange(0, length, dart.as(sourceList, core.Iterable$(E)), 0);
           queue[_tail] = length;
           return queue;
         } else {
           let capacity = ListQueue[_INITIAL_CAPACITY];
           if (dart.is(elements, _internal.EfficientLength)) {
             capacity = elements.length;
           }
@@ skipping 234 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)];
+    ListQueue[dart.implements] = [exports.Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
     ListQueue._INITIAL_CAPACITY = 8;
     return ListQueue;
   });
-  let ListQueue = ListQueue$(dart.dynamic);
+  dart.defineLazyClassGeneric(exports, 'ListQueue', {get: ListQueue$});
   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) {
         this[_queue] = queue;
         this[_end] = queue[_tail];
         this[_modificationCount] = queue[_modificationCount];
         this[_position] = queue[_head];
@@ skipping 503 matching lines @@
         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);
+  dart.defineLazyClassGeneric(exports, '_SplayTreeKeyIterable', {get: _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(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = [_internal.EfficientLength];
     return _SplayTreeValueIterable;
   });
-  let _SplayTreeValueIterable = _SplayTreeValueIterable$(dart.dynamic, dart.dynamic);
+  dart.defineLazyClassGeneric(exports, '_SplayTreeValueIterable', {get: _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);
       }
     }
     return _SplayTreeKeyIterator;
@@ skipping 560 matching lines @@
           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);
+  dart.defineLazyClassGeneric(exports, 'HashMapKeyIterable', {get: 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;
         this[_current] = null;
       }
       get current() {
@@ skipping 284 matching lines @@
         _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);
+  dart.defineLazyClassGeneric(exports, '_LinkedHashMap', {get: _LinkedHashMap$});
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
-    class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
+    class _LinkedIdentityHashMap extends exports._LinkedHashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         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 (core.identical(cell[_key], key))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashMap;
   });
-  let _LinkedIdentityHashMap = _LinkedIdentityHashMap$(dart.dynamic, dart.dynamic);
+  dart.defineLazyClassGeneric(exports, '_LinkedIdentityHashMap', {get: _LinkedIdentityHashMap$});
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
-    class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
+    class _LinkedCustomHashMap extends exports._LinkedHashMap$(K, V) {
       _LinkedCustomHashMap(equals$, hashCode$, validKey) {
         this[_equals] = equals$;
         this[_hashCode] = hashCode$;
         this[_validKey] = dart.as(validKey != null ? validKey : (v) => dart.is(v, K), _Predicate);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         return super._get(key);
@@ skipping 21 matching lines @@
         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;
       }
     }
     return _LinkedCustomHashMap;
   });
-  let _LinkedCustomHashMap = _LinkedCustomHashMap$(dart.dynamic, dart.dynamic);
+  dart.defineLazyClassGeneric(exports, '_LinkedCustomHashMap', {get: _LinkedCustomHashMap$});
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key$, value$) {
       this[_key] = key$;
       this[_value] = value$;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
@@ skipping 21 matching lines @@
           if (!dart.equals(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);
+  dart.defineLazyClassGeneric(exports, 'LinkedHashMapKeyIterable', {get: 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;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
       }
@@ skipping 777 matching lines @@
   exports.MapBase$ = MapBase$;
   exports.MapMixin = MapMixin;
   exports.MapMixin$ = MapMixin$;
   exports.UnmodifiableMapBase = UnmodifiableMapBase;
   exports.UnmodifiableMapBase$ = UnmodifiableMapBase$;
   exports.MapView = MapView;
   exports.MapView$ = MapView$;
   exports.UnmodifiableMapView = UnmodifiableMapView;
   exports.UnmodifiableMapView$ = UnmodifiableMapView$;
   exports.Maps = Maps;
-  exports.Queue = Queue;
-  exports.Queue$ = Queue$;
   exports.DoubleLinkedQueueEntry = DoubleLinkedQueueEntry;
   exports.DoubleLinkedQueueEntry$ = DoubleLinkedQueueEntry$;
-  exports.DoubleLinkedQueue = DoubleLinkedQueue;
-  exports.DoubleLinkedQueue$ = DoubleLinkedQueue$;
-  exports.ListQueue = ListQueue;
-  exports.ListQueue$ = ListQueue$;
   exports.SplayTreeMap = SplayTreeMap;
   exports.SplayTreeMap$ = SplayTreeMap$;
   exports.SplayTreeSet = SplayTreeSet;
   exports.SplayTreeSet$ = SplayTreeSet$;
-  exports.HashMapKeyIterable = HashMapKeyIterable;
-  exports.HashMapKeyIterable$ = HashMapKeyIterable$;
   exports.HashMapKeyIterator = HashMapKeyIterator;
   exports.HashMapKeyIterator$ = HashMapKeyIterator$;
   exports.LinkedHashMapCell = LinkedHashMapCell;
-  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 = {}));