partially implement instance of checks and some codegen fixes

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {
   }
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get iterator() {
-        return new ListIterator(this);
+        return new (ListIterator$(E))(this);
       }
       forEach(action) {
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           action(this.elementAt(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
@@ skipping 156 matching lines @@
         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.elementAt(i));
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       skip(count) {
-        return new SubListIterable(this, count, null);
+        return new (SubListIterable$(E))(this, count, null);
       }
       skipWhile(test) {
         return super.skipWhile(test);
       }
       take(count) {
-        return new SubListIterable(this, 0, count);
+        return new (SubListIterable$(E))(this, 0, count);
       }
       takeWhile(test) {
         return super.takeWhile(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.elementAt(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.elementAt(i));
         }
         return result;
       }
     }
     ListIterable[dart.implements] = () => [EfficientLength];
     return ListIterable;
   });
   let ListIterable = ListIterable$(dart.dynamic);
-  let _iterable = Symbol('_iterable');
-  let _start = Symbol('_start');
-  let _endOrLength = Symbol('_endOrLength');
-  let _endIndex = Symbol('_endIndex');
-  let _startIndex = Symbol('_startIndex');
+  let _iterable = dart.JsSymbol('_iterable');
+  let _start = dart.JsSymbol('_start');
+  let _endOrLength = dart.JsSymbol('_endOrLength');
+  let _endIndex = dart.JsSymbol('_endIndex');
+  let _startIndex = dart.JsSymbol('_startIndex');
   let SubListIterable$ = dart.generic(function(E) {
     class SubListIterable extends ListIterable$(E) {
       SubListIterable(iterable$, start$, endOrLength) {
         this[_iterable] = iterable$;
         this[_start] = start$;
         this[_endOrLength] = endOrLength;
         super.ListIterable();
         core.RangeError.checkNotNegative(this[_start], "start");
         if (this[_endOrLength] != null) {
           core.RangeError.checkNotNegative(this[_endOrLength], "end");
@@ skipping 27 matching lines @@
         let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
         if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(this[_endIndex])) {
           throw new core.RangeError.index(index, this, "index");
         }
         return this[_iterable].elementAt(realIndex);
       }
       skip(count) {
         core.RangeError.checkNotNegative(count, "count");
         let newStart = dart.notNull(this[_start]) + dart.notNull(count);
         if (this[_endOrLength] != null && dart.notNull(newStart) >= dart.notNull(this[_endOrLength])) {
-          return new EmptyIterable();
+          return new (EmptyIterable$(E))();
         }
-        return new SubListIterable(this[_iterable], newStart, this[_endOrLength]);
+        return new (SubListIterable$(E))(this[_iterable], newStart, this[_endOrLength]);
       }
       take(count) {
         core.RangeError.checkNotNegative(count, "count");
         if (this[_endOrLength] == null) {
-          return new SubListIterable(this[_iterable], this[_start], dart.notNull(this[_start]) + dart.notNull(count));
+          return new (SubListIterable$(E))(this[_iterable], this[_start], dart.notNull(this[_start]) + dart.notNull(count));
         } else {
           let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
           if (dart.notNull(this[_endOrLength]) < dart.notNull(newEnd))
             return this;
-          return new SubListIterable(this[_iterable], this[_start], newEnd);
+          return new (SubListIterable$(E))(this[_iterable], this[_start], newEnd);
         }
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let start = this[_start];
         let end = this[_iterable].length;
         if (this[_endOrLength] != null && dart.notNull(this[_endOrLength]) < dart.notNull(end))
           end = this[_endOrLength];
         let length = dart.notNull(end) - dart.notNull(start);
         if (dart.notNull(length) < 0)
           length = 0;
         let result = growable ? ((_) => {
           _.length = length;
           return _;
-        }).bind(this)(new core.List()) : new core.List(length);
+        }).bind(this)(new (core.List$(E))()) : new (core.List$(E))(length);
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result.set(i, this[_iterable].elementAt(dart.notNull(start) + dart.notNull(i)));
           if (dart.notNull(this[_iterable].length) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$(dart.dynamic);
-  let _length = Symbol('_length');
-  let _index = Symbol('_index');
-  let _current = Symbol('_current');
+  let _length = dart.JsSymbol('_length');
+  let _index = dart.JsSymbol('_index');
+  let _current = dart.JsSymbol('_current');
   let ListIterator$ = dart.generic(function(E) {
     class ListIterator extends core.Object {
       ListIterator(iterable) {
         this[_iterable] = iterable;
         this[_length] = iterable.length;
         this[_index] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let length = this[_iterable].length;
         if (this[_length] != length) {
           throw new core.ConcurrentModificationError(this[_iterable]);
         }
         if (dart.notNull(this[_index]) >= dart.notNull(length)) {
           this[_current] = null;
           return false;
         }
         this[_current] = this[_iterable].elementAt(this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     return ListIterator;
   });
   let ListIterator = ListIterator$(dart.dynamic);
-  let _ = Symbol('_');
-  let _f = Symbol('_f');
+  let _ = dart.JsSymbol('_');
+  let _f = dart.JsSymbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
-          return new EfficientLengthMappedIterable(iterable, func);
+          return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
         }
-        return new MappedIterable[_](dart.as(iterable, core.Iterable$(S)), func);
+        return new MappedIterable$(S, T)[_](dart.as(iterable, core.Iterable$(S)), func);
       }
       [_](iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
-        return new MappedIterator(this[_iterable].iterator, this[_f]);
+        return new (MappedIterator$(S, T))(this[_iterable].iterator, this[_f]);
       }
       get length() {
         return this[_iterable].length;
       }
       get isEmpty() {
         return this[_iterable].isEmpty;
       }
       get first() {
         return this[_f](this[_iterable].first);
       }
@@ skipping 14 matching lines @@
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         super[_](dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthMappedIterable;
   });
   let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynamic, dart.dynamic);
-  let _iterator = Symbol('_iterator');
+  let _iterator = dart.JsSymbol('_iterator');
   let MappedIterator$ = dart.generic(function(S, T) {
     class MappedIterator extends core.Iterator$(T) {
       MappedIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_current] = null;
         super.Iterator();
       }
       moveNext() {
         if (this[_iterator].moveNext()) {
           this[_current] = this[_f](this[_iterator].current);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     return MappedIterator;
   });
   let MappedIterator = MappedIterator$(dart.dynamic, dart.dynamic);
-  let _source = Symbol('_source');
+  let _source = dart.JsSymbol('_source');
   let MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f$) {
         this[_source] = source;
         this[_f] = f$;
         super.ListIterable();
       }
       get length() {
         return this[_source].length;
       }
       elementAt(index) {
         return this[_f](this[_source].elementAt(index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic);
   let WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
-        return new WhereIterator(this[_iterable].iterator, this[_f]);
+        return new (WhereIterator$(E))(this[_iterable].iterator, this[_f]);
       }
     }
     return WhereIterable;
   });
   let WhereIterable = WhereIterable$(dart.dynamic);
   let WhereIterator$ = dart.generic(function(E) {
     class WhereIterator extends core.Iterator$(E) {
       WhereIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
@@ skipping 15 matching lines @@
   });
   let WhereIterator = WhereIterator$(dart.dynamic);
   let ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
-        return new ExpandIterator(this[_iterable].iterator, dart.closureWrap(this[_f], "(S) → Iterable<T>"));
+        return new (ExpandIterator$(S, T))(this[_iterable].iterator, dart.closureWrap(this[_f], "(S) → Iterable<T>"));
       }
     }
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$(dart.dynamic, dart.dynamic);
-  let _currentExpansion = Symbol('_currentExpansion');
-  let _nextExpansion = Symbol('_nextExpansion');
+  let _currentExpansion = dart.JsSymbol('_currentExpansion');
+  let _nextExpansion = dart.JsSymbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_currentExpansion] = dart.as(new EmptyIterator(), core.Iterator$(T));
         this[_current] = null;
       }
       [_nextExpansion]() {}
       get current() {
@@ skipping 12 matching lines @@
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
     ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic);
