fixes #215, removes special case for length

lib/runtime/dart/collection.js

 dart.library('dart/collection', null, /* Imports */[
   'dart/core'
 ], /* Lazy imports */[
   'dart/_internal',
   'dart/_js_helper',
   'dart/math'
 ], function(exports, core, _internal, _js_helper, math) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
       }
       get length() {
-        return this[_source].length;
+        return this[_source][dartx.length];
       }
       get(index) {
         return this[_source][dartx.elementAt](index);
       }
     }
     dart.setSignature(UnmodifiableListView, {
       constructors: () => ({UnmodifiableListView: [exports.UnmodifiableListView$(E), [core.Iterable$(E)]]}),
       methods: () => ({get: [E, [core.int]]})
     });
     dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
@@ skipping 158 matching lines @@
         for (let element of this) {
           if (dart.notNull(other.contains(element)))
             result.remove(element);
         }
         return result;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = dart.notNull(growable) ? (() => {
           let _ = core.List$(E).new();
-          _.length = this.length;
+          _[dartx.length] = this.length;
           return _;
         })() : core.List$(E).new(this.length);
         let i = 0;
         for (let element of this)
           result[dartx.set]((() => {
             let x = i;
             i = dart.notNull(x) + 1;
             return x;
           })(), element);
         return result;
