fix for static methods and names banned in strict mode

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 592 matching lines @@
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase.iterableToShortString(this, '(', ')');
       }
     }
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$(dart.dynamic);
-  let _isToStringVisiting$ = Symbol('_isToStringVisiting');
-  let _iterablePartsToStrings$ = Symbol('_iterablePartsToStrings');
+  let _isToStringVisiting = Symbol('_isToStringVisiting');
+  let _toStringVisiting = Symbol('_toStringVisiting');
+  let _iterablePartsToStrings = Symbol('_iterablePartsToStrings');
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       map(f) {
         return new _internal.MappedIterable(this, f);
       }
       where(f) {
         return new _internal.WhereIterable(this, f);
       }
@@ skipping 171 matching lines @@
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index === elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
-        return iterableToShortString(this, '(', ')');
+        return IterableBase.iterableToShortString(this, '(', ')');
       }
       static iterableToShortString(iterable, leftDelimiter, rightDelimiter) {
         if (leftDelimiter === void 0)
           leftDelimiter = '(';
         if (rightDelimiter === void 0)
           rightDelimiter = ')';
-        if (_isToStringVisiting(iterable)) {
+        if (IterableBase[_isToStringVisiting](iterable)) {
           if (dart.notNull(dart.equals(leftDelimiter, "(")) && dart.notNull(dart.equals(rightDelimiter, ")"))) {
             return "(...)";
           }
           return `${leftDelimiter}...${rightDelimiter}`;
         }
         let parts = new List.from([]);
-        _toStringVisiting.add(iterable);
+        IterableBase[_toStringVisiting].add(iterable);
         try {
-          _iterablePartsToStrings(iterable, parts);
+          IterableBase[_iterablePartsToStrings](iterable, parts);
         } finally {
-          dart.assert(core.identical(_toStringVisiting.last, iterable));
-          _toStringVisiting.removeLast();
+          dart.assert(core.identical(IterableBase[_toStringVisiting].last, iterable));
+          IterableBase[_toStringVisiting].removeLast();
         }
         return ((_) => {
           _.writeAll(parts, ", ");
           _.write(rightDelimiter);
           return _;
         }).bind(this)(new core.StringBuffer(leftDelimiter)).toString();
       }
       static iterableToFullString(iterable, leftDelimiter, rightDelimiter) {
         if (leftDelimiter === void 0)
           leftDelimiter = '(';
         if (rightDelimiter === void 0)
           rightDelimiter = ')';
-        if (_isToStringVisiting(iterable)) {
+        if (IterableBase[_isToStringVisiting](iterable)) {
           return `${leftDelimiter}...${rightDelimiter}`;
         }
         let buffer = new core.StringBuffer(leftDelimiter);
-        _toStringVisiting.add(iterable);
+        IterableBase[_toStringVisiting].add(iterable);
         try {
           buffer.writeAll(iterable, ", ");
         } finally {
-          dart.assert(core.identical(_toStringVisiting.last, iterable));
-          _toStringVisiting.removeLast();
+          dart.assert(core.identical(IterableBase[_toStringVisiting].last, iterable));
+          IterableBase[_toStringVisiting].removeLast();
         }
         buffer.write(rightDelimiter);
         return buffer.toString();
       }
-      static [_isToStringVisiting$](o) {
-        for (let i = 0; dart.notNull(i) < dart.notNull(_toStringVisiting.length); i = dart.notNull(i) + 1) {
-          if (core.identical(o, _toStringVisiting.get(i)))
+      static [_isToStringVisiting](o) {
+        for (let i = 0; dart.notNull(i) < dart.notNull(IterableBase[_toStringVisiting].length); i = dart.notNull(i) + 1) {
+          if (core.identical(o, IterableBase[_toStringVisiting].get(i)))
             return true;
         }
         return false;
       }
-      static [_iterablePartsToStrings$](iterable, parts) {
+      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.iterator;
         while (dart.notNull(length) < dart.notNull(LENGTH_LIMIT) || dart.notNull(count) < dart.notNull(HEAD_COUNT)) {
@@ skipping 67 matching lines @@
     }
     dart.defineLazyProperties(IterableBase, {
       get _toStringVisiting() {
         return new List.from([]);
       }
     });
     return IterableBase;
   });
   let IterableBase = IterableBase$(dart.dynamic);
   let _iterator = Symbol('_iterator');
+  let _NOT_MOVED_YET = Symbol('_NOT_MOVED_YET');
   let _state = Symbol('_state');
   let _move = Symbol('_move');
+  let _HAS_NEXT_AND_NEXT_IN_CURRENT = Symbol('_HAS_NEXT_AND_NEXT_IN_CURRENT');
+  let _NO_NEXT = Symbol('_NO_NEXT');
   let HasNextIterator$ = dart.generic(function(E) {
     class HasNextIterator extends core.Object {
       HasNextIterator(iterator$) {
         this[_iterator] = iterator$;
-        this[_state] = HasNextIterator._NOT_MOVED_YET;
+        this[_state] = HasNextIterator[_NOT_MOVED_YET];
       }
       get hasNext() {
-        if (this[_state] === HasNextIterator._NOT_MOVED_YET)
+        if (this[_state] === HasNextIterator[_NOT_MOVED_YET])
           this[_move]();
-        return this[_state] === HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT;
+        return this[_state] === HasNextIterator[_HAS_NEXT_AND_NEXT_IN_CURRENT];
       }
       next() {
         if (!dart.notNull(this.hasNext))
           throw new core.StateError("No more elements");
-        dart.assert(this[_state] === HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT);
+        dart.assert(this[_state] === HasNextIterator[_HAS_NEXT_AND_NEXT_IN_CURRENT]);
         let result = dart.as(this[_iterator].current, E);
         this[_move]();
         return result;
       }
       [_move]() {
         if (this[_iterator].moveNext()) {
-          this[_state] = HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT;
+          this[_state] = HasNextIterator[_HAS_NEXT_AND_NEXT_IN_CURRENT];
         } else {
-          this[_state] = HasNextIterator._NO_NEXT;
+          this[_state] = HasNextIterator[_NO_NEXT];
         }
       }
     }
     HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
     HasNextIterator._NO_NEXT = 1;
     HasNextIterator._NOT_MOVED_YET = 2;
     return HasNextIterator;
   });
   let HasNextIterator = HasNextIterator$(dart.dynamic);
+  let _literal = Symbol('_literal');
+  let _empty = Symbol('_empty');
   let LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
       LinkedHashMap(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey === null) {
           if (hashCode === null) {
             if (equals === null) {
               return new _LinkedHashMap();
@@ skipping 43 matching lines @@
         return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new _LinkedHashMap()), LinkedHashMap$(K, V));
       }
       LinkedHashMap$_empty() {
         return new _LinkedHashMap();
       }
     }
     dart.defineNamedConstructor(LinkedHashMap, 'identity');
     dart.defineNamedConstructor(LinkedHashMap, 'from');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterable');
     dart.defineNamedConstructor(LinkedHashMap, 'fromIterables');
-    dart.defineNamedConstructor(LinkedHashMap, '_literal');
-    dart.defineNamedConstructor(LinkedHashMap, '_empty');
+    dart.defineNamedConstructor(LinkedHashMap, _literal);
+    dart.defineNamedConstructor(LinkedHashMap, _empty);
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$(dart.dynamic, dart.dynamic);
   let LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
       LinkedHashSet(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey === null) {
@@ skipping 206 matching lines @@
       insertAfter(entry) {
         this[_list]._insertAfter(this, entry);
       }
       insertBefore(entry) {
         this[_list]._insertAfter(this[_previous], entry);
       }
     }
     return LinkedListEntry;
   });
   let LinkedListEntry = LinkedListEntry$(dart.dynamic);
