fixes #193, factory constructors as static methods

lib/runtime/dart/_internal.js

 var _internal = dart.defineLibrary(_internal, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var math = dart.lazyImport(math);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_primitives = dart.lazyImport(_js_primitives);
 (function(exports, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
@@ skipping 201 matching lines @@
         return new (SubListIterable$(E))(this, 0, count);
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return super[core.$takeWhile](test);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
-          result = new (core.List$(E))();
+          result = core.List$(E).new();
           result[core.$length] = this[core.$length];
         } else {
-          result = new (core.List$(E))(this[core.$length]);
+          result = core.List$(E).new(this[core.$length]);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[core.$elementAt](i));
         }
         return result;
       }
       [core.$toSet]() {
-        let result = new (core.Set$(E))();
+        let result = core.Set$(E).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$elementAt](i));
         }
         return result;
       }
     }
     ListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(ListIterable, {
       constructors: () => ({ListIterable: [ListIterable$(E), []]}),
       methods: () => ({
@@ skipping 55 matching lines @@
         if (dart.notNull(this[_start]) >= dart.notNull(length))
           return 0;
         if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) >= dart.notNull(length)) {
           return dart.notNull(length) - dart.notNull(this[_start]);
         }
         return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]);
       }
       [core.$elementAt](index) {
         let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
         if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(this[_endIndex])) {
-          throw new core.RangeError.index(index, this, "index");
+          throw core.RangeError.index(index, this, "index");
         }
         return this[_iterable][core.$elementAt](realIndex);
       }
       [core.$skip](count) {
         core.RangeError.checkNotNegative(count, "count");
         let newStart = dart.notNull(this[_start]) + dart.notNull(count);
         if (this[_endOrLength] != null && dart.notNull(newStart) >= dart.notNull(this[_endOrLength])) {
           return new (EmptyIterable$(E))();
         }
         return new (SubListIterable$(E))(this[_iterable], newStart, this[_endOrLength]);
@@ skipping 12 matching lines @@
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let start = this[_start];
         let end = this[_iterable][core.$length];
         if (this[_endOrLength] != null && dart.notNull(this[_endOrLength]) < dart.notNull(end))
           end = this[_endOrLength];
         let length = dart.notNull(end) - dart.notNull(start);
         if (dart.notNull(length) < 0)
           length = 0;
         let result = growable ? (() => {
-          let _ = new (core.List$(E))();
+          let _ = core.List$(E).new();
           _[core.$length] = length;
           return _;
-        })() : new (core.List$(E))(length);
+        })() : core.List$(E).new(length);
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[_iterable][core.$elementAt](dart.notNull(start) + dart.notNull(i)));
           if (dart.notNull(this[_iterable][core.$length]) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     dart.setSignature(SubListIterable, {
       constructors: () => ({SubListIterable: [SubListIterable$(E), [core.Iterable$(E), core.int, core.int]]}),
@@ skipping 44 matching lines @@
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
     let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _f = dart.JsSymbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
-      MappedIterable(iterable, func) {
+      static new(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) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
@@ skipping 15 matching lines @@
       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.setSignature(MappedIterable, {
       constructors: () => ({
-        MappedIterable: [MappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]],
+        new: [MappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]],
         _: [MappedIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S])]]
       }),
       methods: () => ({[core.$elementAt]: [T, [core.int]]})
     });
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$();
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
@@ skipping 163 matching lines @@
         [_nextExpansion]: [dart.void, []],
         moveNext: [core.bool, []]
       })
     });
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$();
   let _takeCount = dart.JsSymbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
