partially implement instance of checks and some codegen fixes

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 17 matching lines @@
   }
   let HashMap$ = dart.generic(function(K, V) {
     class HashMap extends core.Object {
       HashMap(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) {
           if (hashCode == null) {
             if (equals == null) {
-              return new _HashMap();
+              return new (_HashMap$(K, V))();
             }
             hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
-              return new _IdentityHashMap();
+              return new (_IdentityHashMap$(K, V))();
             }
             if (equals == null) {
               equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           }
           if (equals == null) {
             equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
           }
         }
-        return new _CustomHashMap(equals, hashCode, isValidKey);
+        return new (_CustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       identity() {
-        return new _IdentityHashMap();
+        return new (_IdentityHashMap$(K, V))();
       }
       from(other) {
-        let result = new HashMap();
+        let result = new (HashMap$(K, V))();
         other.forEach((k, v) => {
           result.set(k, dart.as(v, V));
         });
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
-        let map = new HashMap();
+        let map = new (HashMap$(K, V))();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values) {
-        let map = new HashMap();
+        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');
     return HashMap;
@@ skipping 69 matching lines @@
           if (other.contains(element))
             result.remove(element);
         }
         return result;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = growable ? ((_) => {
           _.length = this.length;
           return _;
-        }).bind(this)(new core.List()) : new core.List(this.length);
+        }).bind(this)(new (core.List$(E))()) : new (core.List$(E))(this.length);
         let i = 0;
         for (let element of this)
           result.set(((x$) => i = dart.notNull(x$) + 1, x$)(i), element);
         return result;
       }
       map(f) {
-        return new _internal.EfficientLengthMappedIterable(this, f);
+        return new (_internal.EfficientLengthMappedIterable$(E, dynamic))(this, f);
       }
       get single() {
         if (dart.notNull(this.length) > 1)
           throw _internal.IterableElementError.tooMany();
         let it = this.iterator;
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         return result;
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
       where(f) {
-        return new _internal.WhereIterable(this, f);
+        return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
-        return new _internal.ExpandIterable(this, f);
+        return new (_internal.ExpandIterable$(E, dynamic))(this, f);
       }
       forEach(f) {
         for (let element of this)
           f(element);
       }
       reduce(combine) {
         let iterator = this.iterator;
         if (!dart.notNull(iterator.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
@@ skipping 37 matching lines @@
         return buffer.toString();
       }
       any(test) {
         for (let element of this) {
           if (test(element))
             return true;
         }
         return false;
       }
       take(n) {
-        return new _internal.TakeIterable(this, n);
+        return new (_internal.TakeIterable$(E))(this, n);
       }
       takeWhile(test) {
-        return new _internal.TakeWhileIterable(this, test);
+        return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       skip(n) {
-        return new _internal.SkipIterable(this, n);
+        return new (_internal.SkipIterable$(E))(this, n);
       }
       skipWhile(test) {
-        return new _internal.SkipWhileIterable(this, test);
+        return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get first() {
         let it = this.iterator;
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get last() {
         let it = this.iterator;
@@ skipping 104 matching lines @@
   let _HashSetBase = _HashSetBase$(dart.dynamic);
   let HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
       HashSet(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) {
           if (hashCode == null) {
             if (equals == null) {
-              return new _HashSet();
+              return new (_HashSet$(E))();
             }
             hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
-              return new _IdentityHashSet();
+              return new (_IdentityHashSet$(E))();
             }
             if (equals == null) {
               equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           }
           if (equals == null) {
             equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
           }
         }
-        return new _CustomHashSet(equals, hashCode, isValidKey);
+        return new (_CustomHashSet$(E))(equals, hashCode, isValidKey);
       }
       identity() {
-        return new _IdentityHashSet();
+        return new (_IdentityHashSet$(E))();
       }
       from(elements) {
-        let result = new HashSet();
+        let result = new (HashSet$(E))();
         for (let e of dart.as(elements, core.Iterable$(E)))
           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);
+        return new (_internal.MappedIterable$(E, dynamic))(this, f);
       }
       where(f) {
-        return new _internal.WhereIterable(this, f);
+        return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
-        return new _internal.ExpandIterable(this, f);
+        return new (_internal.ExpandIterable$(E, dynamic))(this, f);
       }
       contains(element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       forEach(f) {
         for (let element of this)
@@ skipping 45 matching lines @@
       }
       any(f) {
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return new core.List.from(this, {growable: growable});
+        return new core.List$(E).from(this, {growable: growable});
       }
       toSet() {
-        return new core.Set.from(this);
+        return new core.Set$(E).from(this);
       }
       get length() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
         let it = this.iterator;
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get isEmpty() {
         return !dart.notNull(this.iterator.moveNext());
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       take(n) {
-        return new _internal.TakeIterable(this, n);
+        return new (_internal.TakeIterable$(E))(this, n);
       }
       takeWhile(test) {
-        return new _internal.TakeWhileIterable(this, test);
+        return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       skip(n) {
-        return new _internal.SkipIterable(this, n);
+        return new (_internal.SkipIterable$(E))(this, n);
       }
       skipWhile(test) {
-        return new _internal.SkipWhileIterable(this, test);
+        return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get first() {
         let it = this.iterator;
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get last() {
         let it = this.iterator;
@@ skipping 78 matching lines @@
   });
   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() {
       }
       map(f) {
-        return new _internal.MappedIterable(this, f);
+        return new (_internal.MappedIterable$(E, dynamic))(this, f);
       }
       where(f) {
-        return new _internal.WhereIterable(this, f);
+        return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
-        return new _internal.ExpandIterable(this, f);
+        return new (_internal.ExpandIterable$(E, dynamic))(this, f);
       }
       contains(element) {
         for (let e of this) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       forEach(f) {
         for (let element of this)
@@ skipping 45 matching lines @@
       }
       any(f) {
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return new core.List.from(this, {growable: growable});
+        return new core.List$(E).from(this, {growable: growable});
       }
       toSet() {
-        return new core.Set.from(this);
+        return new core.Set$(E).from(this);
       }
       get length() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
         let it = this.iterator;
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get isEmpty() {
         return !dart.notNull(this.iterator.moveNext());
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       take(n) {
-        return new _internal.TakeIterable(this, n);
+        return new (_internal.TakeIterable$(E))(this, n);
       }
       takeWhile(test) {
-        return new _internal.TakeWhileIterable(this, test);
+        return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       skip(n) {
-        return new _internal.SkipIterable(this, n);
+        return new (_internal.SkipIterable$(E))(this, n);
       }
       skipWhile(test) {
-        return new _internal.SkipWhileIterable(this, test);
+        return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get first() {
         let it = this.iterator;
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get last() {
         let it = this.iterator;
@@ skipping 254 matching lines @@
   let _empty = Symbol('_empty');
   let LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
       LinkedHashMap(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) {
           if (hashCode == null) {
             if (equals == null) {
-              return new _LinkedHashMap();
+              return new (_LinkedHashMap$(K, V))();
             }
             hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
-              return new _LinkedIdentityHashMap();
+              return new (_LinkedIdentityHashMap$(K, V))();
             }
             if (equals == null) {
               equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           }
           if (equals == null) {
             equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
           }
         }
-        return new _LinkedCustomHashMap(equals, hashCode, isValidKey);
+        return new (_LinkedCustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       identity() {
-        return new _LinkedIdentityHashMap();
+        return new (_LinkedIdentityHashMap$(K, V))();
       }
       from(other) {
-        let result = new LinkedHashMap();
+        let result = new (LinkedHashMap$(K, V))();
         other.forEach((k, v) => {
           result.set(k, dart.as(v, V));
         });
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
-        let map = new LinkedHashMap();
+        let map = new (LinkedHashMap$(K, V))();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values) {
-        let map = new LinkedHashMap();
+        let map = new (LinkedHashMap$(K, V))();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       [_literal](keyValuePairs) {
-        return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new _LinkedHashMap()), LinkedHashMap$(K, V));
+        return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new (_LinkedHashMap$(K, V))()), LinkedHashMap$(K, V));
       }
       [_empty]() {
-        return new _LinkedHashMap();
+        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);
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$(dart.dynamic, dart.dynamic);
   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) {
           if (hashCode == null) {
             if (equals == null) {
-              return new _LinkedHashSet();
+              return new (_LinkedHashSet$(E))();
             }
             hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
-              return new _LinkedIdentityHashSet();
+              return new (_LinkedIdentityHashSet$(E))();
             }
             if (equals == null) {
               equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           }
           if (equals == null) {
             equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
           }
         }
-        return new _LinkedCustomHashSet(equals, hashCode, isValidKey);
+        return new (_LinkedCustomHashSet$(E))(equals, hashCode, isValidKey);
       }
       identity() {
-        return new _LinkedIdentityHashSet();
+        return new (_LinkedIdentityHashSet$(E))();
       }
       from(elements) {
-        let result = new LinkedHashSet();
+        let result = new (LinkedHashSet$(E))();
         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;
@@ skipping 25 matching lines @@
       addAll(entries) {
         entries.forEach(dart.closureWrap(((entry) => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this), "(E) → void"));
       }
       remove(entry) {
         if (!dart.equals(entry[_list], this))
           return false;
         this[_unlink](entry);
         return true;
       }
       get iterator() {
-        return new _LinkedListIterator(this);
+        return new (_LinkedListIterator$(E))(this);
       }
       get length() {
         return this[_length];
       }
       clear() {
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         let next = this[_next];
         while (!dart.notNull(core.identical(next, this))) {
           let entry = dart.as(next, E);
           next = entry[_next];
@@ skipping 130 matching lines @@
       }
     }
     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);
+        return new (_internal.ListIterator$(E))(this);
       }
       elementAt(index) {
         return this.get(index);
       }
       forEach(action) {
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           action(this.get(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
@@ skipping 110 matching lines @@
       join(separator) {
         if (separator === void 0)
           separator = "";
         if (this.length == 0)
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return buffer.toString();
       }
       where(test) {
-        return new _internal.WhereIterable(this, test);
+        return new (_internal.WhereIterable$(E))(this, test);
       }
       map(f) {
         return new _internal.MappedListIterable(this, f);
       }
       expand(f) {
-        return new _internal.ExpandIterable(this, f);
+        return new (_internal.ExpandIterable$(E, dynamic))(this, f);
       }
       reduce(combine) {
         let length = this.length;
         if (length == 0)
           throw _internal.IterableElementError.noElement();
         let value = this.get(0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = combine(value, this.get(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = dart.dinvokef(combine, value, this.get(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       skip(count) {
-        return new _internal.SubListIterable(this, count, null);
+        return new (_internal.SubListIterable$(E))(this, count, null);
       }
       skipWhile(test) {
-        return new _internal.SkipWhileIterable(this, test);
+        return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       take(count) {
-        return new _internal.SubListIterable(this, 0, count);
+        return new (_internal.SubListIterable$(E))(this, 0, count);
       }
       takeWhile(test) {
-        return new _internal.TakeWhileIterable(this, test);
+        return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
           result = ((_) => {
             _.length = this.length;
             return _;
-          }).bind(this)(new core.List());
+          }).bind(this)(new (core.List$(E))());
         } else {
-          result = new core.List(this.length);
+          result = new (core.List$(E))(this.length);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result.set(i, this.get(i));
         }
         return result;
       }
       toSet() {
-        let result = new core.Set();
+        let result = new (core.Set$(E))();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result.add(this.get(i));
         }
         return result;
       }
       add(element) {
         this.set(((x$) => this.length = dart.notNull(x$) + 1, x$).bind(this)(this.length), element);
       }
       addAll(iterable) {
         for (let element of iterable) {
@@ skipping 61 matching lines @@
         let length = this.length;
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
           length = 1;
           let tmp = this.get(length);
           this.set(length, this.get(pos));
           this.set(pos, tmp);
         }
       }
       asMap() {
-        return new _internal.ListMapView(this);
+        return new (_internal.ListMapView$(E))(this);
       }
       sublist(start, end) {
         if (end === void 0)
           end = null;
         let listLength = this.length;
         if (end == null)
           end = listLength;
         core.RangeError.checkValidRange(start, end, listLength);
         let length = dart.notNull(end) - dart.notNull(start);
-        let result = new core.List();
+        let result = new (core.List$(E))();
         result.length = length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result.set(i, this.get(dart.notNull(start) + dart.notNull(i)));
         }
         return result;
       }
       getRange(start, end) {
         core.RangeError.checkValidRange(start, end, this.length);
-        return new _internal.SubListIterable(this, start, end);
+        return new (_internal.SubListIterable$(E))(this, start, end);
       }
       removeRange(start, end) {
         core.RangeError.checkValidRange(start, end, this.length);
         let length = dart.notNull(end) - dart.notNull(start);
         this.setRange(start, dart.notNull(this.length) - dart.notNull(length), this, end);
         this.length = length;
       }
       fillRange(start, end, fill) {
         if (fill === void 0)
           fill = null;
@@ skipping 124 matching lines @@
       setAll(index, iterable) {
         if (dart.is(iterable, core.List)) {
           this.setRange(index, dart.notNull(index) + dart.notNull(iterable.length), iterable);
         } else {
           for (let element of iterable) {
             this.set(((x$) => index = dart.notNull(x$) + 1, x$)(index), element);
           }
         }
       }
       get reversed() {
-        return new _internal.ReversedListIterable(this);
+        return new (_internal.ReversedListIterable$(E))(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) {
@@ skipping 36 matching lines @@
       get length() {
         return this.keys.length;
       }
       get isEmpty() {
         return this.keys.isEmpty;
       }
       get isNotEmpty() {
         return this.keys.isNotEmpty;
       }
       get values() {
-        return new _MapBaseValueIterable(this);
+        return new (_MapBaseValueIterable$(V))(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) {
@@ skipping 49 matching lines @@
       get first() {
         return dart.as(this[_map].get(this[_map].keys.first), V);
       }
       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]);
+        return new (_MapBaseValueIterator$(V))(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) {
@@ skipping 176 matching lines @@
         hasNextValue = valueIterator.moveNext();
       }
       if (dart.notNull(hasNextKey) || dart.notNull(hasNextValue)) {
         throw new core.ArgumentError("Iterables do not have same length.");
       }
     }
   }
   let Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
       Queue() {
-        return new ListQueue();
+        return new (ListQueue$(E))();
       }
       from(elements) {
-        return new ListQueue.from(elements);
+        return new ListQueue$(E).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) {
         this[_element] = e;
         this[_previous] = null;
         this[_next] = null;
       }
       [_link](previous, next) {
         this[_next] = next;
         this[_previous] = previous;
         previous[_next] = this;
         next[_previous] = this;
       }
       append(e) {
-        new DoubleLinkedQueueEntry(e)._link(this, this[_next]);
+        new (DoubleLinkedQueueEntry$(E))(e)._link(this, this[_next]);
       }
       prepend(e) {
-        new DoubleLinkedQueueEntry(e)._link(this[_previous], this);
+        new (DoubleLinkedQueueEntry$(E))(e)._link(this[_previous], this);
       }
       remove() {
         this[_previous][_next] = this[_next];
         this[_next][_previous] = this[_previous];
         this[_next] = null;
         this[_previous] = null;
         return this[_element];
       }
       [_asNonSentinelEntry]() {
         return this;
@@ skipping 37 matching lines @@
   });
   let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$(dart.dynamic);
   let _sentinel = Symbol('_sentinel');
   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();
+        this[_sentinel] = new (_DoubleLinkedQueueEntrySentinel$(E))();
       }
       from(elements) {
         let list = dart.as(new DoubleLinkedQueue(), Queue$(E));
         for (let e of dart.as(elements, core.Iterable$(E))) {
           list.addLast(e);
         }
         return dart.as(list, DoubleLinkedQueue$(E));
       }
       get length() {
         return this[_elementCount];
@@ skipping 83 matching lines @@
       }
       forEachEntry(f) {
         let entry = this[_sentinel][_next];
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           let nextEntry = entry[_next];
           f(entry);
           entry = nextEntry;
         }
       }
       get iterator() {
-        return new _DoubleLinkedQueueIterator(this[_sentinel]);
+        return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     return DoubleLinkedQueue;
   });
   let DoubleLinkedQueue = DoubleLinkedQueue$(dart.dynamic);
@@ skipping 45 matching lines @@
         this[_tail] = 0;
         this[_table] = null;
         this[_modificationCount] = 0;
         super.IterableBase();
         if (initialCapacity == null || dart.notNull(initialCapacity) < dart.notNull(ListQueue[_INITIAL_CAPACITY])) {
           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);
+        this[_table] = new (core.List$(E))(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));
           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;
           }
-          let result = new ListQueue(capacity);
+          let result = new (ListQueue$(E))(capacity);
           for (let element of dart.as(elements, core.Iterable$(E))) {
             result.addLast(element);
           }
           return result;
         }
       }
       get iterator() {
-        return new _ListQueueIterator(this);
+        return new (_ListQueueIterator$(E))(this);
       }
       forEach(action) {
         let modificationCount = this[_modificationCount];
         for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table].length) - 1) {
           action(this[_table].get(i));
           this[_checkModification](modificationCount);
         }
       }
       get isEmpty() {
         return this[_head] == this[_tail];
@@ skipping 22 matching lines @@
         core.RangeError.checkValidIndex(index, this);
         return this[_table].get(dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table].length) - 1);
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = null;
         if (growable) {
           list = ((_) => {
             _.length = this.length;
             return _;
-          }).bind(this)(new core.List());
+          }).bind(this)(new (core.List$(E))());
         } else {
-          list = new core.List(this.length);
+          list = new (core.List$(E))(this.length);
         }
         this[_writeToList](list);
         return list;
       }
       add(element) {
         this[_add](element);
       }
       addAll(elements) {
         if (dart.is(elements, core.List)) {
           let list = dart.as(elements, core.List);
@@ skipping 139 matching lines @@
           while (i != this[_tail]) {
             let nextOffset = dart.notNull(i) + 1 & dart.notNull(mask);
             this[_table].set(i, this[_table].get(nextOffset));
             i = nextOffset;
           }
           this[_table].set(this[_tail], null);
           return offset;
         }
       }
       [_grow]() {
-        let newTable = new core.List(dart.notNull(this[_table].length) * 2);
+        let newTable = new (core.List$(E))(dart.notNull(this[_table].length) * 2);
         let split = dart.notNull(this[_table].length) - dart.notNull(this[_head]);
         newTable.setRange(0, split, this[_table], this[_head]);
         newTable.setRange(split, dart.notNull(split) + dart.notNull(this[_head]), this[_table], 0);
         this[_head] = 0;
         this[_tail] = this[_table].length;
         this[_table] = newTable;
       }
       [_writeToList](target) {
         dart.assert(dart.notNull(target.length) >= dart.notNull(this.length));
         if (dart.notNull(this[_head]) <= dart.notNull(this[_tail])) {
           let length = dart.notNull(this[_tail]) - dart.notNull(this[_head]);
           target.setRange(0, length, this[_table], this[_head]);
           return length;
         } else {
           let firstPartSize = dart.notNull(this[_table].length) - dart.notNull(this[_head]);
           target.setRange(0, firstPartSize, this[_table], this[_head]);
           target.setRange(firstPartSize, dart.notNull(firstPartSize) + dart.notNull(this[_tail]), this[_table], 0);
           return dart.notNull(this[_tail]) + dart.notNull(firstPartSize);
         }
       }
       [_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);
+        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');
     ListQueue._INITIAL_CAPACITY = 8;
     return ListQueue;
   });
