fix static members in _emitMemberName

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get [core.$iterator]() {
@@ skipping 343 matching lines @@
   let _ = dart.JsSymbol('_');
   let _f = dart.JsSymbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
         }
         return new MappedIterable$(S, T)[_](dart.as(iterable, core.Iterable$(S)), func);
       }
-      [_](iterable, f) {
+      _(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (MappedIterator$(S, T))(this[_iterable][core.$iterator], this[_f]);
       }
       get [core.$length]() {
         return this[_iterable][core.$length];
       }
       get [core.$isEmpty]() {
         return this[_iterable][core.$isEmpty];
       }
       get [core.$first]() {
         return this[_f](this[_iterable][core.$first]);
       }
       get [core.$last]() {
         return this[_f](this[_iterable][core.$last]);
       }
       get [core.$single]() {
         return this[_f](this[_iterable][core.$single]);
       }
       [core.$elementAt](index) {
         return this[_f](this[_iterable][core.$elementAt](index));
       }
     }
-    dart.defineNamedConstructor(MappedIterable, _);
+    dart.defineNamedConstructor(MappedIterable, '_');
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$();
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
-        super[_](dart.as(iterable, core.Iterable$(S)), func);
+        super._(dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthMappedIterable;
   });
   let EfficientLengthMappedIterable = EfficientLengthMappedIterable$();
   let _iterator = dart.JsSymbol('_iterator');
   let MappedIterator$ = dart.generic(function(S, T) {
     class MappedIterator extends core.Iterator$(T) {
       MappedIterator(iterator, f) {
@@ skipping 133 matching lines @@
     class TakeIterable extends collection.IterableBase$(E) {
       TakeIterable(iterable, takeCount) {
         if (!(typeof takeCount == 'number') || dart.notNull(takeCount) < 0) {
           throw new core.ArgumentError(takeCount);
         }
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
         }
         return new TakeIterable$(E)[_](iterable, takeCount);
       }
-      [_](iterable, takeCount) {
+      _(iterable, takeCount) {
         this[_iterable] = iterable;
         this[_takeCount] = takeCount;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (TakeIterator$(E))(this[_iterable][core.$iterator], this[_takeCount]);
       }
     }
-    dart.defineNamedConstructor(TakeIterable, _);
+    dart.defineNamedConstructor(TakeIterable, '_');
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$();
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
-        super[_](iterable, takeCount);
+        super._(iterable, takeCount);
       }
       get [core.$length]() {
         let iterableLength = this[_iterable][core.$length];
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthTakeIterable;
@@ skipping 66 matching lines @@
   let TakeWhileIterator = TakeWhileIterator$();
   let _skipCount = dart.JsSymbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
         return new SkipIterable$(E)[_](iterable, count);
       }
-      [_](iterable, skipCount) {
+      _(iterable, skipCount) {
         this[_iterable] = iterable;
         this[_skipCount] = skipCount;
         super.IterableBase();
         if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
       }
       [core.$skip](count) {
         if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
         return new SkipIterable$(E)[_](this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get [core.$iterator]() {
         return new (SkipIterator$(E))(this[_iterable][core.$iterator], this[_skipCount]);
       }
     }
-    dart.defineNamedConstructor(SkipIterable, _);
+    dart.defineNamedConstructor(SkipIterable, '_');
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
-        super[_](iterable, skipCount);
+        super._(iterable, skipCount);
       }
       get [core.$length]() {
         let length = dart.notNull(this[_iterable][core.$length]) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthSkipIterable;
@@ skipping 169 matching lines @@
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$();
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {}
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
-  let _rangeCheck = dart.JsSymbol('_rangeCheck');
   let IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       static forEach(iterable, f) {
@@ skipping 215 matching lines @@
         }
       }
       static indexOfList(list, element, start) {
         return Lists.indexOf(list, element, start, list[core.$length]);
       }
       static lastIndexOfList(list, element, start) {
         if (start == null)
           start = dart.notNull(list[core.$length]) - 1;
         return Lists.lastIndexOf(list, element, start);
       }
-      static [_rangeCheck](list, start, end) {
+      static _rangeCheck(list, start, end) {
         core.RangeError.checkValidRange(start, end, list[core.$length]);
       }
       getRangeList(list, start, end) {
-        IterableMixinWorkaround[_rangeCheck](list, start, end);
+        IterableMixinWorkaround._rangeCheck(list, start, end);
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), start, end);
       }
       static setRangeList(list, start, end, from, skipCount) {
-        IterableMixinWorkaround[_rangeCheck](list, start, end);
+        IterableMixinWorkaround._rangeCheck(list, start, end);
         let length = dart.notNull(end) - dart.notNull(start);
         if (length == 0)
           return;
         if (dart.notNull(skipCount) < 0)
           throw new core.ArgumentError(skipCount);
         let otherList = null;
         let otherStart = null;
         if (dart.is(from, core.List)) {
           otherList = from;
           otherStart = skipCount;
         } else {
           otherList = from[core.$skip](skipCount)[core.$toList]({growable: false});
           otherStart = 0;
         }
         if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(otherList[core.$length])) {
           throw IterableElementError.tooFew();
         }
         Lists.copy(otherList, otherStart, list, start, length);
       }
       static replaceRangeList(list, start, end, iterable) {
-        IterableMixinWorkaround[_rangeCheck](list, start, end);
+        IterableMixinWorkaround._rangeCheck(list, start, end);
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[core.$toList]();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
         let insertLength = iterable[core.$length];
         if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
           let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           let newEnd = dart.notNull(list[core.$length]) - dart.notNull(delta);
           list[core.$setRange](start, insertEnd, iterable);
           if (delta != 0) {
             list[core.$setRange](insertEnd, newEnd, list, end);
             list[core.$length] = newEnd;
           }
         } else {
           let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
           let newLength = dart.notNull(list[core.$length]) + dart.notNull(delta);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           list[core.$length] = newLength;
           list[core.$setRange](insertEnd, newLength, list, end);
           list[core.$setRange](start, insertEnd, iterable);
         }
       }
       static fillRangeList(list, start, end, fillValue) {
-        IterableMixinWorkaround[_rangeCheck](list, start, end);
+        IterableMixinWorkaround._rangeCheck(list, start, end);
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           list[core.$set](i, fillValue);
         }
       }
       static insertAllList(list, index, iterable) {
         core.RangeError.checkValueInInterval(index, 0, list[core.$length], "index");
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[core.$toList]({growable: false});
         }
         let insertionLength = iterable[core.$length];