-  let _takeCount = Symbol('_takeCount');
+  let _takeCount = dart.JsSymbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       TakeIterable(iterable, takeCount) {
         if (dart.notNull(!(typeof takeCount == 'number')) || dart.notNull(takeCount) < 0) {
           throw new core.ArgumentError(takeCount);
         }
         if (dart.is(iterable, EfficientLength)) {
-          return new EfficientLengthTakeIterable(iterable, takeCount);
+          return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
         }
-        return new TakeIterable[_](iterable, takeCount);
+        return new TakeIterable$(E)[_](iterable, takeCount);
       }
       [_](iterable$, takeCount$) {
         this[_iterable] = iterable$;
         this[_takeCount] = takeCount$;
         super.IterableBase();
       }
       get iterator() {
-        return new TakeIterator(this[_iterable].iterator, this[_takeCount]);
+        return new (TakeIterator$(E))(this[_iterable].iterator, this[_takeCount]);
       }
     }
     dart.defineNamedConstructor(TakeIterable, _);
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$(dart.dynamic);
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super[_](iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable].length;
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthTakeIterable;
   });
   let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic);
-  let _remaining = Symbol('_remaining');
+  let _remaining = dart.JsSymbol('_remaining');
   let TakeIterator$ = dart.generic(function(E) {
     class TakeIterator extends core.Iterator$(E) {
       TakeIterator(iterator$, remaining) {
         this[_iterator] = iterator$;
         this[_remaining] = remaining;
         super.Iterator();
         dart.assert(dart.notNull(typeof this[_remaining] == 'number') && dart.notNull(this[_remaining]) >= 0);
       }
       moveNext() {
         this[_remaining] = dart.notNull(this[_remaining]) - 1;
@@ skipping 13 matching lines @@
   });
   let TakeIterator = TakeIterator$(dart.dynamic);
   let TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
-        return new TakeWhileIterator(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
+        return new (TakeWhileIterator$(E))(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
       }
     }
     return TakeWhileIterable;
   });
   let TakeWhileIterable = TakeWhileIterable$(dart.dynamic);
