refactor emitMemberName to be used more consistently

lib/runtime/dart/collection.js

 var collection;
 (function(exports) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
         super.UnmodifiableListBase();
       }
@@ skipping 85 matching lines @@
     dart.defineNamedConstructor(HashMap, 'from');
     dart.defineNamedConstructor(HashMap, 'fromIterable');
     dart.defineNamedConstructor(HashMap, 'fromIterables');
     return HashMap;
   });
   let HashMap = HashMap$();
   let _newSet = Symbol('_newSet');
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       get [core.$isEmpty]() {
-        return this.length == 0;
+        return this[core.$length] == 0;
       }
       get [core.$isNotEmpty]() {
-        return this.length != 0;
+        return this[core.$length] != 0;
       }
       clear() {
-        this.removeAll(this.toList());
+        this.removeAll(this[core.$toList]());
       }
       addAll(elements) {
         for (let element of elements)
           this.add(element);
       }
       removeAll(elements) {
         for (let element of elements)
           this.remove(element);
       }
       retainAll(elements) {
-        let toRemove = this.toSet();
+        let toRemove = this[core.$toSet]();
         for (let o of elements) {
           toRemove.remove(o);
         }
         this.removeAll(toRemove);
       }
       removeWhere(test) {
         let toRemove = new core.List.from([]);
         for (let element of this) {
           if (test(element))
             toRemove[core.$add](element);
         }
         this.removeAll(toRemove);
       }
       retainWhere(test) {
         let toRemove = new core.List.from([]);
         for (let element of this) {
           if (!dart.notNull(test(element)))
             toRemove[core.$add](element);
         }
         this.removeAll(toRemove);
       }
       containsAll(other) {
         for (let o of other) {
-          if (!dart.notNull(this.contains(o)))
+          if (!dart.notNull(this[core.$contains](o)))
             return false;
         }
         return true;
       }
       union(other) {
-        let _ = this.toSet();
+        let _ = this[core.$toSet]();
         _.addAll(other);
         return _;
       }
       intersection(other) {
-        let result = this.toSet();
+        let result = this[core.$toSet]();
         for (let element of this) {
           if (!dart.notNull(other[core.$contains](element)))
             result.remove(element);
         }
         return result;
       }
       difference(other) {
-        let result = this.toSet();
+        let result = this[core.$toSet]();
         for (let element of this) {
           if (other[core.$contains](element))
             result.remove(element);
         }
         return result;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = growable ? (() => {
           let _ = new (core.List$(E))();
-          _[core.$length] = this.length;
+          _[core.$length] = this[core.$length];
           return _;
-        }).bind(this)() : new (core.List$(E))(this.length);
+        }).bind(this)() : new (core.List$(E))(this[core.$length]);
         let i = 0;
         for (let element of this)
           result[core.$set]((() => {
             let x$ = i;
             i = dart.notNull(x$) + 1;
             return x$;
           })(), element);
         return result;
       }
       [core.$map](f) {
         return new (_internal.EfficientLengthMappedIterable$(E, dart.dynamic))(this, f);
       }
       get [core.$single]() {
-        if (dart.notNull(this.length) > 1)
+        if (dart.notNull(this[core.$length]) > 1)
           throw _internal.IterableElementError.tooMany();
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         return result;
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
       [core.$where](f) {
         return new (_internal.WhereIterable$(E))(this, f);
@@ skipping 62 matching lines @@
       [core.$takeWhile](test) {
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let result = null;
         do {
           result = dart.as(it.current, E);
         } while (it.moveNext());
         return result;
       }
       [core.$firstWhere](test, opts) {
@@ skipping 215 matching lines @@
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return new core.List$(E).from(this, {growable: growable});
       }
       [core.$toSet]() {
         return new core.Set$(E).from(this);
       }
       get [core.$length]() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
-        let it = this.iterator;
+        let it = this[core.$iterator];
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get [core.$isEmpty]() {
-        return !dart.notNull(this.iterator.moveNext());
+        return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
-        return !dart.notNull(this.isEmpty);
+        return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
         return new (_internal.TakeIterable$(E))(this, n);
       }
       [core.$takeWhile](test) {
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let result = null;
         do {
           result = dart.as(it.current, E);
         } while (it.moveNext());
         return result;
       }
       get [core.$single]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         if (it.moveNext())
           throw _internal.IterableElementError.tooMany();
         return result;
       }
       [core.$firstWhere](test, opts) {
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
         for (let element of this) {
@@ skipping 137 matching lines @@
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return new core.List$(E).from(this, {growable: growable});
       }
       [core.$toSet]() {
         return new core.Set$(E).from(this);
       }
       get [core.$length]() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
-        let it = this.iterator;
+        let it = this[core.$iterator];
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get [core.$isEmpty]() {
-        return !dart.notNull(this.iterator.moveNext());
+        return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
-        return !dart.notNull(this.isEmpty);
+        return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
         return new (_internal.TakeIterable$(E))(this, n);
       }
       [core.$takeWhile](test) {
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
         return new (_internal.SkipIterable$(E))(this, n);
       }
       [core.$skipWhile](test) {
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         return dart.as(it.current, E);
       }
       get [core.$last]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
         let result = null;
         do {
           result = dart.as(it.current, E);
         } while (it.moveNext());
         return result;
       }
       get [core.$single]() {
-        let it = this.iterator;
+        let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext()))
           throw _internal.IterableElementError.noElement();
         let result = dart.as(it.current, E);
         if (it.moveNext())
           throw _internal.IterableElementError.tooMany();
         return result;
       }
       [core.$firstWhere](test, opts) {
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
         for (let element of this) {
@@ skipping 540 matching lines @@
       [core.$forEach](action) {
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           action(this[core.$get](i));
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       get [core.$isEmpty]() {
-        return this.length == 0;
+        return this[core.$length] == 0;
       }
       get [core.$isNotEmpty]() {
-        return !dart.notNull(this.isEmpty);
+        return !dart.notNull(this[core.$isEmpty]);
       }
       get [core.$first]() {
-        if (this.length == 0)
+        if (this[core.$length] == 0)
           throw _internal.IterableElementError.noElement();
         return this[core.$get](0);
       }
       get [core.$last]() {
-        if (this.length == 0)
+        if (this[core.$length] == 0)
           throw _internal.IterableElementError.noElement();
-        return this[core.$get](dart.notNull(this.length) - 1);
+        return this[core.$get](dart.notNull(this[core.$length]) - 1);
       }
       get [core.$single]() {
-        if (this.length == 0)
+        if (this[core.$length] == 0)
           throw _internal.IterableElementError.noElement();
-        if (dart.notNull(this.length) > 1)
+        if (dart.notNull(this[core.$length]) > 1)
           throw _internal.IterableElementError.tooMany();
         return this[core.$get](0);
       }
       [core.$contains](element) {
         let length = this[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           if (dart.equals(this[core.$get](i), element))
             return true;
           if (length != this[core.$length]) {
             throw new core.ConcurrentModificationError(this);
@@ skipping 70 matching lines @@
             throw new core.ConcurrentModificationError(this);
           }
         }
         if (matchFound)
           return match;
         throw _internal.IterableElementError.noElement();
       }
       [core.$join](separator) {
         if (separator === void 0)
           separator = "";
-        if (this.length == 0)
+        if (this[core.$length] == 0)
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return buffer.toString();
       }
       [core.$where](test) {
         return new (_internal.WhereIterable$(E))(this, test);
       }
       [core.$map](f) {
         return new _internal.MappedListIterable(this, f);
@@ skipping 35 matching lines @@
         return new (_internal.SubListIterable$(E))(this, 0, count);
       }
       [core.$takeWhile](test) {
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
           result = new (core.List$(E))();
-          result[core.$length] = this.length;
+          result[core.$length] = this[core.$length];
         } else {
-          result = new (core.List$(E))(this.length);
+          result = new (core.List$(E))(this[core.$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[core.$length]); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[core.$get](i));
         }
         return result;
       }
       [core.$toSet]() {
         let result = new (core.Set$(E))();
-        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[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$get](i));
         }
         return result;
       }
       [core.$add](element) {
         this[core.$set]((() => {
           let o$ = this, x$ = o$[core.$length];
           o$[core.$length] = dart.notNull(x$) + 1;
           return x$;
         }).bind(this)(), element);
@@ skipping 38 matching lines @@
         }
         if (retained[core.$length] != source[core.$length]) {
           source[core.$setRange](0, retained[core.$length], retained);
           source[core.$length] = retained[core.$length];
         }
       }
       [core.$clear]() {
         this[core.$length] = 0;
       }
       [core.$removeLast]() {
-        if (this.length == 0) {
+        if (this[core.$length] == 0) {
           throw _internal.IterableElementError.noElement();
         }
-        let result = this[core.$get](dart.notNull(this.length) - 1);
-        this.length = dart.notNull(this.length) - 1;
+        let result = this[core.$get](dart.notNull(this[core.$length]) - 1);
+        this[core.$length] = dart.notNull(this[core.$length]) - 1;
         return result;
       }
       [core.$sort](compare) {
         if (compare === void 0)
           compare = null;
         if (compare == null) {
           let defaultCompare = core.Comparable.compare;
           compare = defaultCompare;
         }
         _internal.Sort.sort(this, compare);
@@ skipping 30 matching lines @@
         }
         return result;
       }
       [core.$getRange](start, end) {
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         return new (_internal.SubListIterable$(E))(this, start, end);
       }
       [core.$removeRange](start, end) {
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         let length = dart.notNull(end) - dart.notNull(start);
-        this.setRange(start, dart.notNull(this[core.$length]) - dart.notNull(length), this, end);
+        this[core.$setRange](start, dart.notNull(this[core.$length]) - dart.notNull(length), this, end);
         let o$ = this;
         o$[core.$length] = dart.notNull(o$[core.$length]) - dart.notNull(length);
       }
       [core.$fillRange](start, end, fill) {
         if (fill === void 0)
           fill = null;
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           this[core.$set](i, fill);
         }