@@ skipping 853 matching lines @@
         try {
           buffer.writeAll(iterable, ", ");
         } finally {
           dart.assert(core.identical(IterableBase$()._toStringVisiting[dartx.last], iterable));
           IterableBase$()._toStringVisiting[dartx.removeLast]();
         }
         buffer.write(rightDelimiter);
         return dart.toString(buffer);
       }
       static _isToStringVisiting(o) {
-        for (let i = 0; dart.notNull(i) < dart.notNull(IterableBase$()._toStringVisiting.length); i = dart.notNull(i) + 1) {
+        for (let i = 0; dart.notNull(i) < dart.notNull(IterableBase$()._toStringVisiting[dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(core.identical(o, IterableBase$()._toStringVisiting[dartx.get](i))))
             return true;
         }
         return false;
       }
       static _iterablePartsToStrings(iterable, parts) {
         let LENGTH_LIMIT = 80;
         let HEAD_COUNT = 3;
         let TAIL_COUNT = 2;
         let MAX_COUNT = 100;
         let OVERHEAD = 2;
         let ELLIPSIS_SIZE = 3;
         let length = 0;
         let count = 0;
         let it = iterable[dartx.iterator];
         while (dart.notNull(length) < dart.notNull(LENGTH_LIMIT) || dart.notNull(count) < dart.notNull(HEAD_COUNT)) {
           if (!dart.notNull(it.moveNext()))
             return;
           let next = `${it.current}`;
           parts[dartx.add](next);
-          length = dart.notNull(length) + (dart.notNull(next.length) + dart.notNull(OVERHEAD));
+          length = dart.notNull(length) + (dart.notNull(next[dartx.length]) + dart.notNull(OVERHEAD));
           count = dart.notNull(count) + 1;
         }
         let penultimateString = null;
         let ultimateString = null;
         let penultimate = null;
         let ultimate = null;
         if (!dart.notNull(it.moveNext())) {
           if (dart.notNull(count) <= dart.notNull(HEAD_COUNT) + dart.notNull(TAIL_COUNT))
             return;
           ultimateString = dart.as(parts[dartx.removeLast](), core.String);
           penultimateString = dart.as(parts[dartx.removeLast](), core.String);
         } else {
           penultimate = it.current;
           count = dart.notNull(count) + 1;
           if (!dart.notNull(it.moveNext())) {
             if (dart.notNull(count) <= dart.notNull(HEAD_COUNT) + 1) {
               parts[dartx.add](`${penultimate}`);
               return;
             }
             ultimateString = `${penultimate}`;
             penultimateString = dart.as(parts[dartx.removeLast](), core.String);
-            length = dart.notNull(length) + (dart.notNull(ultimateString.length) + dart.notNull(OVERHEAD));
+            length = dart.notNull(length) + (dart.notNull(ultimateString[dartx.length]) + dart.notNull(OVERHEAD));
           } else {
             ultimate = it.current;
             count = dart.notNull(count) + 1;
             dart.assert(dart.notNull(count) < dart.notNull(MAX_COUNT));
             while (dart.notNull(it.moveNext())) {
               penultimate = ultimate;
               ultimate = it.current;
               count = dart.notNull(count) + 1;
               if (dart.notNull(count) > dart.notNull(MAX_COUNT)) {
                 while (dart.notNull(length) > dart.notNull(LENGTH_LIMIT) - dart.notNull(ELLIPSIS_SIZE) - dart.notNull(OVERHEAD) && dart.notNull(count) > dart.notNull(HEAD_COUNT)) {
                   length = dart.notNull(length) - dart.notNull(dart.as(dart.dsend(dart.dload(parts[dartx.removeLast](), 'length'), '+', OVERHEAD), core.int));
                   count = dart.notNull(count) - 1;
                 }
                 parts[dartx.add]("...");
                 return;
               }
             }
             penultimateString = `${penultimate}`;
             ultimateString = `${ultimate}`;
-            length = dart.notNull(length) + (dart.notNull(ultimateString.length) + dart.notNull(penultimateString.length) + 2 * dart.notNull(OVERHEAD));
+            length = dart.notNull(length) + (dart.notNull(ultimateString[dartx.length]) + dart.notNull(penultimateString[dartx.length]) + 2 * dart.notNull(OVERHEAD));
           }
         }
         let elision = null;
-        if (dart.notNull(count) > dart.notNull(parts.length) + dart.notNull(TAIL_COUNT)) {
+        if (dart.notNull(count) > dart.notNull(parts[dartx.length]) + dart.notNull(TAIL_COUNT)) {
           elision = "...";
           length = dart.notNull(length) + (dart.notNull(ELLIPSIS_SIZE) + dart.notNull(OVERHEAD));
         }
-        while (dart.notNull(length) > dart.notNull(LENGTH_LIMIT) && dart.notNull(parts.length) > dart.notNull(HEAD_COUNT)) {
+        while (dart.notNull(length) > dart.notNull(LENGTH_LIMIT) && dart.notNull(parts[dartx.length]) > dart.notNull(HEAD_COUNT)) {
           length = dart.notNull(length) - dart.notNull(dart.as(dart.dsend(dart.dload(parts[dartx.removeLast](), 'length'), '+', OVERHEAD), core.int));
           if (elision == null) {
             elision = "...";
             length = dart.notNull(length) + (dart.notNull(ELLIPSIS_SIZE) + dart.notNull(OVERHEAD));
           }
         }
         if (elision != null) {
           parts[dartx.add](elision);
         }
         parts[dartx.add](penultimateString);
@@ skipping 481 matching lines @@
         dart.as(action, dart.functionType(dart.void, [E]));
         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);
           }
         }
       }
       get isEmpty() {
-        return this.length == 0;
+        return this[dartx.length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get first() {
-        if (this.length == 0)
+        if (this[dartx.length] == 0)
           throw _internal.IterableElementError.noElement();
         return this.get(0);
       }
       get last() {
-        if (this.length == 0)
+        if (this[dartx.length] == 0)
           throw _internal.IterableElementError.noElement();
-        return this.get(dart.notNull(this.length) - 1);
+        return this.get(dart.notNull(this[dartx.length]) - 1);
       }
       get single() {
-        if (this.length == 0)
+        if (this[dartx.length] == 0)
           throw _internal.IterableElementError.noElement();
-        if (dart.notNull(this.length) > 1)
+        if (dart.notNull(this[dartx.length]) > 1)
           throw _internal.IterableElementError.tooMany();
         return this.get(0);
       }
       contains(element) {
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           if (dart.equals(this.get(i), element))
             return true;
           if (length != this.length) {
             throw new core.ConcurrentModificationError(this);
@@ skipping 77 matching lines @@
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (dart.notNull(matchFound))
           return match;
         throw _internal.IterableElementError.noElement();
       }
       join(separator) {
         if (separator === void 0)
           separator = "";
-        if (this.length == 0)
+        if (this[dartx.length] == 0)
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
       where(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, test);
       }
       map(f) {
@@ skipping 42 matching lines @@
       }
       takeWhile(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, 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[dartx.length];
         } else {
-          result = core.List$(E).new(this.length);
+          result = core.List$(E).new(this[dartx.length]);
         }
-        for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
+        for (let i = 0; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
           result[dartx.set](i, this.get(i));
         }
         return result;
       }
       toSet() {
         let result = core.Set$(E).new();
-        for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
+        for (let i = 0; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
           result.add(this.get(i));
         }
         return result;
       }
       add(element) {
         dart.as(element, E);
         this.set((() => {
           let x = this.length;
           this.length = dart.notNull(x) + 1;
           return x;
@@ skipping 23 matching lines @@
         dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin$()._filter(this, test, false);
       }
       retainWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         ListMixin$()._filter(this, test, true);
       }
       static _filter(source, test, retainMatching) {
         dart.as(test, dart.functionType(core.bool, [dart.bottom]));
         let retained = [];
-        let length = source.length;
+        let length = source[dartx.length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source[dartx.get](i);
           if (dart.dcall(test, element) == retainMatching) {
             retained[dartx.add](element);
           }
-          if (length != source.length) {
+          if (length != source[dartx.length]) {
             throw new core.ConcurrentModificationError(source);
           }
         }
-        if (retained.length != source.length) {
-          source[dartx.setRange](0, retained.length, retained);
-          source.length = retained.length;
+        if (retained[dartx.length] != source[dartx.length]) {
+          source[dartx.setRange](0, retained[dartx.length], retained);
+          source[dartx.length] = retained[dartx.length];
         }
       }
       clear() {
         this.length = 0;
       }
       removeLast() {
-        if (this.length == 0) {
+        if (this[dartx.length] == 0) {
           throw _internal.IterableElementError.noElement();
         }
-        let result = this.get(dart.notNull(this.length) - 1);
-        this.length = dart.notNull(this.length) - 1;
+        let result = this.get(dart.notNull(this[dartx.length]) - 1);
+        this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
         return result;
       }
       sort(compare) {
         if (compare === void 0)
           compare = null;
         dart.as(compare, dart.functionType(core.int, [E, E]));
         _internal.Sort.sort(this, compare == null ? core.Comparable.compare : compare);
       }
       shuffle(random) {
         if (random === void 0)
@@ skipping 14 matching lines @@
       }
       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 = core.List$(E).new();
-        result.length = length;
+        result[dartx.length] = length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[dartx.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$(E))(this, start, end);
       }
       removeRange(start, end) {
@@ skipping 22 matching lines @@
         core.RangeError.checkNotNegative(skipCount, "skipCount");
         let otherList = null;
         let otherStart = null;
         if (dart.is(iterable, core.List)) {
           otherList = dart.as(iterable, core.List);
           otherStart = skipCount;
         } else {
           otherList = iterable[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 _internal.IterableElementError.tooFew();
         }
         if (dart.notNull(otherStart) < dart.notNull(start)) {
           for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
             this.set(dart.notNull(start) + dart.notNull(i), dart.as(otherList[dartx.get](dart.notNull(otherStart) + dart.notNull(i)), E));
           }
         } else {
           for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
             this.set(dart.notNull(start) + dart.notNull(i), dart.as(otherList[dartx.get](dart.notNull(otherStart) + dart.notNull(i)), E));
           }
         }
       }
       replaceRange(start, end, newContents) {
         dart.as(newContents, core.Iterable$(E));
         core.RangeError.checkValidRange(start, end, this.length);
         if (!dart.is(newContents, _internal.EfficientLength)) {
           newContents = newContents[dartx.toList]();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
-        let insertLength = newContents.length;
+        let insertLength = newContents[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 newLength = dart.notNull(this.length) - dart.notNull(delta);
           this.setRange(start, insertEnd, newContents);
           if (delta != 0) {
             this.setRange(insertEnd, newLength, this, end);
             this.length = newLength;
           }
         } else {
@@ skipping 36 matching lines @@
         }
         for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           if (dart.equals(this.get(i), element)) {
             return i;
           }
         }
         return -1;
       }
       insert(index, element) {
         dart.as(element, E);
-        core.RangeError.checkValueInInterval(index, 0, this.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
         if (index == this.length) {
           this.add(element);
           return;
         }
         if (!(typeof index == 'number'))
           throw new core.ArgumentError(index);
         this.length = dart.notNull(this.length) + 1;
         this.setRange(dart.notNull(index) + 1, this.length, this, index);
         this.set(index, element);
       }
       removeAt(index) {
         let result = this.get(index);
         this.setRange(index, dart.notNull(this.length) - 1, this, dart.notNull(index) + 1);
-        this.length = dart.notNull(this.length) - 1;
+        this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
         return result;
       }
       insertAll(index, iterable) {
         dart.as(iterable, core.Iterable$(E));
-        core.RangeError.checkValueInInterval(index, 0, this.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
         if (dart.is(iterable, _internal.EfficientLength)) {
           iterable = iterable[dartx.toList]();
         }
-        let insertionLength = iterable.length;
+        let insertionLength = iterable[dartx.length];
         this.length = dart.notNull(this.length) + dart.notNull(insertionLength);
         this.setRange(dart.notNull(index) + dart.notNull(insertionLength), this.length, this, index);
         this.setAll(index, iterable);
       }
       setAll(index, iterable) {
         dart.as(iterable, core.Iterable$(E));
         if (dart.is(iterable, core.List)) {
-          this.setRange(index, dart.notNull(index) + dart.notNull(iterable.length), iterable);
+          this.setRange(index, dart.notNull(index) + dart.notNull(iterable[dartx.length]), iterable);
         } else {
           for (let element of iterable) {
             this.set((() => {
               let x = index;
               index = dart.notNull(x) + 1;
               return x;
             })(), element);
           }
         }
       }
@@ skipping 146 matching lines @@
         dart.as(ifAbsent, dart.functionType(V, []));
         if (dart.notNull(this.keys[dartx.contains](key))) {
           return this.get(key);
         }
         return this.set(key, ifAbsent());
       }
       containsKey(key) {
         return this.keys[dartx.contains](key);
       }
       get length() {
-        return this.keys.length;
+        return this.keys[dartx.length];
       }
       get isEmpty() {
         return this.keys[dartx.isEmpty];
       }
       get isNotEmpty() {
         return this.keys[dartx.isNotEmpty];
       }
       get values() {
         return new (_MapBaseValueIterable$(V))(this);
       }
@@ skipping 245 matching lines @@
     }
     static forEach(map, f) {
       for (let k of map.keys) {
         dart.dcall(f, k, map.get(k));
       }
     }
     static getValues(map) {
       return map.keys[dartx.map](dart.fn(key => map.get(key)));
     }
     static length(map) {
-      return map.keys.length;
+      return map.keys[dartx.length];
     }
     static isEmpty(map) {
       return map.keys[dartx.isEmpty];
     }
     static isNotEmpty(map) {
       return map.keys[dartx.isNotEmpty];
     }
     static mapToString(m) {
       if (dart.notNull(IterableBase._isToStringVisiting(m))) {
         return '{...}';
@@ skipping 395 matching lines @@
         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] = core.List$(E).new(initialCapacity);
       }
       static from(elements) {
         if (dart.is(elements, core.List)) {
-          let length = elements.length;
+          let length = elements[dartx.length];
           let queue = new (ListQueue$(E))(dart.notNull(length) + 1);
-          dart.assert(dart.notNull(queue[_table].length) > dart.notNull(length));
+          dart.assert(dart.notNull(queue[_table][dartx.length]) > dart.notNull(length));
           let sourceList = elements;
           queue[_table][dartx.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;
+            capacity = elements[dartx.length];
           }
           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$(E))(this);
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [E]));
         let modificationCount = this[_modificationCount];
-        for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table].length) - 1) {
+        for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) {
           action(this[_table][dartx.get](i));
           this[_checkModification](modificationCount);
         }
       }
       get isEmpty() {
         return this[_head] == this[_tail];
       }
       get length() {
-        return dart.notNull(this[_tail]) - dart.notNull(this[_head]) & dart.notNull(this[_table].length) - 1;
+        return dart.notNull(this[_tail]) - dart.notNull(this[_head]) & dart.notNull(this[_table][dartx.length]) - 1;
       }
       get first() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         return this[_table][dartx.get](this[_head]);
       }
       get last() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