-  let _isFinished = Symbol('_isFinished');
+  let _isFinished = dart.JsSymbol('_isFinished');
   let TakeWhileIterator$ = dart.generic(function(E) {
     class TakeWhileIterator extends core.Iterator$(E) {
       TakeWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_isFinished] = false;
         super.Iterator();
       }
       moveNext() {
         if (this[_isFinished])
           return false;
         if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(dart.dinvokef(this[_f], this[_iterator].current))) {
           this[_isFinished] = true;
           return false;
         }
         return true;
       }
       get current() {
         if (this[_isFinished])
           return null;
         return this[_iterator].current;
       }
     }
     return TakeWhileIterator;
   });
   let TakeWhileIterator = TakeWhileIterator$(dart.dynamic);
-  let _skipCount = Symbol('_skipCount');
+  let _skipCount = dart.JsSymbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
-          return new EfficientLengthSkipIterable(iterable, count);
+          return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
-        return new SkipIterable[_](iterable, count);
+        return new SkipIterable$(E)[_](iterable, count);
       }
       [_](iterable$, skipCount$) {
         this[_iterable] = iterable$;
         this[_skipCount] = skipCount$;
         super.IterableBase();
         if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
       }
       skip(count) {
         if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
-        return new SkipIterable[_](this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
+        return new SkipIterable$(E)[_](this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get iterator() {
-        return new SkipIterator(this[_iterable].iterator, this[_skipCount]);
+        return new (SkipIterator$(E))(this[_iterable].iterator, this[_skipCount]);
       }
     }
     dart.defineNamedConstructor(SkipIterable, _);
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$(dart.dynamic);
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super[_](iterable, skipCount);
@@ skipping 31 matching lines @@
   });
   let SkipIterator = SkipIterator$(dart.dynamic);
   let SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
