Tag closures with their types

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);
 (function(exports, core, _native_typed_data, _interceptors, _js_helper, isolate, _foreign_helper, _js_embedded_names, collection, async) {
   'use strict';
-  // Function _serializeMessage: (dynamic) → dynamic
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
-  // Function _deserializeMessage: (dynamic) → dynamic
+  dart.fn(_serializeMessage);
   function _deserializeMessage(message) {
     return new _Deserializer().deserialize(message);
   }
-  // Function _clone: (dynamic) → dynamic
+  dart.fn(_deserializeMessage);
   function _clone(message) {
     let serializer = new _Serializer({serializeSendPorts: false});
     let deserializer = new _Deserializer();
     return deserializer.deserialize(serializer.serialize(message));
   }
+  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$(dart.dynamic, core.int)).identity();
@@ skipping 120 matching lines @@
       return ['function', name];
     }
     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, {
+    methods: () => ({
+      serialize: dart.functionType(dart.dynamic, [dart.dynamic]),
+      unsupported: dart.functionType(dart.void, [dart.dynamic], [core.String]),
+      makeRef: dart.functionType(dart.dynamic, [core.int]),
+      isPrimitive: dart.functionType(core.bool, [dart.dynamic]),
+      serializePrimitive: dart.functionType(dart.dynamic, [dart.dynamic]),
+      serializeByteBuffer: dart.functionType(dart.dynamic, [_native_typed_data.NativeByteBuffer]),
+      serializeTypedData: dart.functionType(dart.dynamic, [_native_typed_data.NativeTypedData]),
+      serializeJSIndexable: dart.functionType(dart.dynamic, [_interceptors.JSIndexable]),
+      serializeArray: dart.functionType(dart.dynamic, [_interceptors.JSArray]),
+      serializeArrayInPlace: dart.functionType(dart.dynamic, [_interceptors.JSArray]),
+      serializeMap: dart.functionType(dart.dynamic, [core.Map]),
+      serializeJSObject: dart.functionType(dart.dynamic, [_interceptors.JSObject]),
+      serializeWorkerSendPort: dart.functionType(dart.dynamic, [_WorkerSendPort]),
+      serializeJsSendPort: dart.functionType(dart.dynamic, [_NativeJsSendPort]),
+      serializeCapability: dart.functionType(dart.dynamic, [CapabilityImpl]),
+      serializeClosure: dart.functionType(dart.dynamic, [_js_helper.Closure]),
+      serializeDartObject: dart.functionType(dart.dynamic, [dart.dynamic])
+    })
+  });
   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[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
       if (this.isPrimitive(x))
         return this.deserializePrimitive(x);
@@ skipping 172 matching lines @@
       let classId = dart.as(dart.dindex(x, 1), core.String);
       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, {
+    methods: () => ({
+      deserialize: dart.functionType(dart.dynamic, [dart.dynamic]),
+      isPrimitive: dart.functionType(core.bool, [dart.dynamic]),
+      deserializePrimitive: dart.functionType(dart.dynamic, [dart.dynamic]),
+      deserializeRef: dart.functionType(dart.dynamic, [dart.dynamic]),
+      deserializeByteBuffer: dart.functionType(_native_typed_data.NativeByteBuffer, [dart.dynamic]),
+      deserializeTypedData: dart.functionType(_native_typed_data.NativeTypedData, [dart.dynamic]),
+      deserializeArrayInPlace: dart.functionType(core.List, [_interceptors.JSArray]),
+      deserializeFixed: dart.functionType(core.List, [dart.dynamic]),
+      deserializeExtendable: dart.functionType(core.List, [dart.dynamic]),
+      deserializeMutable: dart.functionType(core.List, [dart.dynamic]),
+      deserializeConst: dart.functionType(core.List, [dart.dynamic]),
+      deserializeMap: dart.functionType(core.Map, [dart.dynamic]),
+      deserializeSendPort: dart.functionType(isolate.SendPort, [dart.dynamic]),
+      deserializeRawSendPort: dart.functionType(isolate.SendPort, [dart.dynamic]),
+      deserializeJSObject: dart.functionType(dart.dynamic, [dart.dynamic]),
+      deserializeClosure: dart.functionType(core.Function, [dart.dynamic]),
+      deserializeDartObject: dart.functionType(dart.dynamic, [dart.dynamic])
+    })
+  });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  // Function _callInIsolate: (_IsolateContext, Function) → dynamic
   function _callInIsolate(isolate, func) {
     let result = isolate.eval(func);
     exports._globalState.topEventLoop.run();
     return result;
   }
