fix for static methods and names banned in strict mode

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();
       }
@@ skipping 329 matching lines @@
         }
         this[_current] = this[_iterable].elementAt(this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     return ListIterator;
   });
   let ListIterator = ListIterator$(dart.dynamic);
   let _f = Symbol('_f');
+  let _ = Symbol('_');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthMappedIterable(iterable, func);
         }
         return new MappedIterable._(dart.as(iterable, core.Iterable$(S)), func);
       }
       MappedIterable$_(iterable$, f$) {
         this[_iterable] = iterable$;
@@ skipping 15 matching lines @@
       get last() {
         return this[_f](this[_iterable].last);
       }
       get single() {
         return this[_f](this[_iterable].single);
       }
       elementAt(index) {
         return this[_f](this[_iterable].elementAt(index));
       }
     }
-    dart.defineNamedConstructor(MappedIterable, '_');
+    dart.defineNamedConstructor(MappedIterable, _);
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic);
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         super.MappedIterable$_(dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     return EfficientLengthMappedIterable;
@@ skipping 138 matching lines @@
       }
       TakeIterable$_(iterable$, takeCount$) {
         this[_iterable] = iterable$;
         this[_takeCount] = takeCount$;
         super.IterableBase();
       }
       get iterator() {
         return new TakeIterator(this[_iterable].iterator, this[_takeCount]);
       }
     }
-    dart.defineNamedConstructor(TakeIterable, '_');
+    dart.defineNamedConstructor(TakeIterable, _);
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$(dart.dynamic);
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super.TakeIterable$_(iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable].length;
@@ skipping 94 matching lines @@
         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._(this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get iterator() {
         return new SkipIterator(this[_iterable].iterator, this[_skipCount]);
       }
     }
-    dart.defineNamedConstructor(SkipIterable, '_');
+    dart.defineNamedConstructor(SkipIterable, _);
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$(dart.dynamic);
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super.SkipIterable$_(iterable, skipCount);
       }
       get length() {
         let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_skipCount]);
@@ skipping 175 matching lines @@
     }
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$(dart.dynamic);
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {
     }
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
-  let _rangeCheck$ = Symbol('_rangeCheck');
+  let _rangeCheck = Symbol('_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.length);
       }
       static lastIndexOfList(list, element, start) {
         if (start === null)
           start = dart.notNull(list.length) - 1;
         return Lists.lastIndexOf(list, element, start);
       }
-      static [_rangeCheck$](list, start, end) {
+      static [_rangeCheck](list, start, end) {
         core.RangeError.checkValidRange(start, end, list.length);
       }
       getRangeList(list, start, end) {
-        _rangeCheck(list, start, end);
+        IterableMixinWorkaround[_rangeCheck](list, start, end);
         return new SubListIterable(dart.as(list, core.Iterable$(T)), start, end);
       }
       static setRangeList(list, start, end, from, skipCount) {
-        _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.skip(skipCount).toList({growable: false});
           otherStart = 0;
         }
         if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(otherList.length)) {
           throw IterableElementError.tooFew();
         }
         Lists.copy(otherList, otherStart, list, start, length);
       }
       static replaceRangeList(list, start, end, iterable) {
-        _rangeCheck(list, start, end);
+        IterableMixinWorkaround[_rangeCheck](list, start, end);
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable.toList();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
         let insertLength = iterable.length;
         if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
           let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           let newEnd = dart.notNull(list.length) - dart.notNull(delta);
           list.setRange(start, insertEnd, iterable);
           if (delta !== 0) {
             list.setRange(insertEnd, newEnd, list, end);
             list.length = newEnd;
           }
         } else {
           let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
           let newLength = dart.notNull(list.length) + dart.notNull(delta);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           list.length = newLength;
           list.setRange(insertEnd, newLength, list, end);
           list.setRange(start, insertEnd, iterable);
         }
       }
       static fillRangeList(list, start, end, fillValue) {
-        _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.set(i, fillValue);
         }
       }
       static insertAllList(list, index, iterable) {
         core.RangeError.checkValueInInterval(index, 0, list.length, "index");
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable.toList({growable: false});
         }
         let insertionLength = iterable.length;