-        return new SkipWhileIterator(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
+        return new (SkipWhileIterator$(E))(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
       }
     }
     return SkipWhileIterable;
   });
   let SkipWhileIterable = SkipWhileIterable$(dart.dynamic);
-  let _hasSkipped = Symbol('_hasSkipped');
+  let _hasSkipped = dart.JsSymbol('_hasSkipped');
   let SkipWhileIterator$ = dart.generic(function(E) {
     class SkipWhileIterator extends core.Iterator$(E) {
       SkipWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_hasSkipped] = false;
         super.Iterator();
       }
       moveNext() {
         if (!dart.notNull(this[_hasSkipped])) {
@@ skipping 92 matching lines @@
       }
       take(count) {
         core.RangeError.checkNotNegative(count, "count");
         return this;
       }
       takeWhile(test) {
         return this;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return growable ? new core.List$(E).from([]) : new core.List(0);
+        return growable ? new core.List$(E).from([]) : new (core.List$(E))(0);
       }
       toSet() {
-        return new core.Set();
+        return new (core.Set$(E))();
       }
     }
     EmptyIterable[dart.implements] = () => [EfficientLength];
     return EmptyIterable;
   });
   let EmptyIterable = EmptyIterable$(dart.dynamic);
   let EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$(dart.dynamic);
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {
     }
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
-  let _rangeCheck = Symbol('_rangeCheck');
+  let _rangeCheck = dart.JsSymbol('_rangeCheck');
   let IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       static forEach(iterable, f) {
@@ skipping 164 matching lines @@
         } else {
           buffer.write(list.get(0));
           for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
             buffer.write(separator);
             buffer.write(list.get(i));
           }
         }
         return buffer.toString();
       }
       where(iterable, f) {
-        return new WhereIterable(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(f, "(T) → bool"));
+        return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(f, "(T) → bool"));
       }
       static map(iterable, f) {
         return new MappedIterable(iterable, f);
       }
       static mapList(list, f) {
         return new MappedListIterable(list, f);
       }
       static expand(iterable, f) {
         return new ExpandIterable(iterable, f);
       }
       takeList(list, n) {
-        return new SubListIterable(dart.as(list, core.Iterable$(T)), 0, n);
+        return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), 0, n);
       }
       takeWhile(iterable, test) {
-        return new TakeWhileIterable(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(test, "(T) → bool"));
+        return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(test, "(T) → bool"));
       }
       skipList(list, n) {
-        return new SubListIterable(dart.as(list, core.Iterable$(T)), n, null);
+        return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), n, null);
       }
       skipWhile(iterable, test) {
-        return new SkipWhileIterable(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(test, "(T) → bool"));
+        return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.closureWrap(test, "(T) → bool"));
       }
       reversedList(list) {
-        return new ReversedListIterable(dart.as(list, core.Iterable$(T)));
+        return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));
       }
       static sortList(list, compare) {
         if (compare == null)
           compare = core.Comparable.compare;
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
         if (random == null)
           random = new math.Random();
         let length = list.length;
@@ skipping 11 matching lines @@
       static lastIndexOfList(list, element, start) {
         if (start == null)
           start = dart.notNull(list.length) - 1;
         return Lists.lastIndexOf(list, element, start);
       }
       static [_rangeCheck](list, start, end) {
         core.RangeError.checkValidRange(start, end, list.length);
       }
       getRangeList(list, start, end) {
         IterableMixinWorkaround[_rangeCheck](list, start, end);
-        return new SubListIterable(dart.as(list, core.Iterable$(T)), start, end);
+        return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), start, end);
       }
       static setRangeList(list, start, end, from, skipCount) {
         IterableMixinWorkaround[_rangeCheck](list, start, end);
         let length = dart.notNull(end) - dart.notNull(start);
         if (length == 0)
           return;
         if (dart.notNull(skipCount) < 0)
           throw new core.ArgumentError(skipCount);
         let otherList = null;
         let otherStart = null;
@@ skipping 52 matching lines @@
           list.set(((x) => index = dart.notNull(x) + 1, x)(index), element);
         }
       }
       static setAllList(list, index, iterable) {
         core.RangeError.checkValueInInterval(index, 0, list.length, "index");
         for (let element of iterable) {
           list.set(((x) => index = dart.notNull(x) + 1, x)(index), element);
         }
       }
       asMapList(l) {
-        return new ListMapView(dart.as(l, core.List$(T)));
+        return new (ListMapView$(T))(dart.as(l, core.List$(T)));
       }
       static setContainsAll(set, other) {
         for (let element of other) {
           if (!dart.notNull(set.contains(element)))
             return false;
         }
         return true;
       }
       static setIntersection(set, other, result) {
         let smaller = null;
@@ skipping 162 matching lines @@
     }
     return FixedLengthListBase;
   });
   let FixedLengthListBase = FixedLengthListBase$(dart.dynamic);
   let UnmodifiableListBase$ = dart.generic(function(E) {
     class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) {
     }
     return UnmodifiableListBase;
   });
   let UnmodifiableListBase = UnmodifiableListBase$(dart.dynamic);
