fixes #215, removes special case for length

lib/runtime/dart/_internal.js

 dart.library('dart/_internal', null, /* Imports */[
   'dart/core',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/math',
   'dart/_interceptors',
   'dart/_js_primitives'
 ], function(exports, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   class EfficientLength extends core.Object {}
@@ skipping 203 matching lines @@
       }
       takeWhile(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return super.takeWhile(test);
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (dart.notNull(growable)) {
           result = core.List$(E).new();
-          result.length = this.length;
+          result[dartx.length] = this.length;
         } else {
           result = core.List$(E).new(this.length);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result[dartx.set](i, this.elementAt(i));
         }
         return result;
       }
       toSet() {
         let result = core.Set$(E).new();
@@ skipping 67 matching lines @@
         super.ListIterable();
         core.RangeError.checkNotNegative(this[_start], "start");
         if (this[_endOrLength] != null) {
           core.RangeError.checkNotNegative(this[_endOrLength], "end");
           if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) {
             throw new core.RangeError.range(this[_start], 0, this[_endOrLength], "start");
           }
         }
       }
       get [_endIndex]() {
-        let length = this[_iterable].length;
+        let length = this[_iterable][dartx.length];
         if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) > dart.notNull(length))
           return length;
         return this[_endOrLength];
       }
       get [_startIndex]() {
-        let length = this[_iterable].length;
+        let length = this[_iterable][dartx.length];
         if (dart.notNull(this[_start]) > dart.notNull(length))
           return length;
         return this[_start];
       }
       get length() {
-        let length = this[_iterable].length;
+        let length = this[_iterable][dartx.length];
         if (dart.notNull(this[_start]) >= dart.notNull(length))
           return 0;
         if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) >= dart.notNull(length)) {
           return dart.notNull(length) - dart.notNull(this[_start]);
         }
         return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]);
       }
       elementAt(index) {
         let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
         if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(this[_endIndex])) {
@@ skipping 16 matching lines @@
         } else {
           let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
           if (dart.notNull(this[_endOrLength]) < dart.notNull(newEnd))
             return this;
           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;
+        let end = this[_iterable][dartx.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 = dart.notNull(growable) ? (() => {
           let _ = core.List$(E).new();
-          _.length = length;
+          _[dartx.length] = length;
           return _;
         })() : core.List$(E).new(length);
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[dartx.set](i, this[_iterable][dartx.elementAt](dart.notNull(start) + dart.notNull(i)));
-          if (dart.notNull(this[_iterable].length) < dart.notNull(end))
+          if (dart.notNull(this[_iterable][dartx.length]) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     dart.setSignature(SubListIterable, {
       constructors: () => ({SubListIterable: [SubListIterable$(E), [core.Iterable$(E), core.int, core.int]]}),
       methods: () => ({
         elementAt: [E, [core.int]],
         skip: [core.Iterable$(E), [core.int]],
@@ skipping 11 matching lines @@
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$();
   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[_length] = iterable[dartx.length];
         this[_index] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
-        let length = this[_iterable].length;
+        let length = this[_iterable][dartx.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][dartx.elementAt](this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
@@ skipping 23 matching lines @@
       }
       _(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get iterator() {
         return new (MappedIterator$(S, T))(this[_iterable][dartx.iterator], this[_f]);
       }
       get length() {
-        return this[_iterable].length;
+        return this[_iterable][dartx.length];
       }
       get isEmpty() {
         return this[_iterable][dartx.isEmpty];
       }
       get first() {
         return this[_f](this[_iterable][dartx.first]);
       }
       get last() {
         return this[_f](this[_iterable][dartx.last]);
       }
@@ skipping 66 matching lines @@
   let MappedIterator = MappedIterator$();
   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;
+        return this[_source][dartx.length];
       }
       elementAt(index) {
         return this[_f](this[_source][dartx.elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(MappedListIterable, {
       constructors: () => ({MappedListIterable: [MappedListIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S])]]}),
       methods: () => ({elementAt: [T, [core.int]]})
     });
@@ skipping 144 matching lines @@
     dart.defineExtensionMembers(TakeIterable, ['iterator']);
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$();
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super._(iterable, takeCount);
       }
       get length() {
-        let iterableLength = this[_iterable].length;
+        let iterableLength = this[_iterable][dartx.length];
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthTakeIterable, {
       constructors: () => ({EfficientLengthTakeIterable: [EfficientLengthTakeIterable$(E), [core.Iterable$(E), core.int]]})
     });
     dart.defineExtensionMembers(EfficientLengthTakeIterable, ['length']);
@@ skipping 117 matching lines @@
     dart.defineExtensionMembers(SkipIterable, ['skip', 'iterator']);
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super._(iterable, skipCount);
       }
       get length() {
-        let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_skipCount]);
+        let length = dart.notNull(this[_iterable][dartx.length]) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthSkipIterable, {
       constructors: () => ({EfficientLengthSkipIterable: [EfficientLengthSkipIterable$(E), [core.Iterable$(E), core.int]]})
     });
     dart.defineExtensionMembers(EfficientLengthSkipIterable, ['length']);
@@ skipping 303 matching lines @@
       static fold(iterable, initialValue, combine) {
         dart.as(combine, dart.functionType(core.Object, [dart.bottom, dart.bottom]));
         for (let element of iterable) {
           initialValue = dart.dcall(combine, initialValue, element);
         }
         return initialValue;
       }
       static removeWhereList(list, test) {
         dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         let retained = [];
-        let length = list.length;
+        let length = list[dartx.length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = list[dartx.get](i);
           if (!dart.notNull(dart.dcall(test, element))) {
             retained[dartx.add](element);
           }
-          if (length != list.length) {
+          if (length != list[dartx.length]) {
             throw new core.ConcurrentModificationError(list);
           }
         }
-        if (retained.length == length)
+        if (retained[dartx.length] == length)
           return;
-        list.length = retained.length;
-        for (let i = 0; dart.notNull(i) < dart.notNull(retained.length); i = dart.notNull(i) + 1) {
+        list[dartx.length] = retained[dartx.length];
+        for (let i = 0; dart.notNull(i) < dart.notNull(retained[dartx.length]); i = dart.notNull(i) + 1) {
           list[dartx.set](i, retained[dartx.get](i));
         }
       }
       static isEmpty(iterable) {
         return !dart.notNull(iterable[dartx.iterator].moveNext());
       }
       static first(iterable) {
         let it = iterable[dartx.iterator];
         if (!dart.notNull(it.moveNext())) {
           throw IterableElementError.noElement();
@@ skipping 44 matching lines @@
         }
         if (dart.notNull(foundMatching))
           return result;
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       static lastWhereList(list, test, orElse) {
         dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         dart.as(orElse, dart.functionType(core.Object, []));
-        for (let i = dart.notNull(list.length) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
+        for (let i = dart.notNull(list[dartx.length]) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           let element = list[dartx.get](i);
           if (dart.notNull(dart.dcall(test, element)))
             return element;
         }
         if (orElse != null)
           return orElse();
         throw IterableElementError.noElement();
       }
       static singleWhere(iterable, test) {
         dart.as(test, dart.functionType(core.bool, [dart.bottom]));
@@ skipping 29 matching lines @@
           separator = null;
         let buffer = new core.StringBuffer();
         buffer.writeAll(iterable, separator);
         return dart.toString(buffer);
       }
       static joinList(list, separator) {
         if (separator === void 0)
           separator = null;
         if (dart.notNull(list[dartx.isEmpty]))
           return "";
-        if (list.length == 1)
+        if (list[dartx.length] == 1)
           return `${list[dartx.get](0)}`;
         let buffer = new core.StringBuffer();
         if (dart.notNull(separator[dartx.isEmpty])) {
-          for (let i = 0; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
+          for (let i = 0; dart.notNull(i) < dart.notNull(list[dartx.length]); i = dart.notNull(i) + 1) {
             buffer.write(list[dartx.get](i));
           }
         } else {
           buffer.write(list[dartx.get](0));
-          for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
+          for (let i = 1; dart.notNull(i) < dart.notNull(list[dartx.length]); i = dart.notNull(i) + 1) {
             buffer.write(separator);
             buffer.write(list[dartx.get](i));
           }
         }
         return dart.toString(buffer);
       }
       where(iterable, f) {
         dart.as(f, dart.functionType(core.bool, [dart.bottom]));
         return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, __CastType6));
       }
@@ skipping 28 matching lines @@
       }
       static sortList(list, compare) {
         dart.as(compare, dart.functionType(core.int, [dart.bottom, dart.bottom]));
         if (compare == null)
           compare = core.Comparable.compare;
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
         if (random == null)
           random = math.Random.new();
-        let length = list.length;
+        let length = list[dartx.length];
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
           length = dart.notNull(length) - 1;
           let tmp = list[dartx.get](length);
           list[dartx.set](length, list[dartx.get](pos));
           list[dartx.set](pos, tmp);
         }
       }
       static indexOfList(list, element, start) {
-        return Lists.indexOf(list, element, start, list.length);
+        return Lists.indexOf(list, element, start, list[dartx.length]);
       }
       static lastIndexOfList(list, element, start) {
         if (start == null)
-          start = dart.notNull(list.length) - 1;
+          start = dart.notNull(list[dartx.length]) - 1;
         return Lists.lastIndexOf(list, element, start);
       }
       static _rangeCheck(list, start, end) {
-        core.RangeError.checkValidRange(start, end, list.length);
+        core.RangeError.checkValidRange(start, end, list[dartx.length]);
       }
       getRangeList(list, start, end) {
         IterableMixinWorkaround$()._rangeCheck(list, 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;
         if (dart.is(from, core.List)) {
           otherList = from;
           otherStart = skipCount;
         } else {
           otherList = from[dartx.skip](skipCount)[dartx.toList]({growable: false});
           otherStart = 0;
         }
-        if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(otherList.length)) {
+        if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(otherList[dartx.length])) {
           throw IterableElementError.tooFew();
         }
         Lists.copy(otherList, otherStart, list, start, length);
       }
       static replaceRangeList(list, start, end, iterable) {
         IterableMixinWorkaround$()._rangeCheck(list, start, end);
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[dartx.toList]();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
-        let insertLength = iterable.length;
+        let insertLength = iterable[dartx.length];
         if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
           let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
-          let newEnd = dart.notNull(list.length) - dart.notNull(delta);
+          let newEnd = dart.notNull(list[dartx.length]) - dart.notNull(delta);
           list[dartx.setRange](start, insertEnd, iterable);
           if (delta != 0) {
             list[dartx.setRange](insertEnd, newEnd, list, end);
-            list.length = newEnd;
+            list[dartx.length] = newEnd;
           }
         } else {
           let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
-          let newLength = dart.notNull(list.length) + dart.notNull(delta);
+          let newLength = dart.notNull(list[dartx.length]) + dart.notNull(delta);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
-          list.length = newLength;
+          list[dartx.length] = newLength;
           list[dartx.setRange](insertEnd, newLength, list, end);
           list[dartx.setRange](start, insertEnd, iterable);
         }
       }
       static fillRangeList(list, start, end, fillValue) {
         IterableMixinWorkaround$()._rangeCheck(list, start, end);
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           list[dartx.set](i, fillValue);
         }
       }
       static insertAllList(list, index, iterable) {
-        core.RangeError.checkValueInInterval(index, 0, list.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, list[dartx.length], "index");
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[dartx.toList]({growable: false});
         }
-        let insertionLength = iterable.length;
-        list.length = dart.notNull(list.length) + dart.notNull(insertionLength);
-        list[dartx.setRange](dart.notNull(index) + dart.notNull(insertionLength), list.length, list, index);
+        let insertionLength = iterable[dartx.length];
+        list[dartx.length] = dart.notNull(list[dartx.length]) + dart.notNull(insertionLength);
+        list[dartx.setRange](dart.notNull(index) + dart.notNull(insertionLength), list[dartx.length], list, index);
         for (let element of iterable) {
           list[dartx.set]((() => {
             let x = index;
             index = dart.notNull(x) + 1;
             return x;
           })(), element);
         }
       }
       static setAllList(list, index, iterable) {
-        core.RangeError.checkValueInInterval(index, 0, list.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, list[dartx.length], "index");
         for (let element of iterable) {
           list[dartx.set]((() => {
             let x = index;
             index = dart.notNull(x) + 1;
             return x;
           })(), element);
         }
       }
       asMapList(l) {
         return new (ListMapView$(T))(dart.as(l, core.List$(T)));
@@ skipping 333 matching lines @@
     return UnmodifiableListBase;
   });
   let UnmodifiableListBase = UnmodifiableListBase$();
   let _backedList = dart.JsSymbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable(backedList) {
       this[_backedList] = backedList;
       super.ListIterable();
     }
     get length() {
-      return this[_backedList].length;
+      return this[_backedList][dartx.length];
     }
     elementAt(index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   dart.setSignature(_ListIndicesIterable, {
     constructors: () => ({_ListIndicesIterable: [_ListIndicesIterable, [core.List]]}),
     methods: () => ({elementAt: [core.int, [core.int]]})
   });
   dart.defineExtensionMembers(_ListIndicesIterable, ['elementAt', 'length']);
   let _values = dart.JsSymbol('_values');
   let ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
         this[_values] = values;
       }
       get(key) {
         return dart.notNull(this.containsKey(key)) ? this[_values][dartx.get](dart.as(key, core.int)) : null;
       }
       get length() {
-        return this[_values].length;
+        return this[_values][dartx.length];
       }
       get values() {
         return new (SubListIterable$(E))(this[_values], 0, null);
       }
       get keys() {
         return new _ListIndicesIterable(this[_values]);
       }
       get isEmpty() {
         return this[_values][dartx.isEmpty];
       }
       get isNotEmpty() {
         return this[_values][dartx.isNotEmpty];
       }
       containsValue(value) {
         return this[_values][dartx.contains](value);
       }
       containsKey(key) {
         return typeof key == 'number' && dart.notNull(key) >= 0 && dart.notNull(key) < dart.notNull(this.length);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [core.int, E]));