@@ skipping 405 matching lines @@
         let message = `${start} + ${length} must be in the range [0..${a[core.$length]}]`;
         throw new core.RangeError.range(length, 0, dart.notNull(a[core.$length]) - dart.notNull(start), "length", message);
       }
     }
   }
   exports.printToZone = null;
   // Function printToConsole: (String) → void
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
-  let _doSort = dart.JsSymbol('_doSort');
-  let _INSERTION_SORT_THRESHOLD = dart.JsSymbol('_INSERTION_SORT_THRESHOLD');
-  let _insertionSort = dart.JsSymbol('_insertionSort');
-  let _dualPivotQuicksort = dart.JsSymbol('_dualPivotQuicksort');
   class Sort extends core.Object {
     static sort(a, compare) {
-      Sort[_doSort](a, 0, dart.notNull(a[core.$length]) - 1, compare);
+      Sort._doSort(a, 0, dart.notNull(a[core.$length]) - 1, compare);
     }
     static sortRange(a, from, to, compare) {
       if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a[core.$length]) || dart.notNull(to) < dart.notNull(from)) {
         throw "OutOfRange";
       }
-      Sort[_doSort](a, from, dart.notNull(to) - 1, compare);
+      Sort._doSort(a, from, dart.notNull(to) - 1, compare);
     }
-    static [_doSort](a, left, right, compare) {
-      if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort[_INSERTION_SORT_THRESHOLD])) {
-        Sort[_insertionSort](a, left, right, compare);
+    static _doSort(a, left, right, compare) {
+      if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTION_SORT_THRESHOLD)) {
+        Sort._insertionSort(a, left, right, compare);
       } else {
-        Sort[_dualPivotQuicksort](a, left, right, compare);
+        Sort._dualPivotQuicksort(a, left, right, compare);
       }
     }
-    static [_insertionSort](a, left, right, compare) {
+    static _insertionSort(a, left, right, compare) {
       for (let i = dart.notNull(left) + 1; dart.notNull(i) <= dart.notNull(right); i = dart.notNull(i) + 1) {
         let el = a[core.$get](i);
         let j = i;
         while (dart.notNull(j) > dart.notNull(left) && dart.notNull(dart.dcall(compare, a[core.$get](dart.notNull(j) - 1), el)) > 0) {
           a[core.$set](j, a[core.$get](dart.notNull(j) - 1));
           j = dart.notNull(j) - 1;
         }
         a[core.$set](j, el);
       }
     }
-    static [_dualPivotQuicksort](a, left, right, compare) {
-      dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort[_INSERTION_SORT_THRESHOLD]));
+    static _dualPivotQuicksort(a, left, right, compare) {
+      dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort._INSERTION_SORT_THRESHOLD));
       let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6).truncate();
       let index1 = dart.notNull(left) + dart.notNull(sixth);
       let index5 = dart.notNull(right) - dart.notNull(sixth);
       let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2).truncate();
       let index2 = dart.notNull(index3) - dart.notNull(sixth);
       let index4 = dart.notNull(index3) + dart.notNull(sixth);
       let el1 = a[core.$get](index1);
       let el2 = a[core.$get](index2);
       let el3 = a[core.$get](index3);
       let el4 = a[core.$get](index4);
@@ skipping 143 matching lines @@
                 }
               }
             }
           }
         }
       }
       a[core.$set](left, a[core.$get](dart.notNull(less) - 1));
       a[core.$set](dart.notNull(less) - 1, pivot1);
       a[core.$set](right, a[core.$get](dart.notNull(great) + 1));
       a[core.$set](dart.notNull(great) + 1, pivot2);
-      Sort[_doSort](a, left, dart.notNull(less) - 2, compare);
-      Sort[_doSort](a, dart.notNull(great) + 2, right, compare);
+      Sort._doSort(a, left, dart.notNull(less) - 2, compare);
+      Sort._doSort(a, dart.notNull(great) + 2, right, compare);
       if (pivots_are_equal) {
         return;
       }
       if (dart.notNull(less) < dart.notNull(index1) && dart.notNull(great) > dart.notNull(index5)) {
         while (dart.dcall(compare, a[core.$get](less), pivot1) == 0) {
           less = dart.notNull(less) + 1;
         }
         while (dart.dcall(compare, a[core.$get](great), pivot2) == 0) {
           great = dart.notNull(great) - 1;
         }
@@ skipping 37 matching lines @@
                       great = dart.notNull(x) - 1;
                       return x;
                     })(), ak);
                   }
                   break;
                 }
               }
             }
           }
         }
-        Sort[_doSort](a, less, great, compare);
+        Sort._doSort(a, less, great, compare);
       } else {
-        Sort[_doSort](a, less, great, compare);
+        Sort._doSort(a, less, great, compare);
       }
     }
   }
   Sort._INSERTION_SORT_THRESHOLD = 32;
   let _name = dart.JsSymbol('_name');
   class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     unvalidated(name) {
@@ skipping 110 matching lines @@
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal || (_internal = {}));