-  let _filter$ = Symbol('_filter');
+  let _filter = Symbol('_filter');
   let ListMixin$ = dart.generic(function(E) {
     class ListMixin extends core.Object {
       get iterator() {
         return new _internal.ListIterator(this);
       }
       elementAt(index) {
         return this.get(index);
       }
       forEach(action) {
         let length = this.length;
@@ skipping 200 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           if (dart.equals(this.get(i), element)) {
             this.setRange(i, dart.notNull(this.length) - 1, this, dart.notNull(i) + 1);
             this.length = 1;
             return true;
           }
         }
         return false;
       }
       removeWhere(test) {
-        _filter(this, test, false);
+        ListMixin[_filter](this, test, false);
       }
       retainWhere(test) {
-        _filter(this, test, true);
+        ListMixin[_filter](this, test, true);
       }
-      static [_filter$](source, test, retainMatching) {
+      static [_filter](source, test, retainMatching) {
         let retained = new List.from([]);
         let length = source.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source.get(i);
           if (dart.dinvokef(test, element) === retainMatching) {
             retained.add(element);
           }
           if (length !== source.length) {
             throw new core.ConcurrentModificationError(source);
           }
@@ skipping 408 matching lines @@
     }
     return MapView;
   });
   let MapView = MapView$(dart.dynamic, dart.dynamic);
   let UnmodifiableMapView$ = dart.generic(function(K, V) {
     class UnmodifiableMapView extends dart.mixin(_UnmodifiableMapMixin$(K, V)) {
     }
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$(dart.dynamic, dart.dynamic);
-  let _toStringVisiting$ = Symbol('_toStringVisiting');
-  let _id$ = Symbol('_id');
+  let _id = Symbol('_id');
   let _fillMapWithMappedIterable = Symbol('_fillMapWithMappedIterable');
   let _fillMapWithIterables = Symbol('_fillMapWithIterables');
   class Maps extends core.Object {
     static containsValue(map, value) {
       for (let v of map.values) {
         if (dart.equals(value, v)) {
           return true;
         }
       }
       return false;
@@ skipping 35 matching lines @@
     }
     static isNotEmpty(map) {
       return map.keys.isNotEmpty;
     }
     static mapToString(m) {
       if (IterableBase._isToStringVisiting(m)) {
         return '{...}';
       }
       let result = new core.StringBuffer();
       try {
-        IterableBase[_toStringVisiting$].add(m);
+        IterableBase[_toStringVisiting].add(m);
         result.write('{');
         let first = true;
         m.forEach(((k, v) => {
           if (!dart.notNull(first)) {
             result.write(', ');
           }
           first = false;
           result.write(k);
           result.write(': ');
           result.write(v);
         }).bind(this));
         result.write('}');
       } finally {
-        dart.assert(core.identical(IterableBase[_toStringVisiting$].last, m));
-        IterableBase[_toStringVisiting$].removeLast();
+        dart.assert(core.identical(IterableBase[_toStringVisiting].last, m));
+        IterableBase[_toStringVisiting].removeLast();
       }
       return result.toString();
     }
-    static [_id$](x) {
+    static [_id](x) {
       return x;
     }
     static [_fillMapWithMappedIterable](map, iterable, key, value) {
       if (key === null)
-        key = _id;
+        key = Maps[_id];
       if (value === null)
-        value = _id;
+        value = Maps[_id];
       for (let element of iterable) {
         map.set(dart.dinvokef(key, element), dart.dinvokef(value, element));
       }
     }
     static [_fillMapWithIterables](map, keys, values) {
       let keyIterator = keys.iterator;
       let valueIterator = values.iterator;
       let hasNextKey = keyIterator.moveNext();
       let hasNextValue = valueIterator.moveNext();
       while (dart.notNull(hasNextKey) && dart.notNull(hasNextValue)) {
@@ skipping 142 matching lines @@
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           if (dart.equals(entry.element, o)) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
             return true;
           }
           entry = entry[_next];
         }
         return false;
       }
-      [_filter$](test, removeMatching) {
+      [_filter](test, removeMatching) {
         let entry = this[_sentinel][_next];
         while (!dart.notNull(core.identical(entry, this[_sentinel]))) {
           let next = entry[_next];
           if (core.identical(removeMatching, test(entry.element))) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
           }
           entry = next;
         }
       }
       removeWhere(test) {
-        this[_filter$](test, true);
+        this[_filter](test, true);
       }
       retainWhere(test) {
-        this[_filter$](test, false);
+        this[_filter](test, false);
       }
       get first() {
         return this[_sentinel][_next].element;
       }
       get last() {
         return this[_sentinel][_previous].element;
       }
       get single() {
         if (core.identical(this[_sentinel][_next], this[_sentinel][_previous])) {
           return this[_sentinel][_next].element;
@@ skipping 54 matching lines @@
       get current() {
         return this[_current];
       }
     }
     return _DoubleLinkedQueueIterator;
   });
   let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$(dart.dynamic);
   let _head = Symbol('_head');
   let _tail = Symbol('_tail');
   let _table = Symbol('_table');
+  let _INITIAL_CAPACITY = Symbol('_INITIAL_CAPACITY');
+  let _isPowerOf2 = Symbol('_isPowerOf2');
+  let _nextPowerOf2 = Symbol('_nextPowerOf2');
   let _checkModification = Symbol('_checkModification');
   let _writeToList = Symbol('_writeToList');
   let _add = Symbol('_add');
   let _preGrow = Symbol('_preGrow');
   let _remove = Symbol('_remove');
   let _filterWhere = Symbol('_filterWhere');
   let _grow = Symbol('_grow');
-  let _isPowerOf2$ = Symbol('_isPowerOf2');
-  let _nextPowerOf2$ = Symbol('_nextPowerOf2');
   let ListQueue$ = dart.generic(function(E) {
     class ListQueue extends IterableBase$(E) {
       ListQueue(initialCapacity) {
         if (initialCapacity === void 0)
           initialCapacity = null;
         this[_head] = 0;
         this[_tail] = 0;
         this[_table] = null;
         this[_modificationCount] = 0;
         super.IterableBase();
-        if (initialCapacity === null || dart.notNull(initialCapacity) < dart.notNull(ListQueue._INITIAL_CAPACITY)) {
-          initialCapacity = ListQueue._INITIAL_CAPACITY;
-        } else if (!dart.notNull(_isPowerOf2(initialCapacity))) {
-          initialCapacity = _nextPowerOf2(initialCapacity);
+        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(_isPowerOf2(initialCapacity));
+        dart.assert(ListQueue[_isPowerOf2](initialCapacity));
         this[_table] = new core.List(initialCapacity);
       }
       ListQueue$from(elements) {
         if (dart.is(elements, core.List)) {
           let length = elements.length;
           let queue = dart.as(new ListQueue(dart.notNull(length) + 1), ListQueue$(E));
           dart.assert(dart.notNull(queue[_table].length) > dart.notNull(length));
           let sourceList = elements;
           queue[_table].setRange(0, length, dart.as(sourceList, core.Iterable$(E)), 0);
           queue[_tail] = length;
           return queue;
         } else {
-          let capacity = ListQueue._INITIAL_CAPACITY;
+          let capacity = ListQueue[_INITIAL_CAPACITY];
           if (dart.is(elements, _internal.EfficientLength)) {
             capacity = elements.length;
           }
           let result = new ListQueue(capacity);
           for (let element of elements) {
             result.addLast(element);
           }
           return result;
         }
       }
@@ skipping 144 matching lines @@
       }
       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;
         let result = this[_table].get(this[_tail]);
         this[_table].set(this[_tail], null);
         return result;
       }
-      static [_isPowerOf2$](number) {
+      static [_isPowerOf2](number) {
         return (dart.notNull(number) & dart.notNull(number) - 1) === 0;
       }
-      static [_nextPowerOf2$](number) {
+      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) {
@@ skipping 52 matching lines @@
         } else {
           let firstPartSize = dart.notNull(this[_table].length) - dart.notNull(this[_head]);
           target.setRange(0, firstPartSize, this[_table], this[_head]);
           target.setRange(firstPartSize, dart.notNull(firstPartSize) + dart.notNull(this[_tail]), this[_table], 0);
           return dart.notNull(this[_tail]) + dart.notNull(firstPartSize);
         }
       }
       [_preGrow](newElementCount) {
         dart.assert(dart.notNull(newElementCount) >= dart.notNull(this.length));
         newElementCount = dart.notNull(newElementCount) >> 1;
-        let newCapacity = _nextPowerOf2(newElementCount);
+        let newCapacity = ListQueue[_nextPowerOf2](newElementCount);
         let newTable = new core.List(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     dart.defineNamedConstructor(ListQueue, 'from');
     ListQueue._INITIAL_CAPACITY = 8;
     return ListQueue;
   });
@@ skipping 203 matching lines @@
     class _TypeTest extends core.Object {
       test(v) {
         return dart.is(v, T);
       }
     }
     return _TypeTest;
   });
   let _TypeTest = _TypeTest$(dart.dynamic);
   let _comparator = Symbol('_comparator');
   let _validKey = Symbol('_validKey');
+  let _internal$ = Symbol('_internal');
   let SplayTreeMap$ = dart.generic(function(K, V) {
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare === null ? core.Comparable.compare : compare, core.Comparator);
         this[_validKey] = dart.as(isValidKey !== null ? isValidKey : (v) => dart.is(v, K), _Predicate);
         super._SplayTree();
@@ skipping 183 matching lines @@
           return null;
         while (node.left !== null) {
           node = node.left;
         }
         return node.key;
       }
     }
     dart.defineNamedConstructor(SplayTreeMap, 'from');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterable');
     dart.defineNamedConstructor(SplayTreeMap, 'fromIterables');
-    dart.defineNamedConstructor(SplayTreeMap, '_internal');
+    dart.defineNamedConstructor(SplayTreeMap, _internal$);
     return SplayTreeMap;
   });
   let SplayTreeMap = SplayTreeMap$(dart.dynamic, dart.dynamic);
   let _workList = Symbol('_workList');
   let _tree = Symbol('_tree');
   let _currentNode = Symbol('_currentNode');
   let _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
   let _getValue = Symbol('_getValue');
   let _rebuildWorkList = Symbol('_rebuildWorkList');
   let _SplayTreeIterator$ = dart.generic(function(T) {
@@ skipping 305 matching lines @@
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     dart.defineNamedConstructor(SplayTreeSet, 'from');
     return SplayTreeSet;
   });
   let SplayTreeSet = SplayTreeSet$(dart.dynamic);
   let _strings = Symbol('_strings');
   let _nums = Symbol('_nums');
   let _rest = Symbol('_rest');