-        return this[_table][dartx.get](dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table].length) - 1);
+        return this[_table][dartx.get](dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1);
       }
       get single() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         if (dart.notNull(this.length) > 1)
           throw _internal.IterableElementError.tooMany();
         return this[_table][dartx.get](this[_head]);
       }
       elementAt(index) {
         core.RangeError.checkValidIndex(index, this);
-        return this[_table][dartx.get](dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table].length) - 1);
+        return this[_table][dartx.get](dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1);
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = null;
         if (dart.notNull(growable)) {
           list = core.List$(E).new();
-          list.length = this.length;
+          list[dartx.length] = this.length;
         } else {
           list = core.List$(E).new(this.length);
         }
         this[_writeToList](list);
         return list;
       }
       add(element) {
         dart.as(element, E);
         this[_add](element);
       }
       addAll(elements) {
         dart.as(elements, core.Iterable$(E));
         if (dart.is(elements, core.List)) {
           let list = dart.as(elements, core.List);
-          let addCount = list.length;
+          let addCount = list[dartx.length];
           let length = this.length;
-          if (dart.notNull(length) + dart.notNull(addCount) >= dart.notNull(this[_table].length)) {
+          if (dart.notNull(length) + dart.notNull(addCount) >= dart.notNull(this[_table][dartx.length])) {
             this[_preGrow](dart.notNull(length) + dart.notNull(addCount));
             this[_table][dartx.setRange](length, dart.notNull(length) + dart.notNull(addCount), dart.as(list, core.Iterable$(E)), 0);
             this[_tail] = dart.notNull(this[_tail]) + dart.notNull(addCount);
           } else {
-            let endSpace = dart.notNull(this[_table].length) - dart.notNull(this[_tail]);
+            let endSpace = dart.notNull(this[_table][dartx.length]) - dart.notNull(this[_tail]);
             if (dart.notNull(addCount) < dart.notNull(endSpace)) {
               this[_table][dartx.setRange](this[_tail], dart.notNull(this[_tail]) + dart.notNull(addCount), dart.as(list, core.Iterable$(E)), 0);
               this[_tail] = dart.notNull(this[_tail]) + dart.notNull(addCount);
             } else {
               let preSpace = dart.notNull(addCount) - dart.notNull(endSpace);
               this[_table][dartx.setRange](this[_tail], dart.notNull(this[_tail]) + dart.notNull(endSpace), dart.as(list, core.Iterable$(E)), 0);
               this[_table][dartx.setRange](0, preSpace, dart.as(list, core.Iterable$(E)), endSpace);
               this[_tail] = preSpace;
             }
           }
           this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         } else {
           for (let element of elements)
             this[_add](element);
         }
       }
       remove(object) {
-        for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table].length) - 1) {
+        for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) {
           let element = this[_table][dartx.get](i);
           if (dart.equals(element, object)) {
             this[_remove](i);
             this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
             return true;
           }
         }
         return false;
       }
       [_filterWhere](test, removeMatching) {
         dart.as(test, dart.functionType(core.bool, [E]));
         let index = this[_head];
         let modificationCount = this[_modificationCount];
         let i = this[_head];
         while (i != this[_tail]) {
           let element = this[_table][dartx.get](i);
           let remove = core.identical(removeMatching, test(element));
           this[_checkModification](modificationCount);
           if (dart.notNull(remove)) {
             i = this[_remove](i);
             modificationCount = this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
           } else {
-            i = dart.notNull(i) + 1 & dart.notNull(this[_table].length) - 1;
+            i = dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1;
           }
         }
       }
       removeWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, true);
       }
       retainWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, false);
       }
       clear() {
         if (this[_head] != this[_tail]) {
-          for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table].length) - 1) {
+          for (let i = this[_head]; i != this[_tail]; i = dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) {
             this[_table][dartx.set](i, null);
           }
           this[_head] = this[_tail] = 0;
           this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         }
       }
       toString() {
         return IterableBase.iterableToFullString(this, "{", "}");
       }
       addLast(element) {
         dart.as(element, E);
         this[_add](element);
       }
       addFirst(element) {
         dart.as(element, E);
-        this[_head] = dart.notNull(this[_head]) - 1 & dart.notNull(this[_table].length) - 1;
+        this[_head] = dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][dartx.length]) - 1;
         this[_table][dartx.set](this[_head], element);
         if (this[_head] == this[_tail])
           this[_grow]();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
       removeFirst() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         let result = this[_table][dartx.get](this[_head]);
         this[_table][dartx.set](this[_head], null);