-  let _backedList = Symbol('_backedList');
+  let _backedList = dart.JsSymbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable(backedList) {
       this[_backedList] = backedList;
       super.ListIterable();
     }
     get length() {
       return this[_backedList].length;
     }
     elementAt(index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
-  let _values = Symbol('_values');
+  let _values = dart.JsSymbol('_values');
   let ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
         this[_values] = values;
       }
       get(key) {
         return this.containsKey(key) ? this[_values].get(key) : null;
       }
       get length() {
         return this[_values].length;
       }
       get values() {
-        return new SubListIterable(this[_values], 0, null);
+        return new (SubListIterable$(E))(this[_values], 0, null);
       }
       get keys() {
         return new _ListIndicesIterable(this[_values]);
       }
       get isEmpty() {
         return this[_values].isEmpty;
       }
       get isNotEmpty() {
         return this[_values].isNotEmpty;
       }
@@ skipping 145 matching lines @@
         let message = `${start} + ${length} must be in the range [0..${a.length}]`;
         throw new core.RangeError.range(length, 0, dart.notNull(a.length) - dart.notNull(start), "length", message);
       }
     }
   }
   exports.printToZone = null;
   // Function printToConsole: (String) → void
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
-  let _doSort = Symbol('_doSort');
-  let _INSERTION_SORT_THRESHOLD = Symbol('_INSERTION_SORT_THRESHOLD');
-  let _insertionSort = Symbol('_insertionSort');
-  let _dualPivotQuicksort = Symbol('_dualPivotQuicksort');
+  let _doSort = dart.JsSymbol('_doSort');
+  let _INSERTION_SORT_THRESHOLD = dart.JsSymbol('_INSERTION_SORT_THRESHOLD');
+  let _insertionSort = dart.JsSymbol('_insertionSort');
+  let _dualPivotQuicksort = dart.JsSymbol('_dualPivotQuicksort');
   class Sort extends core.Object {
     static sort(a, compare) {
       Sort[_doSort](a, 0, dart.notNull(a.length) - 1, compare);
     }
     static sortRange(a, from, to, compare) {
       if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a.length) || dart.notNull(to) < dart.notNull(from)) {
         throw "OutOfRange";
       }
       Sort[_doSort](a, from, dart.notNull(to) - 1, compare);
     }
@@ skipping 203 matching lines @@
             }
           }
         }
         Sort[_doSort](a, less, great, compare);
       } else {
         Sort[_doSort](a, less, great, compare);
       }
     }
   }
   Sort._INSERTION_SORT_THRESHOLD = 32;
-  let _name = Symbol('_name');
+  let _name = dart.JsSymbol('_name');
   class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     unvalidated(name$) {
       this[_name] = name$;
     }
     validated(name) {
       this[_name] = Symbol.validatePublicSymbol(name);
     }
@@ skipping 105 matching lines @@
   exports.ReversedListIterable$ = ReversedListIterable$;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal || (_internal = {}));