Handle dynamic as bottom inside of function type reps

lib/runtime/dart/_isolate_helper.js

 dart_library.library('dart/_isolate_helper', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/isolate',
   'dart/_foreign_helper',
   'dart/collection',
   'dart/async'
 ], /* Lazy imports */[
@@ skipping 18 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 = core.Map$(core.Object, core.int).identity();
+      this.serializedObjectIds = core.Map$(dart.dynamic, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (dart.notNull(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 65 matching lines @@
       return serialized;
     }
     serializeArrayInPlace(x) {
       for (let i = 0; dart.notNull(i) < dart.notNull(x[dartx.length]); i = dart.notNull(i) + 1) {
         x[dartx.set](i, this.serialize(x[dartx.get](i)));
       }
       return x;
     }
     serializeMap(x) {
       let serializeTearOff = dart.bind(this, 'serialize');
-      return ['map', x.keys[dartx.map](dart.as(serializeTearOff, __CastType0))[dartx.toList](), x.values[dartx.map](dart.as(serializeTearOff, dart.functionType(core.Object, [dart.bottom])))[dartx.toList]()];
+      return ['map', x.keys[dartx.map](dart.as(serializeTearOff, __CastType0))[dartx.toList](), x.values[dartx.map](dart.as(serializeTearOff, dart.functionType(dart.dynamic, [dart.dynamic])))[dartx.toList]()];
     }
     serializeJSObject(x) {
       if (!!x.constructor && x.constructor !== Object) {
         this.unsupported(x, "Only plain JS Objects are supported:");
       }
       let keys = dart.as(Object.keys(x), core.List);
       let values = [];
       values[dartx.length] = keys[dartx.length];
       for (let i = 0; dart.notNull(i) < dart.notNull(keys[dartx.length]); i = dart.notNull(i) + 1) {
         values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
@@ skipping 25 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, [], {serializeSendPorts: core.Object}]}),
+    constructors: () => ({_Serializer: [_Serializer, [], {serializeSendPorts: dart.dynamic}]}),
     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]],
-      serializeArrayInPlace: [core.Object, [_interceptors.JSArray]],
-      serializeMap: [core.Object, [core.Map]],
-      serializeJSObject: [core.Object, [_interceptors.JSObject]],
-      serializeWorkerSendPort: [core.Object, [_WorkerSendPort]],
-      serializeJsSendPort: [core.Object, [_NativeJsSendPort]],
-      serializeCapability: [core.Object, [CapabilityImpl]],
-      serializeClosure: [core.Object, [core.Function]],
-      serializeDartObject: [core.Object, [core.Object]]
+      serialize: [dart.dynamic, [dart.dynamic]],
+      unsupported: [dart.void, [dart.dynamic], [core.String]],
+      makeRef: [dart.dynamic, [core.int]],
+      isPrimitive: [core.bool, [dart.dynamic]],
+      serializePrimitive: [dart.dynamic, [dart.dynamic]],
+      serializeByteBuffer: [dart.dynamic, [_native_typed_data.NativeByteBuffer]],
+      serializeTypedData: [dart.dynamic, [_native_typed_data.NativeTypedData]],
+      serializeJSIndexable: [dart.dynamic, [_interceptors.JSIndexable]],
+      serializeArray: [dart.dynamic, [_interceptors.JSArray]],
+      serializeArrayInPlace: [dart.dynamic, [_interceptors.JSArray]],
+      serializeMap: [dart.dynamic, [core.Map]],
+      serializeJSObject: [dart.dynamic, [_interceptors.JSObject]],
+      serializeWorkerSendPort: [dart.dynamic, [_WorkerSendPort]],
+      serializeJsSendPort: [dart.dynamic, [_NativeJsSendPort]],
+      serializeCapability: [dart.dynamic, [CapabilityImpl]],
+      serializeClosure: [dart.dynamic, [core.Function]],
+      serializeDartObject: [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 = core.List.new();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
@@ skipping 175 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[dartx.add](emptyInstance);
       this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
       return initializeObject(classId, emptyInstance, fields);
     }
   }
   dart.setSignature(_Deserializer, {
-    constructors: () => ({_Deserializer: [_Deserializer, [], {adjustSendPorts: core.Object}]}),
+    constructors: () => ({_Deserializer: [_Deserializer, [], {adjustSendPorts: dart.dynamic}]}),
     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]],
+      deserialize: [dart.dynamic, [dart.dynamic]],
+      isPrimitive: [core.bool, [dart.dynamic]],
+      deserializePrimitive: [dart.dynamic, [dart.dynamic]],
+      deserializeRef: [dart.dynamic, [dart.dynamic]],
+      deserializeByteBuffer: [_native_typed_data.NativeByteBuffer, [dart.dynamic]],
+      deserializeTypedData: [_native_typed_data.NativeTypedData, [dart.dynamic]],
       deserializeArrayInPlace: [core.List, [_interceptors.JSArray]],