-      TakeIterable(iterable, takeCount) {
+      static new(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) {
         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.setSignature(TakeIterable, {
       constructors: () => ({
-        TakeIterable: [TakeIterable$(E), [core.Iterable$(E), core.int]],
+        new: [TakeIterable$(E), [core.Iterable$(E), core.int]],
         _: [TakeIterable$(E), [core.Iterable$(E), core.int]]
       })
     });
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$();
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super._(iterable, takeCount);
@@ skipping 84 matching lines @@
     dart.setSignature(TakeWhileIterator, {
       constructors: () => ({TakeWhileIterator: [TakeWhileIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeWhileIterator;
   });
   let TakeWhileIterator = TakeWhileIterator$();
   let _skipCount = dart.JsSymbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
-      SkipIterable(iterable, count) {
+      static new(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
         return new (SkipIterable$(E))._(iterable, count);
       }
       _(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.setSignature(SkipIterable, {
       constructors: () => ({
-        SkipIterable: [SkipIterable$(E), [core.Iterable$(E), core.int]],
+        new: [SkipIterable$(E), [core.Iterable$(E), core.int]],
         _: [SkipIterable$(E), [core.Iterable$(E), core.int]]
       }),
       methods: () => ({[core.$skip]: [core.Iterable$(E), [core.int]]})
     });
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
@@ skipping 179 matching lines @@
       [core.$take](count) {
         core.RangeError.checkNotNegative(count, "count");
         return this;
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return this;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return growable ? dart.setType([], core.List$(E)) : new (core.List$(E))(0);
+        return growable ? dart.setType([], core.List$(E)) : core.List$(E).new(0);
       }
       [core.$toSet]() {
-        return new (core.Set$(E))();
+        return core.Set$(E).new();
       }
     }
     EmptyIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EmptyIterable, {
       constructors: () => ({EmptyIterable: [EmptyIterable$(E), []]}),
       methods: () => ({
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [core.$elementAt]: [E, [core.int]],
         [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
         [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
@@ skipping 199 matching lines @@
       static elementAt(iterable, index) {
         if (!(typeof index == 'number'))
           throw new core.ArgumentError.notNull("index");
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of iterable) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
-        throw new core.RangeError.index(index, iterable, "index", null, elementIndex);
+        throw core.RangeError.index(index, iterable, "index", null, elementIndex);
       }
       static join(iterable, separator) {
         if (separator === void 0)
           separator = null;
         let buffer = new core.StringBuffer();
         buffer.writeAll(iterable, separator);
         return dart.toString(buffer);
       }
       static joinList(list, separator) {
         if (separator === void 0)
@@ skipping 15 matching lines @@
           }
         }
         return dart.toString(buffer);
       }
       where(iterable, f) {
         dart.as(f, dart.functionType(core.bool, [dart.bottom]));
         return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, __CastType6));
       }
       static map(iterable, f) {
         dart.as(f, dart.functionType(core.Object, [dart.bottom]));
-        return new MappedIterable(iterable, f);
+        return MappedIterable.new(iterable, f);
       }
       static mapList(list, f) {
         dart.as(f, dart.functionType(core.Object, [dart.bottom]));
         return new MappedListIterable(list, f);
       }
       static expand(iterable, f) {
         dart.as(f, dart.functionType(core.Iterable, [dart.bottom]));
         return new ExpandIterable(iterable, f);
       }
       takeList(list, n) {
@@ skipping 14 matching lines @@
         return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));
       }
       static sortList(list, compare) {
         dart.as(compare, dart.functionType(core.int, [dart.bottom, dart.bottom]));
         if (compare == null)
           compare = core.Comparable.compare;
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
         if (random == null)
-          random = new math.Random();
+          random = math.Random.new();
         let length = list[core.$length];
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
           length = dart.notNull(length) - 1;
           let tmp = list[core.$get](length);
           list[core.$set](length, list[core.$get](pos));
           list[core.$set](pos, tmp);
         }
       }
       static indexOfList(list, element, start) {
@@ skipping 975 matching lines @@
     }),
     names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
   });
   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-)';
   let POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
-      return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
+      return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
     get symbolPattern() {
-      return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
+      return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
     }
   });
   // Exports:
   exports.EfficientLength = EfficientLength;
   exports.ListIterable$ = ListIterable$;
   exports.ListIterable = ListIterable;
   exports.SubListIterable$ = SubListIterable$;
   exports.SubListIterable = SubListIterable;
   exports.ListIterator$ = ListIterator$;
   exports.ListIterator = ListIterator;
@@ skipping 56 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, core, collection, math, _interceptors, _js_primitives);