Add constructors to signatures

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 147 matching lines @@
     }
     serializeDartObject(x) {
       let classExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CLASS_ID_EXTRACTOR);
       let fieldsExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CLASS_FIELDS_EXTRACTOR);
       let classId = classExtractor(x);
       let fields = dart.as(fieldsExtractor(x), core.List);
       return ['dart', classId, this.serializeArrayInPlace(dart.as(fields, _interceptors.JSArray))];
     }
   }
   dart.setSignature(_Serializer, {
+    constructors: () => ({_Serializer: [_Serializer, [], {erializeSendPort: core.Object}]}),
     methods: () => ({
       serialize: [core.Object, [core.Object]],
       unsupported: [dart.void, [core.Object], [core.String]],
       makeRef: [core.Object, [core.int]],
       isPrimitive: [core.bool, [core.Object]],
       serializePrimitive: [core.Object, [core.Object]],
       serializeByteBuffer: [core.Object, [_native_typed_data.NativeByteBuffer]],
       serializeTypedData: [core.Object, [_native_typed_data.NativeTypedData]],
       serializeJSIndexable: [core.Object, [_interceptors.JSIndexable]],
       serializeArray: [core.Object, [_interceptors.JSArray]],
@@ skipping 193 matching lines @@
       let fields = dart.as(dart.dindex(x, 2), core.List);
       let instanceFromClassId = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INSTANCE_FROM_CLASS_ID);
       let initializeObject = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INITIALIZE_EMPTY_INSTANCE);
       let emptyInstance = instanceFromClassId(classId);
       this.deserializedObjects[core.$add](emptyInstance);
       this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
       return initializeObject(classId, emptyInstance, fields);
     }
   }
   dart.setSignature(_Deserializer, {
+    constructors: () => ({_Deserializer: [_Deserializer, [], {djustSendPort: core.Object}]}),
     methods: () => ({
       deserialize: [core.Object, [core.Object]],
       isPrimitive: [core.bool, [core.Object]],
       deserializePrimitive: [core.Object, [core.Object]],
       deserializeRef: [core.Object, [core.Object]],
       deserializeByteBuffer: [_native_typed_data.NativeByteBuffer, [core.Object]],
       deserializeTypedData: [_native_typed_data.NativeTypedData, [core.Object]],
       deserializeArrayInPlace: [core.List, [_interceptors.JSArray]],
       deserializeFixed: [core.List, [core.Object]],
       deserializeExtendable: [core.List, [core.Object]],
@@ skipping 125 matching lines @@
     static _serializePrintMessage(object) {
       return _serializeMessage(dart.map({command: "print", msg: object}));
     }
     maybeCloseWorker() {
       if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] == 0) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   dart.setSignature(_Manager, {
+    constructors: () => ({_Manager: [_Manager, [core.Function]]}),
     methods: () => ({
       [_nativeDetectEnvironment]: [dart.void, []],
       [_nativeInitWorkerMessageHandler]: [dart.void, []],
       maybeCloseWorker: [dart.void, []]
     }),
     statics: () => ({_serializePrintMessage: [core.Object, [core.Object]]}),
     names: ['_serializePrintMessage']
   });
   let _scheduledControlEvents = Symbol('_scheduledControlEvents');
   let _isExecutingEvent = Symbol('_isExecutingEvent');
@@ skipping 253 matching lines @@
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
       this.weakPorts.remove(portId);
       this[_updateGlobalState]();
     }
   }
   _IsolateContext[dart.implements] = () => [_foreign_helper.IsolateContext];
   dart.setSignature(_IsolateContext, {
+    constructors: () => ({_IsolateContext: [_IsolateContext, []]}),
     methods: () => ({
       addPause: [dart.void, [isolate.Capability, isolate.Capability]],
       removePause: [dart.void, [isolate.Capability]],
       addDoneListener: [dart.void, [isolate.SendPort]],
       removeDoneListener: [dart.void, [isolate.SendPort]],
       setErrorsFatal: [dart.void, [isolate.Capability, core.bool]],
       handlePing: [dart.void, [isolate.SendPort, core.int]],
       handleKill: [dart.void, [isolate.Capability, core.int]],
       addErrorListener: [dart.void, [isolate.SendPort]],
       removeErrorListener: [dart.void, [isolate.SendPort]],
@@ skipping 64 matching lines @@
           this[_runHelper]();
         } catch (e) {
           let trace = dart.stackTrace(e);
           exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'error', msg: `${e}\n${trace}`})));
         }
 
       }
     }
   }
   dart.setSignature(_EventLoop, {
+    constructors: () => ({_EventLoop: [_EventLoop, []]}),
     methods: () => ({
       enqueue: [dart.void, [core.Object, core.Object, core.Object]],
       prequeue: [dart.void, [_IsolateEvent]],
       dequeue: [_IsolateEvent, []],
       checkOpenReceivePortsFromCommandLine: [dart.void, []],
       runIteration: [core.bool, []],
       [_runHelper]: [dart.void, []],
       run: [dart.void, []]
     })
   });
   class _IsolateEvent extends core.Object {
     _IsolateEvent(isolate, fn, message) {
       this.isolate = isolate;
       this.fn = fn;
       this.message = message;
     }
     process() {
       if (this.isolate.isPaused) {
         this.isolate.delayedEvents[core.$add](this);
         return;
       }
       this.isolate.eval(this.fn);
     }
   }
   dart.setSignature(_IsolateEvent, {
+    constructors: () => ({_IsolateEvent: [_IsolateEvent, [_IsolateContext, core.Function, core.String]]}),
     methods: () => ({process: [dart.void, []]})
   });
   class _MainManagerStub extends core.Object {
     postMessage(msg) {
       _js_helper.requiresPreamble();
       self.postMessage(msg);
     }
   }
   dart.setSignature(_MainManagerStub, {
     methods: () => ({postMessage: [dart.void, [core.Object]]})
@@ skipping 327 matching lines @@
       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");
       }
     }
   }
   _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');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort, isolateId) {
       this[_receivePort] = receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