-        let length = this[_values].length;
+        let length = this[_values][dartx.length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(i, this[_values][dartx.get](i));
-          if (length != this[_values].length) {
+          if (length != this[_values][dartx.length]) {
             throw new core.ConcurrentModificationError(this[_values]);
           }
         }
       }
       set(key, value) {
         dart.as(value, E);
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(ifAbsent, dart.functionType(E, []));
@@ skipping 31 matching lines @@
     return ListMapView;
   });
   let ListMapView = ListMapView$();
   let ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get length() {
-        return this[_source].length;
+        return this[_source][dartx.length];
       }
       elementAt(index) {
-        return this[_source][dartx.elementAt](dart.notNull(this[_source].length) - 1 - dart.notNull(index));
+        return this[_source][dartx.elementAt](dart.notNull(this[_source][dartx.length]) - 1 - dart.notNull(index));
       }
     }
     dart.setSignature(ReversedListIterable, {
       constructors: () => ({ReversedListIterable: [ReversedListIterable$(E), [core.Iterable$(E)]]}),
       methods: () => ({elementAt: [E, [core.int]]})
     });
     dart.defineExtensionMembers(ReversedListIterable, ['elementAt', 'length']);
     return ReversedListIterable;
   });
   let ReversedListIterable = ReversedListIterable$();