-      deserializeFixed: [core.List, [core.Object]],
-      deserializeExtendable: [core.List, [core.Object]],
-      deserializeMutable: [core.List, [core.Object]],
-      deserializeConst: [core.List, [core.Object]],
-      deserializeMap: [core.Map, [core.Object]],
-      deserializeSendPort: [isolate.SendPort, [core.Object]],
-      deserializeRawSendPort: [isolate.SendPort, [core.Object]],
-      deserializeJSObject: [core.Object, [core.Object]],
-      deserializeClosure: [core.Function, [core.Object]],
-      deserializeDartObject: [core.Object, [core.Object]]
+      deserializeFixed: [core.List, [dart.dynamic]],
+      deserializeExtendable: [core.List, [dart.dynamic]],
+      deserializeMutable: [core.List, [dart.dynamic]],
+      deserializeConst: [core.List, [dart.dynamic]],
+      deserializeMap: [core.Map, [dart.dynamic]],
+      deserializeSendPort: [isolate.SendPort, [dart.dynamic]],
+      deserializeRawSendPort: [isolate.SendPort, [dart.dynamic]],
+      deserializeJSObject: [dart.dynamic, [dart.dynamic]],
+      deserializeClosure: [core.Function, [dart.dynamic]],
+      deserializeDartObject: [dart.dynamic, [dart.dynamic]]
     })
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [dart.bottom]));
+  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   function _callInIsolate(isolate, func) {
     let result = isolate.eval(func);
     exports._globalState.topEventLoop.run();
     return result;
   }
-  dart.fn(_callInIsolate, () => dart.functionType(core.Object, [_IsolateContext, core.Function]));
+  dart.fn(_callInIsolate, () => dart.definiteFunctionType(dart.dynamic, [_IsolateContext, core.Function]));
   let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
   function enterJsAsync() {
     let o = exports._globalState.topEventLoop;
     o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) + 1;
   }
   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);
   }
   dart.fn(leaveJsAsync);
   function isWorker() {
     return exports._globalState.isWorker;
   }
   dart.fn(isWorker, core.bool, []);
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
-  dart.fn(_currentIsolate, () => dart.functionType(_IsolateContext, []));
+  dart.fn(_currentIsolate, () => dart.definiteFunctionType(_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 (dart.notNull(exports._globalState.isWorker))
       return;
     let rootContext = new _IsolateContext();
     exports._globalState.rootContext = rootContext;
     exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
       rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args);
       }));
     } else if (dart.is(entry, _MainFunctionArgsMessage)) {
       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, [core.Object, core.Object]);
+  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 11 matching lines @@
       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 = core.Map$(core.int, _IsolateContext).new();
-      this.managers = core.Map$(core.int, core.Object).new();
+      this.managers = core.Map$(core.int, dart.dynamic).new();
       if (dart.notNull(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 25 matching lines @@
       }
     }
   }
   dart.setSignature(_Manager, {
     constructors: () => ({_Manager: [_Manager, [core.Function]]}),
     methods: () => ({
       [_nativeDetectEnvironment]: [dart.void, []],
       [_nativeInitWorkerMessageHandler]: [dart.void, []],
       maybeCloseWorker: [dart.void, []]
     }),
-    statics: () => ({_serializePrintMessage: [core.Object, [core.Object]]}),
+    statics: () => ({_serializePrintMessage: [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() {
@@ skipping 258 matching lines @@
     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]],
-      handleUncaughtError: [dart.void, [core.Object, core.StackTrace]],
-      eval: [core.Object, [core.Function]],
+      handleUncaughtError: [dart.void, [dart.dynamic, core.StackTrace]],
+      eval: [dart.dynamic, [core.Function]],
       [_setGlobals]: [dart.void, []],
-      handleControlMessage: [dart.void, [core.Object]],
+      handleControlMessage: [dart.void, [dart.dynamic]],
       lookup: [RawReceivePortImpl, [core.int]],
       [_addRegistration]: [dart.void, [core.int, RawReceivePortImpl]],
       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');
@@ skipping 52 matching lines @@
           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]],
+      enqueue: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
       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) {
@@ skipping 12 matching lines @@
   dart.setSignature(_IsolateEvent, {
     constructors: () => ({_IsolateEvent: [_IsolateEvent, [_IsolateContext, core.Function, core.String]]}),
     methods: () => ({process: [dart.void, []]})
   });
   class _MainManagerStub extends core.Object {
     postMessage(msg) {
       self.postMessage(msg);
     }
   }
   dart.setSignature(_MainManagerStub, {
-    methods: () => ({postMessage: [dart.void, [core.Object]]})
+    methods: () => ({postMessage: [dart.void, [dart.dynamic]]})
   });
   let _SPAWNED_SIGNAL = "spawned";
   let _SPAWN_FAILED_SIGNAL = "spawn failed";
   dart.copyProperties(exports, {
     get globalWindow() {
       return self.window;
     },
     get globalWorker() {
       return self.Worker;
     },
     get globalPostMessageDefined() {
       return !!self.postMessage;
     }
   });
-  let _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(core.Object, []));
-  let _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(core.Object, [dart.bottom]));
-  let _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
+  let _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(dart.dynamic, []));
+  let _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = document.currentScript;
       if (currentScript != null) {
         return String(currentScript.src);
       }
       if (dart.notNull(_js_helper.Primitives.isD8))
         return IsolateNatives.computeThisScriptD8();
       if (dart.notNull(_js_helper.Primitives.isJsshell))
         return IsolateNatives.computeThisScriptJsshell();