-        this[_head] = dart.notNull(this[_head]) + 1 & dart.notNull(this[_table].length) - 1;
+        this[_head] = dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][dartx.length]) - 1;
         return result;
       }
       removeLast() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
-        this[_tail] = dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table].length) - 1;
+        this[_tail] = dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1;
         let result = this[_table][dartx.get](this[_tail]);
         this[_table][dartx.set](this[_tail], null);
         return result;
       }
       static _isPowerOf2(number) {
         return (dart.notNull(number) & dart.notNull(number) - 1) == 0;
       }
       static _nextPowerOf2(number) {
         dart.assert(dart.notNull(number) > 0);
         number = (dart.notNull(number) << 1) - 1;
         for (;;) {
           let nextNumber = dart.notNull(number) & dart.notNull(number) - 1;
           if (nextNumber == 0)
             return number;
           number = nextNumber;
         }
       }
       [_checkModification](expectedModificationCount) {
         if (expectedModificationCount != this[_modificationCount]) {
           throw new core.ConcurrentModificationError(this);
         }
       }
       [_add](element) {
         dart.as(element, E);
         this[_table][dartx.set](this[_tail], element);
-        this[_tail] = dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table].length) - 1;
+        this[_tail] = dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][dartx.length]) - 1;
         if (this[_head] == this[_tail])
           this[_grow]();
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
       }
       [_remove](offset) {
-        let mask = dart.notNull(this[_table].length) - 1;
+        let mask = dart.notNull(this[_table][dartx.length]) - 1;
         let startDistance = dart.notNull(offset) - dart.notNull(this[_head]) & dart.notNull(mask);
         let endDistance = dart.notNull(this[_tail]) - dart.notNull(offset) & dart.notNull(mask);
         if (dart.notNull(startDistance) < dart.notNull(endDistance)) {
           let i = offset;
           while (i != this[_head]) {
             let prevOffset = dart.notNull(i) - 1 & dart.notNull(mask);
             this[_table][dartx.set](i, this[_table][dartx.get](prevOffset));
             i = prevOffset;
           }
           this[_table][dartx.set](this[_head], null);
           this[_head] = dart.notNull(this[_head]) + 1 & dart.notNull(mask);
           return dart.notNull(offset) + 1 & dart.notNull(mask);
         } else {
           this[_tail] = dart.notNull(this[_tail]) - 1 & dart.notNull(mask);
           let i = offset;
           while (i != this[_tail]) {
             let nextOffset = dart.notNull(i) + 1 & dart.notNull(mask);
             this[_table][dartx.set](i, this[_table][dartx.get](nextOffset));
             i = nextOffset;
           }
           this[_table][dartx.set](this[_tail], null);
           return offset;
         }
       }
       [_grow]() {
-        let newTable = core.List$(E).new(dart.notNull(this[_table].length) * 2);
-        let split = dart.notNull(this[_table].length) - dart.notNull(this[_head]);
+        let newTable = core.List$(E).new(dart.notNull(this[_table][dartx.length]) * 2);
+        let split = dart.notNull(this[_table][dartx.length]) - dart.notNull(this[_head]);
         newTable[dartx.setRange](0, split, this[_table], this[_head]);
         newTable[dartx.setRange](split, dart.notNull(split) + dart.notNull(this[_head]), this[_table], 0);
         this[_head] = 0;
-        this[_tail] = this[_table].length;
+        this[_tail] = this[_table][dartx.length];
         this[_table] = newTable;
       }
       [_writeToList](target) {
         dart.as(target, core.List$(E));
-        dart.assert(dart.notNull(target.length) >= dart.notNull(this.length));
+        dart.assert(dart.notNull(target[dartx.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[dartx.setRange](0, length, this[_table], this[_head]);
           return length;
         } else {
-          let firstPartSize = dart.notNull(this[_table].length) - dart.notNull(this[_head]);
+          let firstPartSize = dart.notNull(this[_table][dartx.length]) - dart.notNull(this[_head]);
           target[dartx.setRange](0, firstPartSize, this[_table], this[_head]);
           target[dartx.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) + (dart.notNull(newElementCount) >> 1);
         let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
         let newTable = core.List$(E).new(newCapacity);
@@ skipping 66 matching lines @@
       get current() {
         return this[_current];
       }
       moveNext() {
         this[_queue][_checkModification](this[_modificationCount]);
         if (this[_position] == this[_end]) {
           this[_current] = null;
           return false;
         }
         this[_current] = dart.as(this[_queue][_table][dartx.get](this[_position]), E);
-        this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table].length) - 1;
+        this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][dartx.length]) - 1;
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_ListQueueIterator, {
       constructors: () => ({_ListQueueIterator: [_ListQueueIterator$(E), [ListQueue]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _ListQueueIterator;
   });
@@ skipping 993 matching lines @@
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_keys] = null;
           this[_length] = 0;
         }
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
         let keys = this[_computeKeys]();
-        for (let i = 0, length = keys.length; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
+        for (let i = 0, length = keys[dartx.length]; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let key = keys[i];
           action(dart.as(key, K), this.get(key));
           if (keys !== this[_keys]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       [_computeKeys]() {
         if (this[_keys] != null)
           return this[_keys];
@@ skipping 1716 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;
 });