fixes #193, factory constructors as static methods

lib/runtime/dart/_js_helper.js

 var _js_helper = dart.defineLibrary(_js_helper, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var _internal = dart.import(_internal);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_names = dart.import(_js_names);
 var async = dart.import(async);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
@@ skipping 124 matching lines @@
         let keys = this[_keys];
         for (let i = 0; dart.notNull(i) < dart.notNull(dart.as(dart.dload(keys, 'length'), core.num)); i = dart.notNull(i) + 1) {
           let key = dart.dindex(keys, i);
           f(dart.as(key, K), dart.as(this[_fetch](key), V));
         }
       }
       get keys() {
         return new (_ConstantMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [core.Object]));
+        return _internal.MappedIterable$(K, V).new(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [core.Object]));
       }
     }
     ConstantStringMap[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(ConstantStringMap, '_');
     dart.setSignature(ConstantStringMap, {
       constructors: () => ({_: [ConstantStringMap$(K, V), [core.int, core.Object, core.List$(K)]]}),
       methods: () => ({
         containsValue: [core.bool, [core.Object]],
         containsKey: [core.bool, [core.Object]],
         get: [V, [core.Object]],
@@ skipping 52 matching lines @@
   let _jsData = Symbol('_jsData');
   let _getMap = Symbol('_getMap');
   let GeneralConstantMap$ = dart.generic(function(K, V) {
     class GeneralConstantMap extends ConstantMap$(K, V) {
       GeneralConstantMap(jsData) {
         this[_jsData] = jsData;
         super._();
       }
       [_getMap]() {
         if (!this.$map) {
-          let backingMap = new (collection.LinkedHashMap$(K, V))();
+          let backingMap = collection.LinkedHashMap$(K, V).new();
           this.$map = fillLiteralMap(this[_jsData], backingMap);
         }
         return dart.as(this.$map, core.Map$(K, V));
       }
       containsValue(needle) {
         return this[_getMap]().containsValue(needle);
       }
       containsKey(key) {
         return this[_getMap]().containsKey(key);
       }
@@ skipping 548 matching lines @@
     get groupCount() {
       return 0;
     }
     group(group_) {
       if (group_ != 0) {
         throw new core.RangeError.value(group_);
       }
       return this.pattern;
     }
     groups(groups_) {
-      let result = new (core.List$(core.String))();
+      let result = core.List$(core.String).new();
       for (let g of groups_) {
         result[core.$add](this.group(g));
       }
       return result;
     }
   }
   StringMatch[dart.implements] = () => [core.Match];
   dart.setSignature(StringMatch, {
     constructors: () => ({StringMatch: [StringMatch, [core.int, core.String, core.String]]}),
     methods: () => ({
       get: [core.String, [core.int]],
       group: [core.String, [core.int]],
       groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   function allMatchesInStringUnchecked(needle, haystack, startIndex) {
-    let result = new (core.List$(core.Match))();
+    let result = core.List$(core.Match).new();
     let length = haystack.length;
     let patternLength = needle.length;
     while (true) {
       let position = haystack.indexOf(needle, startIndex);
       if (position == -1) {
         break;
       }
       result[core.$add](new StringMatch(position, haystack, needle));
       let endIndex = dart.notNull(position) + dart.notNull(patternLength);
       if (endIndex == length) {
@@ skipping 755 matching lines @@
       }
       return dart.as(makeLiteralListConst(list), core.List);
     }
     get namedArguments() {
       if (this.isAccessor)
         return dart.map();
       let namedArgumentCount = this[_namedArgumentNames][core.$length];
       let namedArgumentsStartIndex = dart.notNull(this[_arguments][core.$length]) - dart.notNull(namedArgumentCount);
       if (namedArgumentCount == 0)
         return dart.map();
-      let map = new (core.Map$(core.Symbol, core.Object))();
+      let map = core.Map$(core.Symbol, core.Object).new();
       for (let i = 0; dart.notNull(i) < dart.notNull(namedArgumentCount); i = dart.notNull(i) + 1) {
         map.set(new _internal.Symbol.unvalidated(dart.as(this[_namedArgumentNames][core.$get](i), core.String)), this[_arguments][core.$get](dart.notNull(namedArgumentsStartIndex) + dart.notNull(i)));
       }
       return map;
     }
     [_getCachedInvocation](object) {
       let interceptor = _interceptors.getInterceptor(object);
       let receiver = object;
       let name = this[_internalName];
       let arguments$ = this[_arguments];
@@ skipping 69 matching lines @@
     get isNoSuchMethod() {
       return false;
     }
     get isGetterStub() {
       return !!this.jsFunction.$getterStub;
     }
     invokeOn(victim, arguments$) {
       let receiver = victim;
       if (!dart.notNull(this.isIntercepted)) {
         if (!dart.is(arguments$, _interceptors.JSArray))
-          arguments$ = new core.List.from(arguments$);
+          arguments$ = core.List.from(arguments$);
       } else {
         let _ = [victim];
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
   dart.setSignature(CachedInvocation, {
     constructors: () => ({CachedInvocation: [CachedInvocation, [core.String, core.Object, core.bool, _interceptors.Interceptor]]}),
     methods: () => ({invokeOn: [core.Object, [core.Object, core.List]]})
   });
   class CachedCatchAllInvocation extends CachedInvocation {
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
-      this.info = new ReflectionInfo(jsFunction);
+      this.info = ReflectionInfo.new(jsFunction);
       super.CachedInvocation(name, jsFunction, isIntercepted, cachedInterceptor);
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, arguments$) {
       let receiver = victim;
       let providedArgumentCount = null;
       let fullParameterCount = dart.notNull(this.info.requiredParameterCount) + dart.notNull(this.info.optionalParameterCount);
       if (!dart.notNull(this.isIntercepted)) {
         if (dart.is(arguments$, _interceptors.JSArray)) {
           providedArgumentCount = arguments$[core.$length];
           if (dart.notNull(providedArgumentCount) < dart.notNull(fullParameterCount)) {
-            arguments$ = new core.List.from(arguments$);
+            arguments$ = core.List.from(arguments$);
           }
         } else {
-          arguments$ = new core.List.from(arguments$);
+          arguments$ = core.List.from(arguments$);
           providedArgumentCount = arguments$[core.$length];
         }
       } else {
         let _ = [victim];
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
         providedArgumentCount = dart.notNull(arguments$[core.$length]) - 1;
       }
@@ skipping 36 matching lines @@
     internal(jsFunction, data, isAccessor, requiredParameterCount, optionalParameterCount, areOptionalParametersNamed, functionType) {
       this.jsFunction = jsFunction;
       this.data = data;
       this.isAccessor = isAccessor;
       this.requiredParameterCount = requiredParameterCount;
       this.optionalParameterCount = optionalParameterCount;
       this.areOptionalParametersNamed = areOptionalParametersNamed;
       this.functionType = functionType;
       this.cachedSortedIndices = null;
     }
-    ReflectionInfo(jsFunction) {
+    static new(jsFunction) {
       let data = dart.as(jsFunction.$reflectionInfo, core.List);
       if (data == null)
         return null;
       data = _interceptors.JSArray.markFixedList(data);
       let requiredParametersInfo = data[ReflectionInfo.REQUIRED_PARAMETERS_INFO];
       let requiredParameterCount = requiredParametersInfo >> 1;
       let isAccessor = (dart.notNull(requiredParametersInfo) & 1) == 1;
       let optionalParametersInfo = data[ReflectionInfo.OPTIONAL_PARAMETERS_INFO];
       let optionalParameterCount = optionalParametersInfo >> 1;
       let areOptionalParametersNamed = (dart.notNull(optionalParametersInfo) & 1) == 1;
@@ skipping 35 matching lines @@
       if (dart.notNull(parameter) < dart.notNull(this.requiredParameterCount))
         return null;
       if (!dart.notNull(this.areOptionalParametersNamed) || this.optionalParameterCount == 1) {
         return this.parameterName(parameter);
       }
       let index = this.sortedIndex(dart.notNull(parameter) - dart.notNull(this.requiredParameterCount));
       return this.parameterName(index);
     }
     sortedIndex(unsortedIndex) {
       if (this.cachedSortedIndices == null) {
-        this.cachedSortedIndices = new core.List(this.optionalParameterCount);
+        this.cachedSortedIndices = core.List.new(this.optionalParameterCount);
         let positions = dart.map();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.optionalParameterCount); i = dart.notNull(i) + 1) {
           let index = dart.notNull(this.requiredParameterCount) + dart.notNull(i);
           positions.set(this.parameterName(index), index);
         }
         let index = 0;
         (() => {
           let _ = positions.keys[core.$toList]();
           _[core.$sort]();
           return _;
@@ skipping 19 matching lines @@
       }
     }
     get reflectionName() {
       return this.jsFunction.$reflectionName;
     }
   }
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   dart.setSignature(ReflectionInfo, {
     constructors: () => ({
       internal: [ReflectionInfo, [core.Object, core.List, core.bool, core.int, core.int, core.bool, core.Object]],
-      ReflectionInfo: [ReflectionInfo, [core.Object]]
+      new: [ReflectionInfo, [core.Object]]
     }),
     methods: () => ({
       parameterName: [core.String, [core.int]],
       parameterMetadataAnnotations: [core.List$(core.int), [core.int]],
       defaultValue: [core.int, [core.int]],
       defaultValueInOrder: [core.int, [core.int]],
       parameterNameInOrder: [core.String, [core.int]],
       sortedIndex: [core.int, [core.int]],
       computeFunctionRti: [core.Object, [core.Object]]
     })
@@ skipping 327 matching lines @@
     static applyFunction(func, positionalArguments, namedArguments) {
       return namedArguments == null ? Primitives.applyFunctionWithPositionalArguments(func, positionalArguments) : Primitives.applyFunctionWithNamedArguments(func, positionalArguments, namedArguments);
     }
     static applyFunctionWithPositionalArguments(func, positionalArguments) {
       let argumentCount = 0;
       let arguments$ = null;
       if (positionalArguments != null) {
         if (positionalArguments instanceof Array) {
           arguments$ = positionalArguments;
         } else {
-          arguments$ = new core.List.from(positionalArguments);
+          arguments$ = core.List.from(positionalArguments);
         }
         argumentCount = arguments$.length;
       } else {
         arguments$ = [];
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}`;
       let jsFunction = func[selectorName];
       if (jsFunction == null) {
         return Primitives.functionNoSuchMethod(func, positionalArguments, null);
       }
       return jsFunction.apply(func, arguments$);
     }
     static applyFunctionWithNamedArguments(func, positionalArguments, namedArguments) {
       if (namedArguments.isEmpty) {
         return Primitives.applyFunctionWithPositionalArguments(func, positionalArguments);
       }
       let interceptor = _interceptors.getInterceptor(func);
       let jsFunction = interceptor["call*"];
       if (jsFunction == null) {
         return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
-      let info = new ReflectionInfo(jsFunction);
+      let info = ReflectionInfo.new(jsFunction);
       if (dart.notNull(info == null) || !dart.notNull(info.areOptionalParametersNamed)) {
         return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       if (positionalArguments != null) {
-        positionalArguments = new core.List.from(positionalArguments);
+        positionalArguments = core.List.from(positionalArguments);
       } else {
         positionalArguments = [];
       }
       if (info.requiredParameterCount != positionalArguments[core.$length]) {
         return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
-      let defaultArguments = new core.Map();
+      let defaultArguments = core.Map.new();
       for (let i = 0; dart.notNull(i) < dart.notNull(info.optionalParameterCount); i = dart.notNull(i) + 1) {
         let index = dart.notNull(i) + dart.notNull(info.requiredParameterCount);
         let parameterName = info.parameterNameInOrder(index);
         let value = info.defaultValueInOrder(index);
         let defaultValue = getMetadata(value);
         defaultArguments.set(parameterName, defaultValue);
       }
       let bad = false;
       namedArguments.forEach(dart.fn((parameter, value) => {
         if (defaultArguments.containsKey(parameter)) {
@@ skipping 556 matching lines @@
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure)));
     } else if (numberOfArguments == 1) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1)));
     } else if (numberOfArguments == 2) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2)));
     } else if (numberOfArguments == 3) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2, arg3)));
     } else if (numberOfArguments == 4) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2, arg3, arg4)));
     } else {
-      throw new core.Exception('Unsupported number of arguments for wrapped closure');
+      throw core.Exception.new('Unsupported number of arguments for wrapped closure');
     }
   }
   dart.fn(invokeClosure, core.Object, [core.Function, core.Object, core.int, core.Object, core.Object, core.Object, core.Object]);
   function convertDartClosureToJS(closure, arity) {
     return closure;
   }
   dart.fn(convertDartClosureToJS, core.Object, [core.Object, core.int]);
   class Closure extends core.Object {
     Closure() {
     }
     static fromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, propertyName) {
       _foreign_helper.JS_EFFECT(dart.fn(() => {
         BoundClosure.receiverOf(dart.as(void 0, BoundClosure));
         BoundClosure.selfOf(dart.as(void 0, BoundClosure));
       }));
       let func = functions[0];
       let name = dart.as(func.$stubName, core.String);
       let callName = dart.as(func.$callName, core.String);
       func.$reflectionInfo = reflectionInfo;
-      let info = new ReflectionInfo(func);
+      let info = ReflectionInfo.new(func);
       let functionType = info.functionType;
       let prototype = isStatic ? Object.create(new TearOffClosure().constructor.prototype) : Object.create(new BoundClosure(null, null, null, null).constructor.prototype);
       prototype.$initialize = prototype.constructor;
       let constructor = isStatic ? function() {
         this.$initialize();
       } : Closure.isCsp ? function(a, b, c, d) {
         this.$initialize(a, b, c, d);
       } : new Function("a", "b", "c", "d", "this.$initialize(a,b,c,d);" + (() => {
         let x = Closure.functionCounter;
         Closure.functionCounter = dart.notNull(x) + 1;
@@ skipping 696 matching lines @@
       if (!(typeof condition == 'boolean')) {
         throw new TypeErrorImplementation(condition, 'bool');
       }
     }
     if (!dart.equals(true, condition))
       throw new core.AssertionError();
   }
   dart.fn(assertHelper, dart.void, [core.Object]);
   function throwNoSuchMethod(obj, name, arguments$, expectedArgumentNames) {
     let memberName = new _internal.Symbol.unvalidated(dart.as(name, core.String));
-    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), new (core.Map$(core.Symbol, core.Object))(), dart.as(expectedArgumentNames, core.List));
+    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), core.Map$(core.Symbol, core.Object).new(), dart.as(expectedArgumentNames, core.List));
   }
   dart.fn(throwNoSuchMethod, dart.void, [core.Object, core.Object, core.Object, core.Object]);
   function throwCyclicInit(staticName) {
     throw new core.CyclicInitializationError(`Cyclic initialization for static ${staticName}`);
   }
   dart.fn(throwCyclicInit, dart.void, [core.String]);
   class RuntimeError extends core.Error {
     RuntimeError(message) {
       this.message = message;
       super.Error();
@@ skipping 458 matching lines @@
   let LoadLibraryFunctionType = dart.typedef('LoadLibraryFunctionType', () => dart.functionType(async.Future$(core.Null), []));
   function _loadLibraryWrapper(loadId) {
     return dart.fn(() => loadDeferredLibrary(loadId), async.Future$(core.Null), []);
   }
   dart.fn(_loadLibraryWrapper, LoadLibraryFunctionType, [core.String]);
   dart.defineLazyProperties(exports, {
     get _loadingLibraries() {
       return dart.map();
     },
     get _loadedLibraries() {
-      return new (core.Set$(core.String))();
+      return core.Set$(core.String).new();
     }
   });
   let DeferredLoadCallback = dart.typedef('DeferredLoadCallback', () => dart.functionType(dart.void, []));
   exports.deferredLoadHook = null;
   function loadDeferredLibrary(loadId) {
     let urisMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_URIS);
     let uris = dart.as(urisMap[loadId], core.List$(core.String));
     let hashesMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_HASHES);
     let hashes = dart.as(hashesMap[loadId], core.List$(core.String));
     if (uris == null)
-      return new (async.Future$(core.Null)).value(null);
-    let indices = new (core.List$(core.int)).generate(uris[core.$length], dart.fn(i => dart.as(i, core.int), core.int, [core.Object]));
+      return async.Future$(core.Null).value(null);
+    let indices = core.List$(core.int).generate(uris[core.$length], dart.fn(i => dart.as(i, core.int), core.int, [core.Object]));
     let isHunkLoaded = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.IS_HUNK_LOADED);
     let isHunkInitialized = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.IS_HUNK_INITIALIZED);
     let indicesToLoad = indices[core.$where](dart.fn(i => !isHunkLoaded(hashes[core.$get](i)), core.bool, [core.int]))[core.$toList]();
     return dart.as(async.Future.wait(dart.as(indicesToLoad[core.$map](dart.fn(i => _loadHunk(uris[core.$get](i)), async.Future$(core.Null), [core.int])), core.Iterable$(async.Future))).then(dart.fn(_ => {
       let indicesToInitialize = indices[core.$where](dart.fn(i => !isHunkInitialized(hashes[core.$get](i)), core.bool, [core.int]))[core.$toList]();
       for (let i of indicesToInitialize) {
         let initializer = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INITIALIZE_LOADED_HUNK);
         initializer(hashes[core.$get](i));
       }
       let updated = exports._loadedLibraries.add(loadId);
       if (dart.notNull(updated) && dart.notNull(exports.deferredLoadHook != null)) {
         exports.deferredLoadHook();
       }
     })), async.Future$(core.Null));
   }
   dart.fn(loadDeferredLibrary, async.Future$(core.Null), [core.String]);
   function _loadHunk(hunkName) {
     let future = exports._loadingLibraries.get(hunkName);
     if (future != null) {
       return dart.as(future.then(dart.fn(_ => null, dart.bottom, [core.Object])), async.Future$(core.Null));
     }
     let uri = _isolate_helper.IsolateNatives.thisScript;
     let index = uri.lastIndexOf('/');
     uri = `${uri.substring(0, dart.notNull(index) + 1)}${hunkName}`;
     if (dart.notNull(Primitives.isJsshell) || dart.notNull(Primitives.isD8)) {
-      return exports._loadingLibraries.set(hunkName, new (async.Future$(core.Null))(dart.fn(() => {
+      return exports._loadingLibraries.set(hunkName, async.Future$(core.Null).new(dart.fn(() => {
         try {
           new Function(`load("${uri}")`)();
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           throw new async.DeferredLoadException(`Loading ${uri} failed.`);
         }
 
         return null;
       })));
     } else if (_isolate_helper.isWorker()) {
-      return exports._loadingLibraries.set(hunkName, new (async.Future$(core.Null))(dart.fn(() => {
-        let completer = new (async.Completer$(core.Null))();
+      return exports._loadingLibraries.set(hunkName, async.Future$(core.Null).new(dart.fn(() => {
+        let completer = async.Completer$(core.Null).new();
         _isolate_helper.enterJsAsync();
         let leavingFuture = dart.as(completer.future.whenComplete(dart.fn(() => {
           _isolate_helper.leaveJsAsync();
         })), async.Future$(core.Null));
         let index = uri.lastIndexOf('/');
         uri = `${uri.substring(0, dart.notNull(index) + 1)}${hunkName}`;
         let xhr = new XMLHttpRequest();
         xhr.open("GET", uri);
         xhr.addEventListener("load", convertDartClosureToJS(dart.fn(event => {
           if (xhr.status != 200) {
@@ skipping 13 matching lines @@
         }), 1), false);
         let fail = convertDartClosureToJS(dart.fn(event => {
           new async.DeferredLoadException(`Loading ${uri} failed.`);
         }), 1);
         xhr.addEventListener("error", fail, false);
         xhr.addEventListener("abort", fail, false);
         xhr.send();
         return leavingFuture;
       })));
     }
-    return exports._loadingLibraries.set(hunkName, new (async.Future$(core.Null))(dart.fn(() => {
-      let completer = new (async.Completer$(core.Null))();
+    return exports._loadingLibraries.set(hunkName, async.Future$(core.Null).new(dart.fn(() => {
+      let completer = async.Completer$(core.Null).new();
       let script = document.createElement("script");
       script.type = "text/javascript";
       script.src = uri;
       script.addEventListener("load", convertDartClosureToJS(dart.fn(event => {
         completer.complete(null);
       }), 1), false);
       script.addEventListener("error", convertDartClosureToJS(dart.fn(event => {
         completer.completeError(new async.DeferredLoadException(`Loading ${uri} failed.`));
       }), 1), false);
       document.body.appendChild(script);
@@ skipping 252 matching lines @@
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.LoadLibraryFunctionType = LoadLibraryFunctionType;
   exports.DeferredLoadCallback = DeferredLoadCallback;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper, core, collection, _internal, _foreign_helper, _js_embedded_names, _interceptors, _js_names, async, _isolate_helper);