fixes #193, factory constructors as static methods

lib/runtime/dart/_isolate_helper.js

 var _isolate_helper = dart.defineLibrary(_isolate_helper, {});
 var core = dart.import(core);
 var _native_typed_data = dart.import(_native_typed_data);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_helper = dart.lazyImport(_js_helper);
 var isolate = dart.import(isolate);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var collection = dart.import(collection);
 var async = dart.import(async);
@@ skipping 15 matching lines @@
   dart.fn(_clone);
   let _serializeSendPorts = Symbol('_serializeSendPorts');
   let _workerId = Symbol('_workerId');
   let _isolateId = Symbol('_isolateId');
   let _receivePortId = Symbol('_receivePortId');
   let _id = Symbol('_id');
   let _receivePort = Symbol('_receivePort');
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
-      this.serializedObjectIds = new (core.Map$(core.Object, core.int)).identity();
+      this.serializedObjectIds = core.Map$(core.Object, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (this.isPrimitive(x))
         return this.serializePrimitive(x);
       let serializationId = this.serializedObjectIds.get(x);
       if (serializationId != null)
         return this.makeRef(serializationId);
       serializationId = this.serializedObjectIds.length;
       this.serializedObjectIds.set(x, serializationId);
@@ skipping 136 matching lines @@
       serializeJsSendPort: [core.Object, [_NativeJsSendPort]],
       serializeCapability: [core.Object, [CapabilityImpl]],
       serializeClosure: [core.Object, [_js_helper.Closure]],
       serializeDartObject: [core.Object, [core.Object]]
     })
   });
   let _adjustSendPorts = Symbol('_adjustSendPorts');
   class _Deserializer extends core.Object {
     _Deserializer(opts) {
       let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendPorts : true;
-      this.deserializedObjects = new core.List();
+      this.deserializedObjects = core.List.new();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
       if (this.isPrimitive(x))
         return this.deserializePrimitive(x);
       if (!dart.is(x, _interceptors.JSArray))
         throw new core.ArgumentError(`Bad serialized message: ${x}`);
       switch (dart.dload(x, 'first')) {
         case "ref":
         {
@@ skipping 79 matching lines @@
     deserializeArrayInPlace(x) {
       for (let i = 0; dart.notNull(i) < dart.notNull(x[core.$length]); i = dart.notNull(i) + 1) {
         x[core.$set](i, this.deserialize(x[core.$get](i)));
       }
       return x;
     }
     deserializeFixed(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'fixed'));
       let result = dart.as(dart.dindex(x, 1), core.List);
       this.deserializedObjects[core.$add](result);
-      return new _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
+      return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
     }
     deserializeExtendable(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'extendable'));
       let result = dart.as(dart.dindex(x, 1), core.List);
       this.deserializedObjects[core.$add](result);
-      return new _interceptors.JSArray.markGrowable(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
+      return _interceptors.JSArray.markGrowable(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
     }
     deserializeMutable(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'mutable'));
       let result = dart.as(dart.dindex(x, 1), core.List);
       this.deserializedObjects[core.$add](result);
       return this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray));
     }
     deserializeConst(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'const'));
       let result = dart.as(dart.dindex(x, 1), core.List);
       this.deserializedObjects[core.$add](result);