+  dart.fn(_callInIsolate, () => dart.functionType(dart.dynamic, [_IsolateContext, core.Function]));
   let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
-  // Function enterJsAsync: () → dynamic
   function enterJsAsync() {
     let o = exports._globalState.topEventLoop;
     o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) + 1;
   }
-  // Function leaveJsAsync: () → dynamic
+  dart.fn(enterJsAsync);
   function leaveJsAsync() {
     let o = exports._globalState.topEventLoop;
     o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) - 1;
     dart.assert(dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount]) >= 0);
   }
-  // Function isWorker: () → bool
+  dart.fn(leaveJsAsync);
   function isWorker() {
     return exports._globalState.isWorker;
   }
-  // Function _currentIsolate: () → _IsolateContext
+  dart.fn(isWorker, core.bool, []);
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
-  // Function startRootIsolate: (dynamic, dynamic) → void
+  dart.fn(_currentIsolate, () => dart.functionType(_IsolateContext, []));
   function startRootIsolate(entry, args) {
     args = args;
     if (args == null)
       args = [];
     if (!dart.is(args, core.List)) {
       throw new core.ArgumentError(`Arguments to main must be a List: ${args}`);
     }
     exports._globalState = new _Manager(dart.as(entry, core.Function));
     if (exports._globalState.isWorker)
       return;
     let rootContext = new _IsolateContext();
     exports._globalState.rootContext = rootContext;
     exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
-      rootContext.eval(() => {
+      rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args);
-      });
+      }));
     } else if (dart.is(entry, _MainFunctionArgsMessage)) {
-      rootContext.eval(() => {
+      rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args, null);
-      });
+      }));
     } else {
       rootContext.eval(dart.as(entry, core.Function));
     }
     exports._globalState.topEventLoop.run();
   }
+  dart.fn(startRootIsolate, dart.void, [dart.dynamic, dart.dynamic]);
   dart.copyProperties(exports, {
     get _globalState() {
       return dart.as(dart.globalState, _Manager);
     },
     set _globalState(val) {
       dart.globalState = val;
     }
   });
   let _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
   let _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler');
@@ skipping 50 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, {
+    methods: () => ({
+      [_nativeDetectEnvironment]: dart.functionType(dart.void, []),
+      [_nativeInitWorkerMessageHandler]: dart.functionType(dart.void, []),
+      maybeCloseWorker: dart.functionType(dart.void, [])
+    }),
+    statics: () => ({_serializePrintMessage: dart.functionType(dart.dynamic, [dart.dynamic])}),
+    names: ['_serializePrintMessage']
+  });
   let _scheduledControlEvents = Symbol('_scheduledControlEvents');
   let _isExecutingEvent = Symbol('_isExecutingEvent');
   let _updateGlobalState = Symbol('_updateGlobalState');
   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;
@@ skipping 54 matching lines @@
     setErrorsFatal(authentification, errorsAreFatal) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
       this.errorsAreFatal = errorsAreFatal;
     }
     handlePing(responsePort, pingType) {
       if (pingType == isolate.Isolate.IMMEDIATE || pingType == isolate.Isolate.BEFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
         responsePort.send(null);
         return;
       }
-      // Function respond: () → void
       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();
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', respond);
     }