@@ skipping 377 matching lines @@
         let message = `${start} + ${length} must be in the range [0..${a.length}]`;
         throw new core.RangeError.range(length, 0, dart.notNull(a.length) - dart.notNull(start), "length", message);
       }
     }
   }
   exports.printToZone = null;
   // Function printToConsole: (String) → void
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
-  let _doSort$ = Symbol('_doSort');
-  let _insertionSort$ = Symbol('_insertionSort');
-  let _dualPivotQuicksort$ = Symbol('_dualPivotQuicksort');
+  let _doSort = Symbol('_doSort');
+  let _INSERTION_SORT_THRESHOLD = Symbol('_INSERTION_SORT_THRESHOLD');
+  let _insertionSort = Symbol('_insertionSort');
+  let _dualPivotQuicksort = Symbol('_dualPivotQuicksort');
   class Sort extends core.Object {
     static sort(a, compare) {
-      _doSort(a, 0, dart.notNull(a.length) - 1, compare);
+      Sort[_doSort](a, 0, dart.notNull(a.length) - 1, compare);
     }
     static sortRange(a, from, to, compare) {
       if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a.length) || dart.notNull(to) < dart.notNull(from)) {
         throw "OutOfRange";
       }
-      _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)) {
-        _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 {
-        _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.get(i);
         let j = i;
         while (dart.notNull(j) > dart.notNull(left) && dart.notNull(dart.dinvokef(compare, a.get(dart.notNull(j) - 1), el)) > 0) {
           a.set(j, a.get(dart.notNull(j) - 1));
           j = dart.notNull(j) - 1;
         }
         a.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.get(index1);
       let el2 = a.get(index2);
       let el3 = a.get(index3);
       let el4 = a.get(index4);
@@ skipping 119 matching lines @@
                 }
               }
             }
           }
         }
       }
       a.set(left, a.get(dart.notNull(less) - 1));
       a.set(dart.notNull(less) - 1, pivot1);
       a.set(right, a.get(dart.notNull(great) + 1));
       a.set(dart.notNull(great) + 1, pivot2);
-      _doSort(a, left, dart.notNull(less) - 2, compare);
-      _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.dinvokef(compare, a.get(less), pivot1) === 0) {
           less = dart.notNull(less) + 1;
         }
         while (dart.dinvokef(compare, a.get(great), pivot2) === 0) {
           great = dart.notNull(great) - 1;
         }
@@ skipping 25 matching lines @@
                   } else {
                     a.set(k, a.get(great));
                     a.set(((x) => great = dart.notNull(x) - 1, x)(great), ak);
                   }
                   break;
                 }
               }
             }
           }
         }
-        _doSort(a, less, great, compare);
+        Sort[_doSort](a, less, great, compare);
       } else {
-        _doSort(a, less, great, compare);
+        Sort[_doSort](a, less, great, compare);
       }
     }
   }
   Sort._INSERTION_SORT_THRESHOLD = 32;
   let _name = Symbol('_name');
   class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     Symbol$unvalidated(name$) {
       this[_name] = name$;
     }
     Symbol$validated(name) {
-      this[_name] = validatePublicSymbol(name);
+      this[_name] = Symbol.validatePublicSymbol(name);
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, Symbol)) && dart.notNull(dart.equals(this[_name], dart.dload(other, '_name')));
     }
     get hashCode() {
       let arbitraryPrime = 664597;
       return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(this[_name].hashCode);
     }
     toString() {
       return `Symbol("${this[_name]}")`;
     }
     static getName(symbol) {
       return symbol[_name];
     }
     static validatePublicSymbol(name) {
-      if (dart.notNull(name.isEmpty) || dart.notNull(publicSymbolPattern.hasMatch(name)))
+      if (dart.notNull(name.isEmpty) || dart.notNull(Symbol.publicSymbolPattern.hasMatch(name)))
         return name;
       if (name.startsWith('_')) {
         throw new core.ArgumentError(`"${name}" is a private identifier`);
       }
       throw new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`);
     }
     static isValidSymbol(name) {
-      return dart.notNull(name.isEmpty) || dart.notNull(symbolPattern.hasMatch(name));
+      return dart.notNull(name.isEmpty) || dart.notNull(Symbol.symbolPattern.hasMatch(name));
     }
   }
   dart.defineNamedConstructor(Symbol, 'unvalidated');
   dart.defineNamedConstructor(Symbol, 'validated');
   Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
   Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
   Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
@@ skipping 71 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 = {}));