-      return new _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
+      return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
     }
     deserializeMap(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'map'));
       let keys = dart.as(dart.dindex(x, 1), core.List);
       let values = dart.as(dart.dindex(x, 2), core.List);
       let result = dart.map();
       this.deserializedObjects[core.$add](result);
       keys = keys[core.$map](dart.bind(this, 'deserialize'))[core.$toList]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys[core.$length]); i = dart.notNull(i) + 1) {
         result.set(keys[core.$get](i), this.deserialize(values[core.$get](i)));
@@ skipping 155 matching lines @@
       this.rootContext = null;
       this.topEventLoop = null;
       this.fromCommandLine = null;
       this.isWorker = null;
       this.supportsWorkers = null;
       this.isolates = null;
       this.mainManager = null;
       this.managers = null;
       this[_nativeDetectEnvironment]();
       this.topEventLoop = new _EventLoop();
-      this.isolates = new (core.Map$(core.int, _IsolateContext))();
-      this.managers = new (core.Map$(core.int, core.Object))();
+      this.isolates = core.Map$(core.int, _IsolateContext).new();
+      this.managers = core.Map$(core.int, core.Object).new();
       if (this.isWorker) {
         this.mainManager = new _MainManagerStub();
         this[_nativeInitWorkerMessageHandler]();
       }
     }
     [_nativeDetectEnvironment]() {
       let isWindowDefined = exports.globalWindow != null;
       let isWorkerDefined = exports.globalWorker != null;
       this.isWorker = !dart.notNull(isWindowDefined) && dart.notNull(exports.globalPostMessageDefined);
       this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(isWorkerDefined) && IsolateNatives.thisScript != null;
@@ skipping 41 matching lines @@
   let _setGlobals = Symbol('_setGlobals');
   let _addRegistration = Symbol('_addRegistration');
   let _close = Symbol('_close');
   class _IsolateContext extends core.Object {
     _IsolateContext() {
       this.id = (() => {
         let o = exports._globalState, x = o.nextIsolateId;
         o.nextIsolateId = dart.notNull(x) + 1;
         return x;
       })();
-      this.ports = new (core.Map$(core.int, RawReceivePortImpl))();
-      this.weakPorts = new (core.Set$(core.int))();
+      this.ports = core.Map$(core.int, RawReceivePortImpl).new();
+      this.weakPorts = core.Set$(core.int).new();
       this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
       this.controlPort = new RawReceivePortImpl._controlPort();
-      this.pauseCapability = new isolate.Capability();
-      this.terminateCapability = new isolate.Capability();
+      this.pauseCapability = isolate.Capability.new();
+      this.terminateCapability = isolate.Capability.new();
       this.delayedEvents = dart.setType([], core.List$(_IsolateEvent));
-      this.pauseTokens = new (core.Set$(isolate.Capability))();
-      this.errorPorts = new (core.Set$(isolate.SendPort))();
+      this.pauseTokens = core.Set$(isolate.Capability).new();
+      this.errorPorts = core.Set$(isolate.SendPort).new();
       this.initialized = false;
       this.isPaused = false;
       this.doneHandlers = null;
       this[_scheduledControlEvents] = null;
       this[_isExecutingEvent] = false;
       this.errorsAreFatal = true;
       this.registerWeak(this.controlPort[_id], this.controlPort);
     }
     addPause(authentification, resume) {
       if (!dart.equals(this.pauseCapability, authentification))
@@ skipping 42 matching lines @@
       let respond = () => {
         responsePort.send(null);
       };
       dart.fn(respond, dart.void, []);
       if (pingType == isolate.Isolate.AS_EVENT) {
         exports._globalState.topEventLoop.enqueue(this, respond, "ping");
         return;
       }
       dart.assert(pingType == isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this[_scheduledControlEvents] == null) {
-        this[_scheduledControlEvents] = new collection.Queue();
+        this[_scheduledControlEvents] = collection.Queue.new();
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', respond);
     }
     handleKill(authentification, priority) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
       if (priority == isolate.Isolate.IMMEDIATE || priority == isolate.Isolate.BEFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
         this.kill();
         return;
       }
       if (priority == isolate.Isolate.AS_EVENT) {
         exports._globalState.topEventLoop.enqueue(this, dart.bind(this, 'kill'), "kill");
         return;
       }
       dart.assert(priority == isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this[_scheduledControlEvents] == null) {
-        this[_scheduledControlEvents] = new collection.Queue();
+        this[_scheduledControlEvents] = collection.Queue.new();
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', dart.bind(this, 'kill'));
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
       if (this.errorPorts[core.$isEmpty]) {
         if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, exports._globalState.rootContext))) {
           return;
         }
         if (self.console && self.console.error) {
           self.console.error(error, stackTrace);
         } else {
           core.print(error);
           if (stackTrace != null)
             core.print(stackTrace);
         }
         return;
       }
-      let message = new core.List(2);
+      let message = core.List.new(2);
       message[core.$set](0, dart.toString(error));
       message[core.$set](1, stackTrace == null ? null : dart.toString(stackTrace));
       for (let port of this.errorPorts)
         port.send(message);
     }
     eval(code) {
       let old = exports._globalState.currentContext;
       exports._globalState.currentContext = this;
       this[_setGlobals]();
       let result = null;
@@ skipping 74 matching lines @@
           break;
         }
         default:
       }
     }
     lookup(portId) {
       return this.ports.get(portId);
     }
     [_addRegistration](portId, port) {
       if (this.ports.containsKey(portId)) {
-        throw new core.Exception("Registry: ports must be registered only once.");
+        throw core.Exception.new("Registry: ports must be registered only once.");
       }
       this.ports.set(portId, port);
     }
     register(portId, port) {
       this[_addRegistration](portId, port);
       this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
       this[_addRegistration](portId, port);
@@ skipping 51 matching lines @@
       register: [dart.void, [core.int, RawReceivePortImpl]],
       registerWeak: [dart.void, [core.int, RawReceivePortImpl]],
       [_updateGlobalState]: [dart.void, []],
       kill: [dart.void, []],
       unregister: [dart.void, [core.int]]
     })
   });
   let _runHelper = Symbol('_runHelper');
   class _EventLoop extends core.Object {
     _EventLoop() {
-      this.events = new (collection.Queue$(_IsolateEvent))();
+      this.events = collection.Queue$(_IsolateEvent).new();
       this[_activeJsAsyncCount] = 0;
     }
     enqueue(isolate, fn, msg) {
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (this.events[core.$isEmpty])
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
       if (dart.notNull(exports._globalState.rootContext != null) && dart.notNull(exports._globalState.isolates.containsKey(exports._globalState.rootContext.id)) && dart.notNull(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.rootContext.ports.isEmpty)) {
-        throw new core.Exception("Program exited with open ReceivePorts.");
+        throw core.Exception.new("Program exited with open ReceivePorts.");
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
@@ skipping 205 matching lines @@
         }, core.Object, [core.String])});
     }
     static _log(msg) {
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           IsolateNatives._consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
-          throw new core.Exception(trace);
+          throw core.Exception.new(trace);
         }
 
       }
     }
     static _consoleLog(msg) {
       _js_helper.requiresPreamble();
       self.console.log(msg);
     }
     static _getJSFunctionFromName(functionName) {
       let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", _js_embedded_names.GLOBAL_FUNCTIONS);
@@ skipping 18 matching lines @@
     static spawnUri(uri, args, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let isLight = false;
       let isSpawnUri = true;
       return IsolateNatives.spawn(null, dart.toString(uri), args, message, isLight, isSpawnUri, startPaused);
     }
     static spawn(functionName, uri, args, message, isLight, isSpawnUri, startPaused) {
       if (uri != null && dart.notNull(uri.endsWith(".dart"))) {
         uri = dart.notNull(uri) + ".js";
       }
-      let port = new isolate.ReceivePort();
-      let completer = new (async.Completer$(core.List))();
+      let port = isolate.ReceivePort.new();
+      let completer = async.Completer$(core.List).new();
       port.first.then(dart.fn(msg => {
         if (dart.equals(dart.dindex(msg, 0), _SPAWNED_SIGNAL)) {
           completer.complete(msg);
         } else {
           dart.assert(dart.equals(dart.dindex(msg, 0), _SPAWN_FAILED_SIGNAL));
           completer.completeError(dart.dindex(msg, 1));
         }
       }));
       let signalReply = port.sendPort;
       if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight)) {
         IsolateNatives._startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, dart.fn(message => completer.completeError(message), dart.void, [core.String]));
       } else {
         IsolateNatives._startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply);
       }
       return completer.future;
     }
     static _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (args != null)