@@ skipping 166 matching lines @@
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
       this.weakPorts.remove(portId);
       this[_updateGlobalState]();
     }
   }
   _IsolateContext[dart.implements] = () => [_foreign_helper.IsolateContext];
+  dart.setSignature(_IsolateContext, {
+    methods: () => ({
+      addPause: dart.functionType(dart.void, [isolate.Capability, isolate.Capability]),
+      removePause: dart.functionType(dart.void, [isolate.Capability]),
+      addDoneListener: dart.functionType(dart.void, [isolate.SendPort]),
+      removeDoneListener: dart.functionType(dart.void, [isolate.SendPort]),
+      setErrorsFatal: dart.functionType(dart.void, [isolate.Capability, core.bool]),
+      handlePing: dart.functionType(dart.void, [isolate.SendPort, core.int]),
+      handleKill: dart.functionType(dart.void, [isolate.Capability, core.int]),
+      addErrorListener: dart.functionType(dart.void, [isolate.SendPort]),
+      removeErrorListener: dart.functionType(dart.void, [isolate.SendPort]),
+      handleUncaughtError: dart.functionType(dart.void, [dart.dynamic, core.StackTrace]),
+      eval: dart.functionType(dart.dynamic, [core.Function]),
+      [_setGlobals]: dart.functionType(dart.void, []),
+      handleControlMessage: dart.functionType(dart.void, [dart.dynamic]),
+      lookup: dart.functionType(RawReceivePortImpl, [core.int]),
+      [_addRegistration]: dart.functionType(dart.void, [core.int, RawReceivePortImpl]),
+      register: dart.functionType(dart.void, [core.int, RawReceivePortImpl]),
+      registerWeak: dart.functionType(dart.void, [core.int, RawReceivePortImpl]),
+      [_updateGlobalState]: dart.functionType(dart.void, []),
+      kill: dart.functionType(dart.void, []),
+      unregister: dart.functionType(dart.void, [core.int])
+    })
+  });
   let _runHelper = Symbol('_runHelper');
   class _EventLoop extends core.Object {
     _EventLoop() {
       this.events = new (collection.Queue$(_IsolateEvent))();
       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) {
@@ skipping 14 matching lines @@
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     [_runHelper]() {
       if (exports.globalWindow != null) {
-        // Function next: () → dynamic
         let next = (() => {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         }).bind(this);
+        dart.fn(next);
         next();
       } else {
         while (this.runIteration()) {
         }
       }
     }
     run() {
       if (!dart.notNull(exports._globalState.isWorker)) {
         this[_runHelper]();
       } else {
         try {
           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, {
+    methods: () => ({
+      enqueue: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
+      prequeue: dart.functionType(dart.void, [_IsolateEvent]),
+      dequeue: dart.functionType(_IsolateEvent, []),
+      checkOpenReceivePortsFromCommandLine: dart.functionType(dart.void, []),
+      runIteration: dart.functionType(core.bool, []),
+      [_runHelper]: dart.functionType(dart.void, []),
+      run: dart.functionType(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, {
+    methods: () => ({process: dart.functionType(dart.void, [])})
+  });
   class _MainManagerStub extends core.Object {
     postMessage(msg) {
       _js_helper.requiresPreamble();
       self.postMessage(msg);
     }
   }
+  dart.setSignature(_MainManagerStub, {
+    methods: () => ({postMessage: dart.functionType(dart.void, [dart.dynamic])})
+  });
   let _SPAWNED_SIGNAL = "spawned";
   let _SPAWN_FAILED_SIGNAL = "spawn failed";
   dart.copyProperties(exports, {
     get globalWindow() {
       _js_helper.requiresPreamble();
       return self.window;
     },
     get globalWorker() {
       _js_helper.requiresPreamble();
       return self.Worker;
@@ skipping 61 matching lines @@
         {
           exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
           let functionName = dart.as(dart.dindex(msg, 'functionName'), core.String);
           let entryPoint = functionName == null ? exports._globalState.entry : dart.as(IsolateNatives._getJSFunctionFromName(functionName), core.Function);
           let args = dart.dindex(msg, 'args');
           let message = _deserializeMessage(dart.dindex(msg, 'msg'));
           let isSpawnUri = dart.dindex(msg, 'isSpawnUri');
           let startPaused = dart.dindex(msg, 'startPaused');
           let replyTo = _deserializeMessage(dart.dindex(msg, 'replyTo'));
           let context = new _IsolateContext();
-          exports._globalState.topEventLoop.enqueue(context, () => {
+          exports._globalState.topEventLoop.enqueue(context, dart.fn(() => {
             IsolateNatives._startIsolate(entryPoint, dart.as(args, core.List$(core.String)), message, dart.as(isSpawnUri, core.bool), dart.as(startPaused, core.bool), dart.as(replyTo, isolate.SendPort));
-          }, 'worker-start');
+          }), 'worker-start');
           exports._globalState.currentContext = context;
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'spawn-worker':
         {
           if (IsolateNatives.enableSpawnWorker != null)
             IsolateNatives.handleSpawnWorkerRequest(msg);
           break;
         }
@@ skipping 28 matching lines @@
           break;
         }
         case 'error':
         {
           throw dart.dindex(msg, 'msg');
         }
       }
     }
     static handleSpawnWorkerRequest(msg) {
       let replyPort = dart.dindex(msg, 'replyPort');
-      IsolateNatives.spawn(dart.as(dart.dindex(msg, 'functionName'), core.String), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args'), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dindex(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core.bool)).then(msg => {
+      IsolateNatives.spawn(dart.as(dart.dindex(msg, 'functionName'), core.String), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args'), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dindex(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core.bool)).then(dart.fn(msg => {
         dart.dsend(replyPort, 'send', msg);
-      }, {
-        onError: errorMessage => {
+      }), {onError: dart.fn(errorMessage => {
           dart.dsend(replyPort, 'send', [_SPAWN_FAILED_SIGNAL, errorMessage]);
-        }
-      });
+        }, dart.dynamic, [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);
@@ skipping 30 matching lines @@
       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))();
-      port.first.then(msg => {
+      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, message => completer.completeError(message));
+        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);
       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);
-      exports._globalState.topEventLoop.enqueue(new _IsolateContext(), () => {
+      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');
+      }), '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) {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       _js_helper.Primitives.initializeStatics(context.id);
       replyTo.send([_SPAWNED_SIGNAL, context.controlPort.sendPort, context.pauseCapability, context.terminateCapability]);
-      // Function runStartFunction: () → void
       let runStartFunction = () => {
         context.initialized = true;
         if (!dart.notNull(isSpawnUri)) {
           dart.dcall(topLevel, message);
         } else if (dart.is(topLevel, _MainFunctionArgsMessage)) {
           dart.dcall(topLevel, args, message);
         } else if (dart.is(topLevel, _MainFunctionArgs)) {
           dart.dcall(topLevel, args);
         } else {
           dart.dcall(topLevel);
         }
       };
+      dart.fn(runStartFunction, dart.void, []);
       if (startPaused) {
         context.addPause(context.pauseCapability, context.pauseCapability);
         exports._globalState.topEventLoop.enqueue(context, runStartFunction, 'start isolate');
       } else {
         runStartFunction();
       }
     }
     static _spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (uri == null)
         uri = IsolateNatives.thisScript;
@@ skipping 23 matching lines @@
       let message = dart.as(event.message, core.String);
       if (message == null) {
         message = `Error spawning worker for ${uri}`;
       } else {
         message = `Error spawning worker for ${uri} (${message})`;
       }
       onError(message);
       return true;
     }
   }
+  dart.setSignature(IsolateNatives, {
+    statics: () => ({
+      computeThisScript: dart.functionType(core.String, []),
+      computeThisScriptJsshell: dart.functionType(core.String, []),
+      computeThisScriptD8: dart.functionType(core.String, []),
+      computeThisScriptFromTrace: dart.functionType(core.String, []),
+      _getEventData: dart.functionType(dart.dynamic, [dart.dynamic]),
+      _processWorkerMessage: dart.functionType(dart.void, [dart.dynamic, dart.dynamic]),
+      handleSpawnWorkerRequest: dart.functionType(dart.dynamic, [dart.dynamic]),
+      _log: dart.functionType(dart.dynamic, [dart.dynamic]),
+      _consoleLog: dart.functionType(dart.void, [dart.dynamic]),
+      _getJSFunctionFromName: dart.functionType(dart.dynamic, [core.String]),
+      _getJSFunctionName: dart.functionType(core.String, [core.Function]),
+      _allocate: dart.functionType(dart.dynamic, [dart.dynamic]),
+      spawnFunction: dart.functionType(async.Future$(core.List), [dart.functionType(dart.void, [dart.dynamic]), dart.dynamic, core.bool]),
+      spawnUri: dart.functionType(async.Future$(core.List), [core.Uri, core.List$(core.String), dart.dynamic, core.bool]),
+      spawn: dart.functionType(async.Future$(core.List), [core.String, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, core.bool]),
+      _startWorker: dart.functionType(dart.void, [core.String, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort, dart.functionType(dart.void, [core.String])]),
+      _startNonWorker: dart.functionType(dart.void, [core.String, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort]),
+      _startIsolate: dart.functionType(dart.void, [core.Function, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort]),
+      _spawnWorker: dart.functionType(dart.void, [dart.dynamic, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort, dart.functionType(dart.void, [core.String])]),
+      workerOnError: dart.functionType(core.bool, [dart.dynamic, core.String, dart.functionType(dart.void, [core.String])])
+    }),
+    names: ['computeThisScript', 'computeThisScriptJsshell', 'computeThisScriptD8', 'computeThisScriptFromTrace', '_getEventData', '_processWorkerMessage', 'handleSpawnWorkerRequest', '_log', '_consoleLog', '_getJSFunctionFromName', '_getJSFunctionName', '_allocate', 'spawnFunction', 'spawnUri', 'spawn', '_startWorker', '_startNonWorker', '_startIsolate', '_spawnWorker', 'workerOnError']
+  });
   IsolateNatives.enableSpawnWorker = null;
   dart.defineLazyProperties(IsolateNatives, {
     get thisScript() {
       return IsolateNatives.computeThisScript();
     },
     set thisScript(_) {},
     get workerIds() {
       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");
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
+  dart.setSignature(_BaseSendPort, {
+    methods: () => ({[_checkReplyTo]: dart.functionType(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) {
       let isolate = exports._globalState.isolates.get(this[_isolateId]);
       if (isolate == null)
         return;
       if (this[_receivePort][_isClosed])
         return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
-      exports._globalState.topEventLoop.enqueue(isolate, (() => {
+      exports._globalState.topEventLoop.enqueue(isolate, dart.fn((() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort][_add](msg);
         }
-      }).bind(this), `receive ${message}`);
+      }).bind(this)), `receive ${message}`);
     }
     ['=='](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, {
+    methods: () => ({
+      send: dart.functionType(dart.void, [dart.dynamic]),
+      '==': dart.functionType(core.bool, [dart.dynamic])
+    })
+  });
   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, {
+    methods: () => ({
+      send: dart.functionType(dart.void, [dart.dynamic]),
+      '==': dart.functionType(core.bool, [dart.dynamic])
+    })
+  });
   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;
       })();
       this[_isClosed] = false;
@@ skipping 33 matching lines @@
         return;
       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, {
+    methods: () => ({
+      [_close]: dart.functionType(dart.void, []),
+      close: dart.functionType(dart.void, []),
+      [_add]: dart.functionType(dart.void, [dart.dynamic])
+    })
+  });
   RawReceivePortImpl._nextFreeId = 1;
   let _rawPort = Symbol('_rawPort');
   let _controller = Symbol('_controller');
   class ReceivePortImpl extends async.Stream {
     ReceivePortImpl() {
       this.fromRawReceivePort(new RawReceivePortImpl(null));
     }
     weak() {
       this.fromRawReceivePort(new RawReceivePortImpl.weak(null));
     }
@@ skipping 14 matching lines @@
       this[_rawPort].close();
       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, {
+    methods: () => ({
+      listen: dart.functionType(async.StreamSubscription, [dart.functionType(dart.void, [dart.dynamic])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}),
+      close: dart.functionType(dart.void, [])
+    })
+  });
   let _once = Symbol('_once');
   let _inEventLoop = Symbol('_inEventLoop');
   let _handle = Symbol('_handle');
   class TimerImpl extends core.Object {
     TimerImpl(milliseconds, callback) {
       this[_once] = true;
       this[_inEventLoop] = false;
       this[_handle] = null;
       if (milliseconds == 0 && (!dart.notNull(hasTimer()) || dart.notNull(exports._globalState.isWorker))) {
-        // Function internalCallback: () → void
         let internalCallback = (() => {
           this[_handle] = null;
           callback();
         }).bind(this);
+        dart.fn(internalCallback, dart.void, []);
         this[_handle] = 1;
         exports._globalState.topEventLoop.enqueue(exports._globalState.currentContext, internalCallback, 'timer');
         this[_inEventLoop] = true;
       } else if (hasTimer()) {
-        // Function internalCallback: () → void
         let internalCallback = (() => {
           this[_handle] = null;
           leaveJsAsync();
           callback();
         }).bind(this);
+        dart.fn(internalCallback, dart.void, []);
         enterJsAsync();
         this[_handle] = self.setTimeout(_js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds);
       } else {
         dart.assert(dart.notNull(milliseconds) > 0);
         throw new core.UnsupportedError("Timer greater than 0.");
       }
     }
     periodic(milliseconds, callback) {
       this[_once] = false;
       this[_inEventLoop] = false;
       this[_handle] = null;
       if (hasTimer()) {
         enterJsAsync();
-        this[_handle] = self.setInterval(_js_helper.convertDartClosureToJS((() => {
+        this[_handle] = self.setInterval(_js_helper.convertDartClosureToJS(dart.fn((() => {
           callback(this);
-        }).bind(this), 0), milliseconds);
+        }).bind(this)), 0), milliseconds);
       } else {
         throw new core.UnsupportedError("Periodic timer.");
       }
     }
     cancel() {
       if (hasTimer()) {
         if (this[_inEventLoop]) {
           throw new core.UnsupportedError("Timer in event loop cannot be canceled.");
         }
         if (this[_handle] == null)
           return;
         leaveJsAsync();
         if (this[_once]) {
           self.clearTimeout(this[_handle]);
         } else {
           self.clearInterval(this[_handle]);
         }
         this[_handle] = null;
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
       return this[_handle] != null;
     }
   }
   TimerImpl[dart.implements] = () => [async.Timer];
   dart.defineNamedConstructor(TimerImpl, 'periodic');
-  // Function hasTimer: () → bool
+  dart.setSignature(TimerImpl, {
+    methods: () => ({cancel: dart.functionType(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());
     }
     _internal(id) {
       this[_id] = id;
     }
     get hashCode() {
       let hash = this[_id];
       hash = dart.notNull(hash) >> 0 ^ (dart.notNull(hash) / 4294967296).truncate();
       hash = ~dart.notNull(hash) + (dart.notNull(hash) << 15) & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 12;
       hash = dart.notNull(hash) * 5 & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 4;
       hash = dart.notNull(hash) * 2057 & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 16;
       return hash;
     }
     ['=='](other) {
       if (core.identical(other, this))
         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, {
+    methods: () => ({'==': dart.functionType(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);