+  let _isStringKey = Symbol('_isStringKey');
+  let _hasTableEntry = Symbol('_hasTableEntry');
+  let _isNumericKey = Symbol('_isNumericKey');
   let _containsKey = Symbol('_containsKey');
   let _getBucket = Symbol('_getBucket');
   let _findBucketIndex = Symbol('_findBucketIndex');
   let _computeKeys = Symbol('_computeKeys');
+  let _getTableEntry = Symbol('_getTableEntry');
   let _get = Symbol('_get');
+  let _newHashTable = Symbol('_newHashTable');
   let _addHashTableEntry = Symbol('_addHashTableEntry');
   let _set = Symbol('_set');
   let _computeHashCode = Symbol('_computeHashCode');
+  let _setTableEntry = Symbol('_setTableEntry');
   let _removeHashTableEntry = Symbol('_removeHashTableEntry');
-  let _isStringKey$ = Symbol('_isStringKey');
-  let _isNumericKey$ = Symbol('_isNumericKey');
-  let _hasTableEntry$ = Symbol('_hasTableEntry');
-  let _getTableEntry$ = Symbol('_getTableEntry');
-  let _setTableEntry$ = Symbol('_setTableEntry');
-  let _deleteTableEntry$ = Symbol('_deleteTableEntry');
-  let _newHashTable$ = Symbol('_newHashTable');
+  let _deleteTableEntry = Symbol('_deleteTableEntry');
   let _HashMap$ = dart.generic(function(K, V) {
     class _HashMap extends core.Object {
       _HashMap() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_keys] = null;
       }
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new HashMapKeyIterable(this);
       }
       get values() {
         return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
-        if (_isStringKey(key)) {
+        if (_HashMap[_isStringKey](key)) {
           let strings = this[_strings];
-          return strings === null ? false : _hasTableEntry(strings, key);
-        } else if (_isNumericKey(key)) {
+          return strings === null ? false : _HashMap[_hasTableEntry](strings, key);
+        } else if (_HashMap[_isNumericKey](key)) {
           let nums = this[_nums];
-          return nums === null ? false : _hasTableEntry(nums, key);
+          return nums === null ? false : _HashMap[_hasTableEntry](nums, key);
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this[_computeKeys]().any(((each) => dart.equals(this.get(each), value)).bind(this));
       }
       addAll(other) {
         other.forEach(((key, value) => {
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
-        if (_isStringKey(key)) {
+        if (_HashMap[_isStringKey](key)) {
           let strings = this[_strings];
-          return dart.as(strings === null ? null : _getTableEntry(strings, key), V);
-        } else if (_isNumericKey(key)) {
+          return dart.as(strings === null ? null : _HashMap[_getTableEntry](strings, key), V);
+        } else if (_HashMap[_isNumericKey](key)) {
           let nums = this[_nums];
-          return dart.as(nums === null ? null : _getTableEntry(nums, key), V);
+          return dart.as(nums === null ? null : _HashMap[_getTableEntry](nums, key), V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest === null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         return dart.as(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1], V);
       }
       set(key, value) {
-        if (_isStringKey(key)) {
+        if (_HashMap[_isStringKey](key)) {
           let strings = this[_strings];
           if (strings === null)
-            this[_strings] = strings = _newHashTable();
+            this[_strings] = strings = _HashMap[_newHashTable]();
           this[_addHashTableEntry](strings, key, value);
-        } else if (_isNumericKey(key)) {
+        } else if (_HashMap[_isNumericKey](key)) {
           let nums = this[_nums];
           if (nums === null)
-            this[_nums] = nums = _newHashTable();
+            this[_nums] = nums = _HashMap[_newHashTable]();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
         let rest = this[_rest];
         if (rest === null)
-          this[_rest] = rest = _newHashTable();
+          this[_rest] = rest = _HashMap[_newHashTable]();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket === null) {
-          _setTableEntry(rest, hash, [key, value]);
+          _HashMap[_setTableEntry](rest, hash, [key, value]);
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             bucket[dart.notNull(index) + 1] = value;
           } else {
             bucket.push(key, value);
             this[_length] = dart.notNull(this[_length]) + 1;
             this[_keys] = null;
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
-        if (_isStringKey(key)) {
+        if (_HashMap[_isStringKey](key)) {
           return this[_removeHashTableEntry](this[_strings], key);
-        } else if (_isNumericKey(key)) {
+        } else if (_HashMap[_isNumericKey](key)) {
           return this[_removeHashTableEntry](this[_nums], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest === null)
           return null;
         let bucket = this[_getBucket](rest, key);
@@ skipping 57 matching lines @@
               let key = bucket[i];
               result[index] = key;
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index === this[_length]);
         return this[_keys] = result;
       }
       [_addHashTableEntry](table, key, value) {
-        if (!dart.notNull(_hasTableEntry(table, key))) {
+        if (!dart.notNull(_HashMap[_hasTableEntry](table, key))) {
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         }
-        _setTableEntry(table, key, value);
+        _HashMap[_setTableEntry](table, key, value);
       }
       [_removeHashTableEntry](table, key) {
-        if (dart.notNull(table !== null) && dart.notNull(_hasTableEntry(table, key))) {
-          let value = dart.as(_getTableEntry(table, key), V);
-          _deleteTableEntry(table, key);
+        if (dart.notNull(table !== null) && dart.notNull(_HashMap[_hasTableEntry](table, key))) {
+          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) {
+      static [_isStringKey](key) {
         return dart.notNull(typeof key == string) && dart.notNull(!dart.equals(key, '__proto__'));
       }
-      static [_isNumericKey$](key) {
+      static [_isNumericKey](key) {
         return dart.notNull(dart.is(key, core.num)) && (key & 0x3ffffff) === key;
       }
       [_computeHashCode](key) {
         return dart.dload(key, 'hashCode') & 0x3ffffff;
       }
-      static [_hasTableEntry$](table, key) {
+      static [_hasTableEntry](table, key) {
         let entry = table[key];
         return entry !== null;
       }
-      static [_getTableEntry$](table, key) {
+      static [_getTableEntry](table, key) {
         let entry = table[key];
         return entry === table ? null : entry;
       }
-      static [_setTableEntry$](table, key, value) {
+      static [_setTableEntry](table, key, value) {
         if (value === null) {
           table[key] = table;
         } else {
           table[key] = value;
         }
       }
-      static [_deleteTableEntry$](table, key) {
+      static [_deleteTableEntry](table, key) {
         delete table[key];
       }
       [_getBucket](table, key) {
         let hash = this[_computeHashCode](key);
         return dart.as(table[hash], core.List);
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = 2) {
           if (dart.equals(bucket[i], key))
             return i;
         }
         return -1;
       }
-      static [_newHashTable$]() {
+      static [_newHashTable]() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _setTableEntry(table, temporaryKey, table);
-        _deleteTableEntry(table, temporaryKey);
+        _HashMap[_setTableEntry](table, temporaryKey, table);
+        _HashMap[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     return _HashMap;
   });
   let _HashMap = _HashMap$(dart.dynamic, dart.dynamic);
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
@@ skipping 147 matching lines @@
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new LinkedHashMapKeyIterable(this);
       }
       get values() {
         return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
-        if (_isStringKey(key)) {
+        if (_LinkedHashMap[_isStringKey](key)) {
           let strings = this[_strings];
           if (strings === null)
             return false;
-          let cell = dart.as(_getTableEntry(strings, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap[_getTableEntry](strings, key), LinkedHashMapCell);
           return cell !== null;
-        } else if (_isNumericKey(key)) {
+        } else if (_LinkedHashMap[_isNumericKey](key)) {
           let nums = this[_nums];
           if (nums === null)
             return false;
-          let cell = dart.as(_getTableEntry(nums, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap[_getTableEntry](nums, key), LinkedHashMapCell);
           return cell !== null;
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this.keys.any(dart.closureWrap(((each) => dart.equals(this.get(each), value)).bind(this), "(K) → bool"));
       }
       addAll(other) {
         other.forEach(((key, value) => {
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
-        if (_isStringKey(key)) {
+        if (_LinkedHashMap[_isStringKey](key)) {
           let strings = this[_strings];
           if (strings === null)
             return null;
-          let cell = dart.as(_getTableEntry(strings, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap[_getTableEntry](strings, key), LinkedHashMapCell);
           return dart.as(cell === null ? null : cell[_value], V);
-        } else if (_isNumericKey(key)) {
+        } else if (_LinkedHashMap[_isNumericKey](key)) {
           let nums = this[_nums];
           if (nums === null)
             return null;
-          let cell = dart.as(_getTableEntry(nums, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap[_getTableEntry](nums, key), LinkedHashMapCell);
           return dart.as(cell === null ? null : cell[_value], V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest === null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0)
           return null;
         let cell = dart.as(bucket[index], LinkedHashMapCell);
         return dart.as(cell[_value], V);
       }
       set(key, value) {
-        if (_isStringKey(key)) {
+        if (_LinkedHashMap[_isStringKey](key)) {
           let strings = this[_strings];
           if (strings === null)
-            this[_strings] = strings = _newHashTable();
+            this[_strings] = strings = _LinkedHashMap[_newHashTable]();
           this[_addHashTableEntry](strings, key, value);
-        } else if (_isNumericKey(key)) {
+        } else if (_LinkedHashMap[_isNumericKey](key)) {
           let nums = this[_nums];
           if (nums === null)
-            this[_nums] = nums = _newHashTable();
+            this[_nums] = nums = _LinkedHashMap[_newHashTable]();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
         let rest = this[_rest];
         if (rest === null)
-          this[_rest] = rest = _newHashTable();
+          this[_rest] = rest = _LinkedHashMap[_newHashTable]();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket === null) {
           let cell = this[_newLinkedCell](key, value);
-          _setTableEntry(rest, hash, [cell]);
+          _LinkedHashMap[_setTableEntry](rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             let cell = dart.as(bucket[index], LinkedHashMapCell);
             cell[_value] = value;
           } else {
             let cell = this[_newLinkedCell](key, value);
             bucket.push(cell);
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
-        if (_isStringKey(key)) {
+        if (_LinkedHashMap[_isStringKey](key)) {
           return this[_removeHashTableEntry](this[_strings], key);
-        } else if (_isNumericKey(key)) {
+        } else if (_LinkedHashMap[_isNumericKey](key)) {
           return this[_removeHashTableEntry](this[_nums], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest === null)
           return null;
         let bucket = this[_getBucket](rest, key);
@@ skipping 16 matching lines @@
         let modifications = this[_modifications];
         while (cell !== null) {
           action(dart.as(cell[_key], K), dart.as(cell[_value], V));
           if (modifications !== this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           cell = cell[_next];
         }
       }
       [_addHashTableEntry](table, key, value) {
-        let cell = dart.as(_getTableEntry(table, key), LinkedHashMapCell);
+        let cell = dart.as(_LinkedHashMap[_getTableEntry](table, key), LinkedHashMapCell);
         if (cell === null) {
-          _setTableEntry(table, key, this[_newLinkedCell](key, value));
+          _LinkedHashMap[_setTableEntry](table, key, this[_newLinkedCell](key, value));
         } else {
           cell[_value] = value;
         }
       }
       [_removeHashTableEntry](table, key) {
         if (table === null)
           return null;
-        let cell = dart.as(_getTableEntry(table, key), LinkedHashMapCell);
+        let cell = dart.as(_LinkedHashMap[_getTableEntry](table, key), LinkedHashMapCell);
         if (cell === null)
           return null;
         this[_unlinkCell](cell);
-        _deleteTableEntry(table, key);
+        _LinkedHashMap[_deleteTableEntry](table, key);
         return dart.as(cell[_value], V);
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](key, value) {
         let cell = new LinkedHashMapCell(key, value);
         if (this[_first] === null) {
           this[_first] = this[_last] = cell;
         } else {
@@ skipping 16 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) {
+      static [_isStringKey](key) {
         return dart.notNull(typeof key == string) && dart.notNull(!dart.equals(key, '__proto__'));
       }
-      static [_isNumericKey$](key) {
+      static [_isNumericKey](key) {
         return dart.notNull(dart.is(key, core.num)) && (key & 0x3ffffff) === key;
       }
       [_computeHashCode](key) {
         return dart.dload(key, 'hashCode') & 0x3ffffff;
       }
-      static [_getTableEntry$](table, key) {
+      static [_getTableEntry](table, key) {
         return table[key];
       }
-      static [_setTableEntry$](table, key, value) {
+      static [_setTableEntry](table, key, value) {
         dart.assert(value !== null);
         table[key] = value;
       }
-      static [_deleteTableEntry$](table, key) {
+      static [_deleteTableEntry](table, key) {
         delete table[key];
       }
       [_getBucket](table, key) {
         let hash = this[_computeHashCode](key);
         return dart.as(table[hash], core.List);
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (dart.equals(cell[_key], key))
             return i;
         }
         return -1;
       }
-      static [_newHashTable$]() {
+      static [_newHashTable]() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _setTableEntry(table, temporaryKey, table);
-        _deleteTableEntry(table, temporaryKey);
+        _LinkedHashMap[_setTableEntry](table, temporaryKey, table);
+        _LinkedHashMap[_deleteTableEntry](table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$(dart.dynamic, dart.dynamic);
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
@@ skipping 125 matching lines @@
           this[_cell] = this[_cell][_next];
           return true;
         }
       }
     }
     return LinkedHashMapKeyIterator;
   });
   let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$(dart.dynamic);
   let _elements = Symbol('_elements');
   let _computeElements = Symbol('_computeElements');
+  let _isStringElement = Symbol('_isStringElement');
+  let _isNumericElement = Symbol('_isNumericElement');
   let _contains = Symbol('_contains');
   let _lookup = Symbol('_lookup');
-  let _isStringElement$ = Symbol('_isStringElement');
-  let _isNumericElement$ = Symbol('_isNumericElement');
   let _HashSet$ = dart.generic(function(E) {
     class _HashSet extends _HashSetBase$(E) {
       _HashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_elements] = null;
         super._HashSetBase();
       }
       [_newSet]() {
         return new _HashSet();
       }
       get iterator() {
         return new HashSetIterator(this, this[_computeElements]());
       }
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       contains(object) {
-        if (_isStringElement(object)) {
+        if (_HashSet[_isStringElement](object)) {
           let strings = this[_strings];
-          return strings === null ? false : _hasTableEntry(strings, object);
-        } else if (_isNumericElement(object)) {
+          return strings === null ? false : _HashSet[_hasTableEntry](strings, object);
+        } else if (_HashSet[_isNumericElement](object)) {
           let nums = this[_nums];
-          return nums === null ? false : _hasTableEntry(nums, object);
+          return nums === null ? false : _HashSet[_hasTableEntry](nums, object);
         } else {
           return this[_contains](object);
         }
       }
       [_contains](object) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
-        if (dart.notNull(_isStringElement(object)) || dart.notNull(_isNumericElement(object))) {
+        if (dart.notNull(_HashSet[_isStringElement](object)) || dart.notNull(_HashSet[_isNumericElement](object))) {
           return dart.as(this.contains(object) ? object : null, E);
         }
         return this[_lookup](object);
       }
       [_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(bucket.get(index), E);
       }
       add(element) {
-        if (_isStringElement(element)) {
+        if (_HashSet[_isStringElement](element)) {
           let strings = this[_strings];
           if (strings === null)
-            this[_strings] = strings = _newHashTable();
+            this[_strings] = strings = _HashSet[_newHashTable]();
           return this[_addHashTableEntry](strings, element);
-        } else if (_isNumericElement(element)) {
+        } else if (_HashSet[_isNumericElement](element)) {
           let nums = this[_nums];
           if (nums === null)
-            this[_nums] = nums = _newHashTable();
+            this[_nums] = nums = _HashSet[_newHashTable]();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
         let rest = this[_rest];
         if (rest === null)
-          this[_rest] = rest = _newHashTable();
+          this[_rest] = rest = _HashSet[_newHashTable]();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket === null) {
-          _setTableEntry(rest, hash, [element]);
+          _HashSet[_setTableEntry](rest, hash, [element]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0)
             return false;
           bucket.push(element);
         }
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       addAll(objects) {
         for (let each of objects) {
           this.add(each);
         }
       }
       remove(object) {
-        if (_isStringElement(object)) {
+        if (_HashSet[_isStringElement](object)) {
           return this[_removeHashTableEntry](this[_strings], object);
-        } else if (_isNumericElement(object)) {
+        } else if (_HashSet[_isNumericElement](object)) {
           return this[_removeHashTableEntry](this[_nums], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, object);
@@ skipping 47 matching lines @@
             for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
               result[index] = bucket[i];
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index === this[_length]);
         return this[_elements] = result;
       }
       [_addHashTableEntry](table, element) {
-        if (_hasTableEntry(table, element))
+        if (_HashSet[_hasTableEntry](table, element))
           return false;
-        _setTableEntry(table, element, 0);
+        _HashSet[_setTableEntry](table, element, 0);
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       [_removeHashTableEntry](table, element) {
-        if (dart.notNull(table !== null) && dart.notNull(_hasTableEntry(table, element))) {
-          _deleteTableEntry(table, element);
+        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) {
+      static [_isStringElement](element) {
         return dart.notNull(typeof element == string) && dart.notNull(!dart.equals(element, '__proto__'));
       }
-      static [_isNumericElement$](element) {
+      static [_isNumericElement](element) {
         return dart.notNull(dart.is(element, core.num)) && (element & 0x3ffffff) === element;
       }
       [_computeHashCode](element) {
         return dart.dload(element, 'hashCode') & 0x3ffffff;
       }
-      static [_hasTableEntry$](table, key) {
+      static [_hasTableEntry](table, key) {
         let entry = table[key];
         return entry !== null;
       }
-      static [_setTableEntry$](table, key, value) {
+      static [_setTableEntry](table, key, value) {
         dart.assert(value !== null);
         table[key] = value;
       }
-      static [_deleteTableEntry$](table, key) {
+      static [_deleteTableEntry](table, key) {
         delete table[key];
       }
       [_getBucket](table, element) {
         let hash = this[_computeHashCode](element);
         return dart.as(table[hash], core.List);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (dart.equals(bucket[i], element))
             return i;
         }
         return -1;
       }
-      static [_newHashTable$]() {
+      static [_newHashTable]() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _setTableEntry(table, temporaryKey, table);
-        _deleteTableEntry(table, temporaryKey);
+        _HashSet[_setTableEntry](table, temporaryKey, table);
+        _HashSet[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     return _HashSet;
   });
   let _HashSet = _HashSet$(dart.dynamic);
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       [_newSet]() {
         return new _IdentityHashSet();
@@ skipping 117 matching lines @@
       get length() {
         return this[_length];
       }
       get isEmpty() {
         return this[_length] === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       contains(object) {
-        if (_isStringElement(object)) {
+        if (_LinkedHashSet[_isStringElement](object)) {
           let strings = this[_strings];
           if (strings === null)
             return false;
-          let cell = dart.as(_getTableEntry(strings, object), LinkedHashSetCell);
+          let cell = dart.as(_LinkedHashSet[_getTableEntry](strings, object), LinkedHashSetCell);
           return cell !== null;
-        } else if (_isNumericElement(object)) {
+        } else if (_LinkedHashSet[_isNumericElement](object)) {
           let nums = this[_nums];
           if (nums === null)
             return false;
-          let cell = dart.as(_getTableEntry(nums, object), LinkedHashSetCell);
+          let cell = dart.as(_LinkedHashSet[_getTableEntry](nums, object), LinkedHashSetCell);
           return cell !== null;
         } else {
           return this[_contains](object);
         }
       }
       [_contains](object) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
-        if (dart.notNull(_isStringElement(object)) || dart.notNull(_isNumericElement(object))) {
+        if (dart.notNull(_LinkedHashSet[_isStringElement](object)) || dart.notNull(_LinkedHashSet[_isNumericElement](object))) {
           return dart.as(this.contains(object) ? object : null, E);
         } else {
           return this[_lookup](object);
         }
       }
       [_lookup](object) {
         let rest = this[_rest];
         if (rest === null)
           return null;
         let bucket = this[_getBucket](rest, object);
@@ skipping 17 matching lines @@
         if (this[_first] === null)
           throw new core.StateError("No elements");
         return dart.as(this[_first][_element], E);
       }
       get last() {
         if (this[_last] === null)
           throw new core.StateError("No elements");
         return dart.as(this[_last][_element], E);
       }
       add(element) {
-        if (_isStringElement(element)) {
+        if (_LinkedHashSet[_isStringElement](element)) {
           let strings = this[_strings];
           if (strings === null)
-            this[_strings] = strings = _newHashTable();
+            this[_strings] = strings = _LinkedHashSet[_newHashTable]();
           return this[_addHashTableEntry](strings, element);
-        } else if (_isNumericElement(element)) {
+        } else if (_LinkedHashSet[_isNumericElement](element)) {
           let nums = this[_nums];
           if (nums === null)
-            this[_nums] = nums = _newHashTable();
+            this[_nums] = nums = _LinkedHashSet[_newHashTable]();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
         let rest = this[_rest];
         if (rest === null)
-          this[_rest] = rest = _newHashTable();
+          this[_rest] = rest = _LinkedHashSet[_newHashTable]();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket === null) {
           let cell = this[_newLinkedCell](element);
-          _setTableEntry(rest, hash, [cell]);
+          _LinkedHashSet[_setTableEntry](rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0)
             return false;
           let cell = this[_newLinkedCell](element);
           bucket.push(cell);
         }
         return true;
       }
       remove(object) {
-        if (_isStringElement(object)) {
+        if (_LinkedHashSet[_isStringElement](object)) {
           return this[_removeHashTableEntry](this[_strings], object);
-        } else if (_isNumericElement(object)) {
+        } else if (_LinkedHashSet[_isNumericElement](object)) {
           return this[_removeHashTableEntry](this[_nums], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, object);
@@ skipping 26 matching lines @@
         }
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
           this[_length] = 0;
           this[_modified]();
         }
       }
       [_addHashTableEntry](table, element) {
-        let cell = dart.as(_getTableEntry(table, element), LinkedHashSetCell);
+        let cell = dart.as(_LinkedHashSet[_getTableEntry](table, element), LinkedHashSetCell);
         if (cell !== null)
           return false;
-        _setTableEntry(table, element, this[_newLinkedCell](element));
+        _LinkedHashSet[_setTableEntry](table, element, this[_newLinkedCell](element));
         return true;
       }
       [_removeHashTableEntry](table, element) {
         if (table === null)
           return false;
-        let cell = dart.as(_getTableEntry(table, element), LinkedHashSetCell);
+        let cell = dart.as(_LinkedHashSet[_getTableEntry](table, element), LinkedHashSetCell);
         if (cell === null)
           return false;
         this[_unlinkCell](cell);
-        _deleteTableEntry(table, element);
+        _LinkedHashSet[_deleteTableEntry](table, element);
         return true;
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](element) {
         let cell = new LinkedHashSetCell(element);
         if (this[_first] === null) {
           this[_first] = this[_last] = cell;
         } else {
@@ skipping 16 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) {
+      static [_isStringElement](element) {
         return dart.notNull(typeof element == string) && dart.notNull(!dart.equals(element, '__proto__'));
       }
-      static [_isNumericElement$](element) {
+      static [_isNumericElement](element) {
         return dart.notNull(dart.is(element, core.num)) && (element & 0x3ffffff) === element;
       }
       [_computeHashCode](element) {
         return dart.dload(element, 'hashCode') & 0x3ffffff;
       }
-      static [_getTableEntry$](table, key) {
+      static [_getTableEntry](table, key) {
         return table[key];
       }
-      static [_setTableEntry$](table, key, value) {
+      static [_setTableEntry](table, key, value) {
         dart.assert(value !== null);
         table[key] = value;
       }
-      static [_deleteTableEntry$](table, key) {
+      static [_deleteTableEntry](table, key) {
         delete table[key];
       }
       [_getBucket](table, element) {
         let hash = this[_computeHashCode](element);
         return dart.as(table[hash], core.List);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (dart.equals(cell[_element], element))
             return i;
         }
         return -1;
       }
-      static [_newHashTable$]() {
+      static [_newHashTable]() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _setTableEntry(table, temporaryKey, table);
-        _deleteTableEntry(table, temporaryKey);
+        _LinkedHashSet[_setTableEntry](table, temporaryKey, table);
+        _LinkedHashSet[_deleteTableEntry](table, temporaryKey);
         return table;
       }
     }
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$(dart.dynamic);
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       [_newSet]() {
         return new _LinkedIdentityHashSet();
@@ skipping 170 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 = {}));