@@ skipping 57 matching lines @@
   let _compare = Symbol('_compare');
   let _splayMin = Symbol('_splayMin');
   let _splayMax = Symbol('_splayMax');
   let _addNewRoot = Symbol('_addNewRoot');
   let _first = Symbol('_first');
   let _last = Symbol('_last');
   let _clear = Symbol('_clear');
   let _SplayTree$ = dart.generic(function(K) {
     class _SplayTree extends core.Object {
       _SplayTree() {
-        this[_dummy] = new _SplayTreeNode(null);
+        this[_dummy] = new (_SplayTreeNode$(K))(null);
         this[_root] = null;
         this[_count] = 0;
         this[_modificationCount] = 0;
         this[_splayCount] = 0;
       }
       [_splay](key) {
         if (this[_root] == null)
           return -1;
         let left = this[_dummy];
         let right = this[_dummy];
@@ skipping 143 matching lines @@
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator);
         this[_validKey] = dart.as(isValidKey != null ? isValidKey : (v) => dart.is(v, K), _Predicate);
         super._SplayTree();
       }
       from(other, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
-        let result = new SplayTreeMap();
+        let result = new (SplayTreeMap$(K, V))();
         other.forEach((k, v) => {
           result.set(k, dart.as(v, V));
         });
         return result;
       }
       fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let compare = opts && 'compare' in opts ? opts.compare : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
-        let map = new SplayTreeMap(compare, isValidKey);
+        let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
       fromIterables(keys, values, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
-        let map = new SplayTreeMap(compare, isValidKey);
+        let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       [_compare](key1, key2) {
         return this[_comparator](key1, key2);
       }
       [_internal$]() {
         this[_comparator] = null;
         this[_validKey] = null;
         super._SplayTree();
@@ skipping 57 matching lines @@
           this.set(key, value);
         }).bind(this));
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       forEach(f) {
-        let nodes = new _SplayTreeNodeIterator(this);
+        let nodes = new (_SplayTreeNodeIterator$(K))(this);
         while (nodes.moveNext()) {
           let node = dart.as(nodes.current, _SplayTreeMapNode$(K, V));
           f(node.key, node.value);
         }
       }
       get length() {
         return this[_count];
       }
       clear() {
         this[_clear]();
@@ skipping 14 matching lines @@
             }
             if (dart.notNull(node.right != null) && dart.notNull(visit(dart.as(node.right, _SplayTreeMapNode))))
               return true;
             node = dart.as(node.left, _SplayTreeMapNode);
           }
           return false;
         }
         return visit(dart.as(this[_root], _SplayTreeMapNode));
       }
       get keys() {
-        return new _SplayTreeKeyIterable(this);
+        return new (_SplayTreeKeyIterable$(K))(this);
       }
       get values() {
-        return new _SplayTreeValueIterable(this);
+        return new (_SplayTreeValueIterable$(K, V))(this);
       }
       toString() {
         return Maps.mapToString(this);
       }
       firstKey() {
         if (this[_root] == null)
           return null;
         return dart.as(this[_first].key, K);
       }
       lastKey() {
@@ skipping 123 matching lines @@
         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]);