@@ skipping 97 matching lines @@
           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(dart.fn(msg => {
         dart.dsend(replyPort, 'send', msg);
       }), {onError: dart.fn(errorMessage => {
           dart.dsend(replyPort, 'send', [_SPAWN_FAILED_SIGNAL, errorMessage]);
-        }, core.Object, [core.String])});
+        }, dart.dynamic, [core.String])});
     }
     static _log(msg) {
       if (dart.notNull(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 core.Exception.new(trace);
@@ skipping 136 matching lines @@
       onError(message);
       return true;
     }
   }
   dart.setSignature(IsolateNatives, {
     statics: () => ({
       computeThisScript: [core.String, []],
       computeThisScriptJsshell: [core.String, []],
       computeThisScriptD8: [core.String, []],
       computeThisScriptFromTrace: [core.String, []],
-      _getEventData: [core.Object, [core.Object]],
-      _processWorkerMessage: [dart.void, [core.Object, core.Object]],
-      handleSpawnWorkerRequest: [core.Object, [core.Object]],
-      _log: [core.Object, [core.Object]],
-      _consoleLog: [dart.void, [core.Object]],
-      _getJSFunctionFromName: [core.Object, [core.String]],
+      _getEventData: [dart.dynamic, [dart.dynamic]],
+      _processWorkerMessage: [dart.void, [dart.dynamic, dart.dynamic]],
+      handleSpawnWorkerRequest: [dart.dynamic, [dart.dynamic]],
+      _log: [dart.dynamic, [dart.dynamic]],
+      _consoleLog: [dart.void, [dart.dynamic]],
+      _getJSFunctionFromName: [dart.dynamic, [core.String]],
       _getJSFunctionName: [core.String, [core.Function]],
-      _allocate: [core.Object, [core.Object]],
-      spawnFunction: [async.Future$(core.List), [dart.functionType(dart.void, [dart.bottom]), core.Object, core.bool]],
-      spawnUri: [async.Future$(core.List), [core.Uri, core.List$(core.String), core.Object, core.bool]],
-      spawn: [async.Future$(core.List), [core.String, core.String, core.List$(core.String), core.Object, core.bool, core.bool, core.bool]],
-      _startWorker: [dart.void, [core.String, core.String, core.List$(core.String), core.Object, core.bool, core.bool, isolate.SendPort, dart.functionType(dart.void, [core.String])]],
-      _startNonWorker: [dart.void, [core.String, core.String, core.List$(core.String), core.Object, core.bool, core.bool, isolate.SendPort]],
-      _startIsolate: [dart.void, [core.Function, core.List$(core.String), core.Object, core.bool, core.bool, isolate.SendPort]],
-      _spawnWorker: [dart.void, [core.Object, core.String, core.List$(core.String), core.Object, core.bool, core.bool, isolate.SendPort, dart.functionType(dart.void, [core.String])]],
-      workerOnError: [core.bool, [core.Object, core.String, dart.functionType(dart.void, [core.String])]]
+      _allocate: [dart.dynamic, [dart.dynamic]],
+      spawnFunction: [async.Future$(core.List), [dart.functionType(dart.void, [dart.dynamic]), dart.dynamic, core.bool]],
+      spawnUri: [async.Future$(core.List), [core.Uri, core.List$(core.String), dart.dynamic, core.bool]],
+      spawn: [async.Future$(core.List), [core.String, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, core.bool]],
+      _startWorker: [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.void, [core.String, core.String, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort]],
+      _startIsolate: [dart.void, [core.Function, core.List$(core.String), dart.dynamic, core.bool, core.bool, isolate.SendPort]],
+      _spawnWorker: [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: [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() {
@@ skipping 43 matching lines @@
     ['=='](other) {
       return dart.is(other, _NativeJsSendPort) && 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]]})
+    methods: () => ({send: [dart.void, [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 (dart.notNull(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]]})
+    methods: () => ({send: [dart.void, [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;
       })();
@@ skipping 43 matching lines @@
   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]]
+      [_add]: [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() {
@@ skipping 23 matching lines @@
   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])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
+      listen: [async.StreamSubscription, [dart.functionType(dart.void, [dart.dynamic])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: 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) {
       this[_once] = true;
       this[_inEventLoop] = false;
@@ skipping 110 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;
 });