@@ skipping 83 matching lines @@
           }
         }
         for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
           if (dart.equals(this[core.$get](i), element)) {
             return i;
           }
         }
         return -1;
       }
       [core.$insert](index, element) {
-        core.RangeError.checkValueInInterval(index, 0, this.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, this[core.$length], "index");
         if (index == this[core.$length]) {
-          this.add(element);
+          this[core.$add](element);
           return;
         }
         if (!(typeof index == 'number'))
           throw new core.ArgumentError(index);
         let o$ = this;
         o$[core.$length] = dart.notNull(o$[core.$length]) + 1;
-        this.setRange(dart.notNull(index) + 1, this[core.$length], this, index);
+        this[core.$setRange](dart.notNull(index) + 1, this[core.$length], this, index);
         this[core.$set](index, element);
       }
       [core.$removeAt](index) {
         let result = this[core.$get](index);
-        this.setRange(index, dart.notNull(this[core.$length]) - 1, this, dart.notNull(index) + 1);
-        this.length = dart.notNull(this.length) - 1;
+        this[core.$setRange](index, dart.notNull(this[core.$length]) - 1, this, dart.notNull(index) + 1);
+        this[core.$length] = dart.notNull(this[core.$length]) - 1;
         return result;
       }
       [core.$insertAll](index, iterable) {
-        core.RangeError.checkValueInInterval(index, 0, this.length, "index");
+        core.RangeError.checkValueInInterval(index, 0, this[core.$length], "index");
         if (dart.is(iterable, _internal.EfficientLength)) {
           iterable = iterable[core.$toList]();
         }
         let insertionLength = iterable[core.$length];
         let o$ = this;
         o$[core.$length] = dart.notNull(o$[core.$length]) + dart.notNull(insertionLength);
-        this.setRange(dart.notNull(index) + dart.notNull(insertionLength), this[core.$length], this, index);
-        this.setAll(index, iterable);
+        this[core.$setRange](dart.notNull(index) + dart.notNull(insertionLength), this[core.$length], this, index);
+        this[core.$setAll](index, iterable);
       }
       [core.$setAll](index, iterable) {
         if (dart.is(iterable, core.List)) {
-          this.setRange(index, dart.notNull(index) + dart.notNull(iterable[core.$length]), iterable);
+          this[core.$setRange](index, dart.notNull(index) + dart.notNull(iterable[core.$length]), iterable);
         } else {
           for (let element of iterable) {
             this[core.$set]((() => {
               let x$ = index;
               index = dart.notNull(x$) + 1;
               return x$;
             })(), element);
           }
         }
       }