+        return new (_SplayTreeKeyIterator$(K))(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")));
+        let set = new (SplayTreeSet$(K))(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]);
+        return new (_SplayTreeValueIterator$(K, V))(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);
@@ skipping 44 matching lines @@
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator);
         this[_validKey] = dart.as(isValidKey != null ? isValidKey : (v) => dart.is(v, E), _Predicate);
         super._SplayTree();
       }
       from(elements, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
-        let result = new SplayTreeSet(compare, isValidKey);
+        let result = new (SplayTreeSet$(E))(compare, isValidKey);
         for (let element of dart.as(elements, core.Iterable$(E))) {
           result.add(element);
         }
         return result;
       }
       [_compare](e1, e2) {
         return dart.dinvokef(this[_comparator], e1, e2);
       }
       get iterator() {
-        return new _SplayTreeKeyIterator(this);
+        return new (_SplayTreeKeyIterator$(E))(this);
       }
       get length() {
         return this[_count];
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return this[_root] != null;
       }
@@ skipping 37 matching lines @@
           }
         }
       }
       removeAll(elements) {
         for (let element of elements) {
           if (dart.dinvokef(this[_validKey], element))
             this[_remove](dart.as(element, E));
         }
       }
       retainAll(elements) {
-        let retainSet = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
+        let retainSet = new (SplayTreeSet$(E))(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         let modificationCount = this[_modificationCount];
         for (let object of elements) {
           if (modificationCount != this[_modificationCount]) {
             throw new core.ConcurrentModificationError(this);
           }
           if (dart.notNull(dart.dinvokef(this[_validKey], object)) && this[_splay](dart.as(object, E)) == 0)
             retainSet.add(this[_root].key);
         }
         if (retainSet[_count] != this[_count]) {
           this[_root] = retainSet[_root];
           this[_count] = retainSet[_count];
           this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         }
       }
       lookup(object) {
         if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return null;
         let comp = this[_splay](dart.as(object, E));
         if (comp != 0)
           return null;
         return this[_root].key;
       }
       intersection(other) {
-        let result = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
+        let result = new (SplayTreeSet$(E))(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         for (let element of this) {
           if (other.contains(element))
             result.add(element);
         }
         return result;
       }
       difference(other) {
-        let result = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
+        let result = new (SplayTreeSet$(E))(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         for (let element of this) {
           if (!dart.notNull(other.contains(element)))
             result.add(element);
         }
         return result;
       }
       union(other) {
         return ((_) => {
           _.addAll(other);
           return _;
         }).bind(this)(this[_clone]());
       }
       [_clone]() {
-        let set = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
+        let set = new (SplayTreeSet$(E))(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         set[_count] = this[_count];
         set[_root] = this[_copyNode](this[_root]);
         return set;
       }
       [_copyNode](node) {
         if (node == null)
           return null;
         return ((_) => {
           _.left = this[_copyNode](node.left);
           _.right = this[_copyNode](node.right);
           return _;
-        }).bind(this)(new _SplayTreeNode(node.key));
+        }).bind(this)(new (_SplayTreeNode$(E))(node.key));
       }
       clear() {
         this[_clear]();
       }
       toSet() {
         return this[_clone]();
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
@@ skipping 33 matching lines @@
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
-        return new HashMapKeyIterable(this);
+        return new (HashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
         if (_HashMap[_isStringKey](key)) {
           let strings = this[_strings];
           return strings == null ? false : _HashMap[_hasTableEntry](strings, key);
         } else if (_HashMap[_isNumericKey](key)) {
           let nums = this[_nums];
           return nums == null ? false : _HashMap[_hasTableEntry](nums, key);
         } else {
           return this[_containsKey](key);
@@ skipping 300 matching lines @@
         this[_map] = map$;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], '_length'), core.int);
       }
       get isEmpty() {
         return dart.equals(dart.dload(this[_map], '_length'), 0);
       }
       get iterator() {
-        return new HashMapKeyIterator(this[_map], dart.as(dart.dinvoke(this[_map], '_computeKeys'), core.List));
+        return new (HashMapKeyIterator$(E))(this[_map], dart.as(dart.dinvoke(this[_map], '_computeKeys'), core.List));
       }
       contains(element) {
         return dart.as(dart.dinvoke(this[_map], 'containsKey', element), core.bool);
       }
       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]);