@@ skipping 15 matching lines @@
     }
     ['=='](other) {
       return dart.is(other, _NativeJsSendPort) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, _receivePort)));
     }
     get hashCode() {
       return this[_receivePort][_id];
     }
   }
   _NativeJsSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_NativeJsSendPort, {
+    constructors: () => ({_NativeJsSendPort: [_NativeJsSendPort, [RawReceivePortImpl, core.int]]}),
     methods: () => ({send: [dart.void, [core.Object]]})
   });
   class _WorkerSendPort extends _BaseSendPort {
     _WorkerSendPort(workerId, isolateId, receivePortId) {
       this[_workerId] = workerId;
       this[_receivePortId] = receivePortId;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(workerMessage);
       } else {
         let manager = exports._globalState.managers.get(this[_workerId]);
         if (manager != null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
       return dart.is(other, _WorkerSendPort) && dart.equals(this[_workerId], dart.dload(other, _workerId)) && dart.equals(this[_isolateId], dart.dload(other, _isolateId)) && dart.equals(this[_receivePortId], dart.dload(other, _receivePortId));
     }
     get hashCode() {
       return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
     }
   }
   _WorkerSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_WorkerSendPort, {
+    constructors: () => ({_WorkerSendPort: [_WorkerSendPort, [core.int, core.int, core.int]]}),
     methods: () => ({send: [dart.void, [core.Object]]})
   });
   let _handler = Symbol('_handler');
   class RawReceivePortImpl extends core.Object {
     RawReceivePortImpl(handler) {
       this[_handler] = handler;
       this[_id] = (() => {
         let x = RawReceivePortImpl._nextFreeId;
         RawReceivePortImpl._nextFreeId = dart.notNull(x) + 1;
         return x;
@@ skipping 36 matching lines @@
       dart.dcall(this[_handler], dataEvent);
     }
     get sendPort() {
       return new _NativeJsSendPort(this, exports._globalState.currentContext.id);
     }
   }
   RawReceivePortImpl[dart.implements] = () => [isolate.RawReceivePort];
   dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
   dart.defineNamedConstructor(RawReceivePortImpl, '_controlPort');
   dart.setSignature(RawReceivePortImpl, {
+    constructors: () => ({
+      RawReceivePortImpl: [RawReceivePortImpl, [core.Function]],
+      weak: [RawReceivePortImpl, [core.Function]],
+      _controlPort: [RawReceivePortImpl, []]
+    }),
     methods: () => ({
       [_close]: [dart.void, []],
       close: [dart.void, []],
       [_add]: [dart.void, [core.Object]]
     })
   });
   RawReceivePortImpl._nextFreeId = 1;
   let _rawPort = Symbol('_rawPort');
   let _controller = Symbol('_controller');
   class ReceivePortImpl extends async.Stream {
@@ skipping 21 matching lines @@
       this[_controller].close();
     }
     get sendPort() {
       return this[_rawPort].sendPort;
     }
   }
   ReceivePortImpl[dart.implements] = () => [isolate.ReceivePort];
   dart.defineNamedConstructor(ReceivePortImpl, 'weak');
   dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
   dart.setSignature(ReceivePortImpl, {
+    constructors: () => ({
+      ReceivePortImpl: [ReceivePortImpl, []],
+      weak: [ReceivePortImpl, []],
+      fromRawReceivePort: [ReceivePortImpl, [isolate.RawReceivePort]]
+    }),
     methods: () => ({
       listen: [async.StreamSubscription, [dart.functionType(dart.void, [dart.bottom])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
       close: [dart.void, []]
     })
   });
   let _once = Symbol('_once');
   let _inEventLoop = Symbol('_inEventLoop');
   let _handle = Symbol('_handle');
   class TimerImpl extends core.Object {
     TimerImpl(milliseconds, callback) {
@@ skipping 54 matching lines @@
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
       return this[_handle] != null;
     }
   }
   TimerImpl[dart.implements] = () => [async.Timer];
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   dart.setSignature(TimerImpl, {
+    constructors: () => ({
+      TimerImpl: [TimerImpl, [core.int, dart.functionType(dart.void, [])]],
+      periodic: [TimerImpl, [core.int, dart.functionType(dart.void, [async.Timer])]]
+    }),
     methods: () => ({cancel: [dart.void, []]})
   });
   function hasTimer() {
     _js_helper.requiresPreamble();
     return self.setTimeout != null;
   }
   dart.fn(hasTimer, core.bool, []);
   class CapabilityImpl extends core.Object {
     CapabilityImpl() {
       this._internal(_js_helper.random64());
@@ skipping 17 matching lines @@
         return true;
       if (dart.is(other, CapabilityImpl)) {
         return core.identical(this[_id], other[_id]);
       }
       return false;
     }
   }
   CapabilityImpl[dart.implements] = () => [isolate.Capability];
   dart.defineNamedConstructor(CapabilityImpl, '_internal');
   dart.setSignature(CapabilityImpl, {
+    constructors: () => ({
+      CapabilityImpl: [CapabilityImpl, []],
+      _internal: [CapabilityImpl, [core.int]]
+    }),
     methods: () => ({'==': [core.bool, [core.Object]]})
   });
   // Exports:
   exports.enterJsAsync = enterJsAsync;
   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);