@@ skipping 621 matching lines @@
         return this[_table][core.$get](this[_head]);
       }
       get [core.$last]() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
         return this[_table][core.$get](dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][core.$length]) - 1);
       }
       get [core.$single]() {
         if (this[_head] == this[_tail])
           throw _internal.IterableElementError.noElement();
-        if (dart.notNull(this.length) > 1)
+        if (dart.notNull(this[core.$length]) > 1)
           throw _internal.IterableElementError.tooMany();
         return this[_table][core.$get](this[_head]);
       }
       [core.$elementAt](index) {
         core.RangeError.checkValidIndex(index, this);
         return this[_table][core.$get](dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][core.$length]) - 1);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = null;
         if (growable) {
           list = new (core.List$(E))();
-          list[core.$length] = this.length;
+          list[core.$length] = this[core.$length];
         } else {
-          list = new (core.List$(E))(this.length);
+          list = new (core.List$(E))(this[core.$length]);
         }
         this[_writeToList](list);
         return list;
       }
       add(element) {
         this[_add](element);
       }
       addAll(elements) {
         if (dart.is(elements, core.List)) {
           let list = dart.as(elements, core.List);
@@ skipping 148 matching lines @@
       [_grow]() {
         let newTable = new (core.List$(E))(dart.notNull(this[_table][core.$length]) * 2);
         let split = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
         newTable[core.$setRange](0, split, this[_table], this[_head]);
         newTable[core.$setRange](split, dart.notNull(split) + dart.notNull(this[_head]), this[_table], 0);
         this[_head] = 0;
         this[_tail] = this[_table][core.$length];
         this[_table] = newTable;
       }
       [_writeToList](target) {
-        dart.assert(dart.notNull(target[core.$length]) >= dart.notNull(this.length));
+        dart.assert(dart.notNull(target[core.$length]) >= dart.notNull(this[core.$length]));
         if (dart.notNull(this[_head]) <= dart.notNull(this[_tail])) {
           let length = dart.notNull(this[_tail]) - dart.notNull(this[_head]);
           target[core.$setRange](0, length, this[_table], this[_head]);
           return length;
         } else {
           let firstPartSize = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
           target[core.$setRange](0, firstPartSize, this[_table], this[_head]);
           target[core.$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));
+        dart.assert(dart.notNull(newElementCount) >= dart.notNull(this[core.$length]));
         newElementCount = dart.notNull(newElementCount) + (dart.notNull(newElementCount) >> 1);
         let newCapacity = ListQueue[_nextPowerOf2](newElementCount);
         let newTable = new (core.List$(E))(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
@@ skipping 971 matching lines @@
           let value = dart.as(_HashMap[_getTableEntry](table, key), V);
           _HashMap[_deleteTableEntry](table, key);
           this[_length] = dart.notNull(this[_length]) - 1;
           this[_keys] = null;
           return value;
         } else {
           return null;
         }
       }
       static [_isStringKey](key) {
-        return dart.notNull(typeof key == 'string') && dart.notNull(!dart.equals(key, '__proto__'));
+        return typeof key == 'string' && dart.notNull(!dart.equals(key, '__proto__'));
       }
       static [_isNumericKey](key) {
-        return dart.notNull(dart.is(key, core.num)) && (key & 0x3ffffff) === key;
+        return dart.is(key, core.num) && (key & 0x3ffffff) === key;
       }
       [_computeHashCode](key) {
         return key.hashCode & 0x3ffffff;
       }
       static [_hasTableEntry](table, key) {
         let entry = table[key];
         return entry != null;
       }
       static [_getTableEntry](table, key) {
         let entry = table[key];
@@ skipping 102 matching lines @@
     return _CustomHashMap;
   });
   let _CustomHashMap = _CustomHashMap$();
   let HashMapKeyIterable$ = dart.generic(function(E) {
     class HashMapKeyIterable extends IterableBase$(E) {
       HashMapKeyIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
       get [core.$length]() {
-        return dart.as(dart.dload(this[_map], '_length'), core.int);
+        return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get [core.$isEmpty]() {
-        return dart.equals(dart.dload(this[_map], '_length'), 0);
+        return dart.equals(dart.dload(this[_map], _length), 0);
       }
       get [core.$iterator]() {
-        return new (HashMapKeyIterator$(E))(this[_map], dart.as(dart.dsend(this[_map], '_computeKeys'), core.List));
+        return new (HashMapKeyIterator$(E))(this[_map], dart.as(dart.dsend(this[_map], _computeKeys), core.List));
       }
       [core.$contains](element) {
         return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       [core.$forEach](f) {
-        let keys = dart.as(dart.dsend(this[_map], '_computeKeys'), core.List);
+        let keys = dart.as(dart.dsend(this[_map], _computeKeys), core.List);
         for (let i = 0, length = keys.length; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(dart.as(keys[i], E));
-          if (keys !== dart.dload(this[_map], '_keys')) {
+          if (keys !== dart.dload(this[_map], _keys)) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
         }
       }
     }
     HashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$();
   let _offset = Symbol('_offset');
   let HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map$, keys$) {
         this[_map] = map$;
         this[_keys] = keys$;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let keys = this[_keys];
         let offset = this[_offset];
-        if (keys !== dart.dload(this[_map], '_keys')) {
+        if (keys !== dart.dload(this[_map], _keys)) {
           throw new core.ConcurrentModificationError(this[_map]);
         } else if (dart.notNull(offset) >= keys.length) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(keys[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
@@ skipping 221 matching lines @@
         if (next == null) {
           dart.assert(dart.equals(cell, this[_last]));
           this[_last] = previous;
         } else {
           next[_previous] = previous;
         }
         this[_length] = dart.notNull(this[_length]) - 1;
         this[_modified]();
       }
       static [_isStringKey](key) {
-        return dart.notNull(typeof key == 'string') && dart.notNull(!dart.equals(key, '__proto__'));
+        return typeof key == 'string' && dart.notNull(!dart.equals(key, '__proto__'));
       }
       static [_isNumericKey](key) {
-        return dart.notNull(dart.is(key, core.num)) && (key & 0x3ffffff) === key;
+        return dart.is(key, core.num) && (key & 0x3ffffff) === key;
       }
       [_computeHashCode](key) {
         return key.hashCode & 0x3ffffff;
       }
       static [_getTableEntry](table, key) {
         return table[key];
       }
       static [_setTableEntry](table, key, value) {
         dart.assert(value != null);
         table[key] = value;
@@ skipping 103 matching lines @@
       this[_previous] = null;
     }
   }
   let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
       LinkedHashMapKeyIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
       get [core.$length]() {
-        return dart.as(dart.dload(this[_map], '_length'), core.int);
+        return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get [core.$isEmpty]() {
-        return dart.equals(dart.dload(this[_map], '_length'), 0);
+        return dart.equals(dart.dload(this[_map], _length), 0);
       }
       get [core.$iterator]() {
-        return new (LinkedHashMapKeyIterator$(E))(this[_map], dart.as(dart.dload(this[_map], '_modifications'), core.int));
+        return new (LinkedHashMapKeyIterator$(E))(this[_map], dart.as(dart.dload(this[_map], _modifications), core.int));
       }
       [core.$contains](element) {
         return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       [core.$forEach](f) {
-        let cell = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
-        let modifications = dart.as(dart.dload(this[_map], '_modifications'), core.int);
+        let cell = dart.as(dart.dload(this[_map], _first), LinkedHashMapCell);
+        let modifications = dart.as(dart.dload(this[_map], _modifications), core.int);
         while (cell != null) {
           f(dart.as(cell[_key], E));
-          if (!dart.equals(modifications, dart.dload(this[_map], '_modifications'))) {
+          if (!dart.equals(modifications, dart.dload(this[_map], _modifications))) {
             throw new core.ConcurrentModificationError(this[_map]);
           }
           cell = cell[_next];
         }
       }
     }
     LinkedHashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     return LinkedHashMapKeyIterable;
   });
   let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
   let _cell = Symbol('_cell');
   let LinkedHashMapKeyIterator$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map$, modifications$) {
         this[_map] = map$;
         this[_modifications] = modifications$;
         this[_cell] = null;
         this[_current] = null;
-        this[_cell] = dart.as(dart.dload(this[_map], '_first'), LinkedHashMapCell);
+        this[_cell] = dart.as(dart.dload(this[_map], _first), LinkedHashMapCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
-        if (!dart.equals(this[_modifications], dart.dload(this[_map], '_modifications'))) {
+        if (!dart.equals(this[_modifications], dart.dload(this[_map], _modifications))) {
           throw new core.ConcurrentModificationError(this[_map]);
         } else if (this[_cell] == null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_key], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
@@ skipping 24 matching lines @@
       get [core.$iterator]() {
         return new (HashSetIterator$(E))(this, this[_computeElements]());
       }
       get [core.$length]() {
         return this[_length];
       }
       get [core.$isEmpty]() {
         return this[_length] == 0;
       }
       get [core.$isNotEmpty]() {
-        return !dart.notNull(this.isEmpty);
+        return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$contains](object) {
         if (_HashSet[_isStringElement](object)) {
           let strings = this[_strings];
           return strings == null ? false : _HashSet[_hasTableEntry](strings, object);
         } else if (_HashSet[_isNumericElement](object)) {
           let nums = this[_nums];
           return nums == null ? false : _HashSet[_hasTableEntry](nums, object);
         } else {
           return this[_contains](object);
@@ skipping 142 matching lines @@
         if (dart.notNull(table != null) && dart.notNull(_HashSet[_hasTableEntry](table, element))) {
           _HashSet[_deleteTableEntry](table, element);
           this[_length] = dart.notNull(this[_length]) - 1;
           this[_elements] = null;
           return true;
         } else {
           return false;
         }
       }
       static [_isStringElement](element) {
-        return dart.notNull(typeof element == 'string') && dart.notNull(!dart.equals(element, '__proto__'));
+        return typeof element == 'string' && dart.notNull(!dart.equals(element, '__proto__'));
       }
       static [_isNumericElement](element) {
-        return dart.notNull(dart.is(element, core.num)) && (element & 0x3ffffff) === element;
+        return dart.is(element, core.num) && (element & 0x3ffffff) === element;
       }
       [_computeHashCode](element) {
         return element.hashCode & 0x3ffffff;
       }
       static [_hasTableEntry](table, key) {
         let entry = table[key];
         return entry != null;
       }
       static [_setTableEntry](table, key, value) {
         dart.assert(value != null);
@@ skipping 105 matching lines @@
         this[_elements] = elements$;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let elements = this[_elements];
         let offset = this[_offset];
-        if (elements !== dart.dload(this[_set], '_elements')) {
+        if (elements !== dart.dload(this[_set], _elements)) {
           throw new core.ConcurrentModificationError(this[_set]);
         } else if (dart.notNull(offset) >= elements.length) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(elements[offset], E);
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
@@ skipping 24 matching lines @@
       get [core.$iterator]() {
         return dart.as(new LinkedHashSetIterator(this, this[_modifications]), core.Iterator$(E));
       }
       get [core.$length]() {
         return this[_length];
       }
       get [core.$isEmpty]() {
         return this[_length] == 0;
       }
       get [core.$isNotEmpty]() {
-        return !dart.notNull(this.isEmpty);
+        return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$contains](object) {
         if (_LinkedHashSet[_isStringElement](object)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
           let cell = dart.as(_LinkedHashSet[_getTableEntry](strings, object), LinkedHashSetCell);
           return cell != null;
         } else if (_LinkedHashSet[_isNumericElement](object)) {
           let nums = this[_nums];
@@ skipping 20 matching lines @@
         }
       }
       [_lookup](object) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0)
           return null;
-        return dart.as(dart.dload(bucket[core.$get](index), '_element'), E);
+        return dart.as(dart.dload(bucket[core.$get](index), _element), E);
       }
       [core.$forEach](action) {
         let cell = this[_first];
         let modifications = this[_modifications];
         while (cell != null) {
           action(dart.as(cell[_element], E));
           if (modifications != this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           cell = cell[_next];
@@ skipping 136 matching lines @@
         if (next == null) {
           dart.assert(dart.equals(cell, this[_last]));
           this[_last] = previous;
         } else {
           next[_previous] = previous;
         }
         this[_length] = dart.notNull(this[_length]) - 1;
         this[_modified]();
       }
       static [_isStringElement](element) {
-        return dart.notNull(typeof element == 'string') && dart.notNull(!dart.equals(element, '__proto__'));
+        return typeof element == 'string' && dart.notNull(!dart.equals(element, '__proto__'));
       }
       static [_isNumericElement](element) {
-        return dart.notNull(dart.is(element, core.num)) && (element & 0x3ffffff) === element;
+        return dart.is(element, core.num) && (element & 0x3ffffff) === element;
       }
       [_computeHashCode](element) {
         return element.hashCode & 0x3ffffff;
       }
       static [_getTableEntry](table, key) {
         return table[key];
       }
       static [_setTableEntry](table, key, value) {
         dart.assert(value != null);
         table[key] = value;
@@ skipping 119 matching lines @@
       this[_previous] = null;
     }
   }
   let LinkedHashSetIterator$ = dart.generic(function(E) {
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set$, modifications$) {
         this[_set] = set$;
         this[_modifications] = modifications$;
         this[_cell] = null;
         this[_current] = null;
-        this[_cell] = dart.as(dart.dload(this[_set], '_first'), LinkedHashSetCell);
+        this[_cell] = dart.as(dart.dload(this[_set], _first), LinkedHashSetCell);
       }
       get current() {
         return this[_current];
       }
       moveNext() {
-        if (!dart.equals(this[_modifications], dart.dload(this[_set], '_modifications'))) {
+        if (!dart.equals(this[_modifications], dart.dload(this[_set], _modifications))) {
           throw new core.ConcurrentModificationError(this[_set]);
         } else if (this[_cell] == null) {
           this[_current] = null;
           return false;
         } else {
           this[_current] = dart.as(this[_cell][_element], E);
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
@@ skipping 61 matching lines @@
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
 })(collection || (collection = {}));