@@ skipping 56 matching lines @@
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
-        return new LinkedHashMapKeyIterable(this);
+        return new (LinkedHashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
+        return new (_internal.MappedIterable$(K, V))(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
         if (_LinkedHashMap[_isStringKey](key)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
           let cell = dart.as(_LinkedHashMap[_getTableEntry](strings, key), LinkedHashMapCell);
           return cell != null;
         } else if (_LinkedHashMap[_isNumericKey](key)) {
           let nums = this[_nums];
@@ skipping 308 matching lines @@
         this[_map] = map$;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], '_length'), core.int);
       }
       get isEmpty() {
         return dart.equals(dart.dload(this[_map], '_length'), 0);
       }
       get iterator() {
-        return new LinkedHashMapKeyIterator(this[_map], dart.as(dart.dload(this[_map], '_modifications'), core.int));
+        return new (LinkedHashMapKeyIterator$(E))(this[_map], dart.as(dart.dload(this[_map], '_modifications'), core.int));
       }
       contains(element) {
         return dart.as(dart.dinvoke(this[_map], 'containsKey', element), core.bool);
       }
       forEach(f) {
         let cell = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
         let modifications = dart.as(dart.dload(this[_map], '_modifications'), core.int);
         while (cell != null) {
           f(dart.as(cell[_key], E));
           if (!dart.equals(modifications, dart.dload(this[_map], '_modifications'))) {
@@ skipping 47 matching lines @@
     class _HashSet extends _HashSetBase$(E) {
       _HashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_elements] = null;
         super._HashSetBase();
       }
       [_newSet]() {
-        return new _HashSet();
+        return new (_HashSet$(E))();
       }
       get iterator() {
-        return new HashSetIterator(this, this[_computeElements]());
+        return new (HashSetIterator$(E))(this, this[_computeElements]());
       }
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
@@ skipping 199 matching lines @@
         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();
+        return new (_IdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (core.identical(bucket[i], element))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashSet;
   });
   let _IdentityHashSet = _IdentityHashSet$(dart.dynamic);
   let _equality = Symbol('_equality');
   let _hasher = Symbol('_hasher');
   let _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = dart.as(validKey != null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._HashSet();
       }
       [_newSet]() {
-        return new _CustomHashSet(this[_equality], this[_hasher], this[_validKey]);
+        return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (this[_equality](dart.as(bucket[i], E), dart.as(element, E)))
             return i;
         }
         return -1;
@@ skipping 60 matching lines @@
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_first] = null;
         this[_last] = null;
         this[_modifications] = 0;
         super._HashSetBase();
       }
       [_newSet]() {
-        return new _LinkedHashSet();
+        return new (_LinkedHashSet$(E))();
       }
       [_unsupported](operation) {
         throw `LinkedHashSet: unsupported ${operation}`;
       }
       get iterator() {
         return dart.as(new LinkedHashSetIterator(this, this[_modifications]), core.Iterator$(E));
       }
       get length() {
         return this[_length];
       }
@@ skipping 240 matching lines @@
         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();
+        return new (_LinkedIdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (core.identical(cell[_element], element))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$(dart.dynamic);
   let _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = dart.as(validKey != null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._LinkedHashSet();
       }
       [_newSet]() {
-        return new _LinkedCustomHashSet(this[_equality], this[_hasher], this[_validKey]);
+        return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (this[_equality](dart.as(cell[_element], E), dart.as(element, E)))
             return i;
         }
@@ skipping 132 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 = {}));