@@ skipping 54 matching lines @@
         for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
           dst[dartx.set](j, src[dartx.get](i));
         }
       }
     }
     static areEqual(a, b) {
       if (dart.notNull(core.identical(a, b)))
         return true;
       if (!dart.is(b, core.List))
         return false;
-      let length = a.length;
+      let length = a[dartx.length];
       if (!dart.equals(length, dart.dload(b, 'length')))
         return false;
       for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
         if (!dart.notNull(core.identical(a[dartx.get](i), dart.dindex(b, i))))
           return false;
       }
       return true;
     }
     static indexOf(a, element, startIndex, endIndex) {
-      if (dart.notNull(startIndex) >= dart.notNull(a.length)) {
+      if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
         return -1;
       }
       if (dart.notNull(startIndex) < 0) {
         startIndex = 0;
       }
       for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
         if (dart.equals(a[dartx.get](i), element)) {
           return i;
         }
       }
       return -1;
     }
     static lastIndexOf(a, element, startIndex) {
       if (dart.notNull(startIndex) < 0) {
         return -1;
       }
-      if (dart.notNull(startIndex) >= dart.notNull(a.length)) {
-        startIndex = dart.notNull(a.length) - 1;
+      if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
+        startIndex = dart.notNull(a[dartx.length]) - 1;
       }
       for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
         if (dart.equals(a[dartx.get](i), element)) {
           return i;
         }
       }
       return -1;
     }
     static indicesCheck(a, start, end) {
-      core.RangeError.checkValidRange(start, end, a.length);
+      core.RangeError.checkValidRange(start, end, a[dartx.length]);
     }
     static rangeCheck(a, start, length) {
       core.RangeError.checkNotNegative(length);
       core.RangeError.checkNotNegative(start);
-      if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a.length)) {
-        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);
+      if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a[dartx.length])) {
+        let message = `${start} + ${length} must be in the range [0..${a[dartx.length]}]`;
+        throw new core.RangeError.range(length, 0, dart.notNull(a[dartx.length]) - dart.notNull(start), "length", message);
       }
     }
   }
   dart.setSignature(Lists, {
     statics: () => ({
       copy: [dart.void, [core.List, core.int, core.List, core.int, core.int]],
       areEqual: [core.bool, [core.List, core.Object]],
       indexOf: [core.int, [core.List, core.Object, core.int, core.int]],
       lastIndexOf: [core.int, [core.List, core.Object, core.int]],
       indicesCheck: [dart.void, [core.List, core.int, core.int]],
       rangeCheck: [dart.void, [core.List, core.int, core.int]]
     }),
     names: ['copy', 'areEqual', 'indexOf', 'lastIndexOf', 'indicesCheck', 'rangeCheck']
   });
   exports.printToZone = null;
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
   dart.fn(printToConsole, dart.void, [core.String]);
   class Sort extends core.Object {
     static sort(a, compare) {
-      Sort._doSort(a, 0, dart.notNull(a.length) - 1, compare);
+      Sort._doSort(a, 0, dart.notNull(a[dartx.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)) {
+      if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a[dartx.length]) || dart.notNull(to) < dart.notNull(from)) {
         throw "OutOfRange";
       }
       Sort._doSort(a, from, dart.notNull(to) - 1, compare);
     }
     static _doSort(a, left, right, compare) {
       if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTION_SORT_THRESHOLD)) {
         Sort._insertionSort(a, left, right, compare);
       } else {
         Sort._dualPivotQuicksort(a, left, right, compare);
       }
@@ skipping 383 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;
 });