-        args = new (core.List$(core.String)).from(args);
+        args = core.List$(core.String).from(args);
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort})));
       } else {
         IsolateNatives._spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError);
       }
     }
     static _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
       if (uri != null) {
         throw new core.UnsupportedError("Currently spawnUri is not supported without web workers.");
       }
       message = _clone(message);
       if (args != null)
-        args = new (core.List$(core.String)).from(args);
+        args = core.List$(core.String).from(args);
       exports._globalState.topEventLoop.enqueue(new _IsolateContext(), dart.fn(() => {
         let func = IsolateNatives._getJSFunctionFromName(functionName);
         IsolateNatives._startIsolate(dart.as(func, core.Function), args, message, isSpawnUri, startPaused, replyPort);
       }), 'nonworker start');
     }
     static get currentIsolate() {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       return new isolate.Isolate(context.controlPort.sendPort, {pauseCapability: context.pauseCapability, terminateCapability: context.terminateCapability});
     }
     static _startIsolate(topLevel, args, message, isSpawnUri, startPaused, replyTo) {
@@ skipping 91 matching lines @@
       return new (core.Expando$(core.int))();
     }
   });
   let _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends core.Object {
     _BaseSendPort(isolateId) {
       this[_isolateId] = isolateId;
     }
     [_checkReplyTo](replyTo) {
       if (dart.notNull(replyTo != null) && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(replyTo, _WorkerSendPort)) {
-        throw new core.Exception("SendPort.send: Illegal replyTo port type");
+        throw core.Exception.new("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_BaseSendPort, {
     constructors: () => ({_BaseSendPort: [_BaseSendPort, [core.int]]}),
     methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
   });
   let _isClosed = Symbol('_isClosed');
   let _add = Symbol('_add');
@@ skipping 132 matching lines @@
     ReceivePortImpl() {
       this.fromRawReceivePort(new RawReceivePortImpl(null));
     }
     weak() {
       this.fromRawReceivePort(new RawReceivePortImpl.weak(null));
     }
     fromRawReceivePort(rawPort) {
       this[_rawPort] = rawPort;
       this[_controller] = null;
       super.Stream();
-      this[_controller] = new async.StreamController({onCancel: dart.bind(this, 'close'), sync: true});
+      this[_controller] = async.StreamController.new({onCancel: dart.bind(this, 'close'), sync: true});
       this[_rawPort].handler = dart.bind(this[_controller], 'add');
     }
     listen(onData, opts) {
       let onError = opts && 'onError' in opts ? opts.onError : null;
       let onDone = opts && 'onDone' in opts ? opts.onDone : null;
       let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
       return this[_controller].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
     }
     close() {
       this[_rawPort].close();
@@ skipping 138 matching lines @@
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper, core, _native_typed_data, _interceptors, _js_helper, isolate, _foreign_helper, _js_embedded_names, collection, async);