Make int and double nullable by default

test/codegen/expect/dart/_isolate_helper.js

 var _isolate_helper;
 (function(exports) {
   'use strict';
   // Function _callInIsolate: (_IsolateContext, Function) → dynamic
   function _callInIsolate(isolate, function) {
     let result = isolate.eval(function);
     exports._globalState.topEventLoop.run();
     return result;
   }
   let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
   // Function enterJsAsync: () → dynamic
   function enterJsAsync() {
-    exports._globalState.topEventLoop[_activeJsAsyncCount]++;
+    dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount])++;
   }
   // Function leaveJsAsync: () → dynamic
   function leaveJsAsync() {
-    exports._globalState.topEventLoop[_activeJsAsyncCount]--;
-    dart.assert(exports._globalState.topEventLoop[_activeJsAsyncCount] >= 0);
+    dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount])--;
+    dart.assert(dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount]) >= 0);
   }
   // Function isWorker: () → bool
   function isWorker() {
     return exports._globalState.isWorker;
   }
   // Function _currentIsolate: () → _IsolateContext
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
   // Function startRootIsolate: (dynamic, dynamic) → void
@@ skipping 58 matching lines @@
       this.isolates = new core.Map();
       this.managers = new core.Map();
       if (this.isWorker) {
         this.mainManager = new _MainManagerStub();
         this[_nativeInitWorkerMessageHandler]();
       }
     }
     [_nativeDetectEnvironment]() {
       let isWindowDefined = exports.globalWindow !== null;
       let isWorkerDefined = exports.globalWorker !== null;
-      this.isWorker = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(exports.globalPostMessageDefined);
-      this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(dart.notNull(isWorkerDefined) && dart.notNull(IsolateNatives.thisScript !== null));
-      this.fromCommandLine = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(!dart.notNull(this.isWorker));
+      this.isWorker = !dart.notNull(isWindowDefined) && dart.notNull(exports.globalPostMessageDefined);
+      this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(isWorkerDefined) && dart.notNull(IsolateNatives.thisScript !== null);
+      this.fromCommandLine = !dart.notNull(isWindowDefined) && !dart.notNull(this.isWorker);
     }
     [_nativeInitWorkerMessageHandler]() {
       let function = function(f, a) {
         return function(e) {
           f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives[_processWorkerMessage]), this.mainManager);
       self.onmessage = function;
       self.dartPrint = self.dartPrint || function(serialize) {
         return function(object) {
           if (self.console && self.console.log) {
             self.console.log(object);
           } else {
             self.postMessage(serialize(object));
           }
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(_serializePrintMessage));
     }
     static [_serializePrintMessage](object) {
       return _serializeMessage(dart.map({command: "print", msg: object}));
     }
     maybeCloseWorker() {
-      if (dart.notNull(dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty)) && dart.notNull(this.topEventLoop[_activeJsAsyncCount] === 0)) {
+      if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] === 0) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   let _scheduledControlEvents = Symbol('_scheduledControlEvents');
   let _isExecutingEvent = Symbol('_isExecutingEvent');
   let _id = Symbol('_id');
   let _updateGlobalState = Symbol('_updateGlobalState');
   let _setGlobals = Symbol('_setGlobals');
   let _addRegistration = Symbol('_addRegistration');
   class _IsolateContext extends dart.Object {
     _IsolateContext() {
-      this.id = exports._globalState.nextIsolateId++;
+      this.id = dart.notNull(exports._globalState.nextIsolateId)++;
       this.ports = new core.Map();
       this.weakPorts = new core.Set();
       this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
       this.controlPort = new RawReceivePortImpl._controlPort();
       this.pauseCapability = new isolate.Capability();
       this.terminateCapability = new isolate.Capability();
       this.delayedEvents = dart.as(new List.from([]), core.List$(_IsolateEvent));
       this.pauseTokens = dart.as(new core.Set(), core.Set$(isolate.Capability));
       this.errorPorts = dart.as(new core.Set(), core.Set$(isolate.SendPort));
       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))
         return;
-      if (dart.notNull(this.pauseTokens.add(resume)) && dart.notNull(!dart.notNull(this.isPaused))) {
+      if (dart.notNull(this.pauseTokens.add(resume)) && !dart.notNull(this.isPaused)) {
         this.isPaused = true;
       }
       this[_updateGlobalState]();
     }
     removePause(resume) {
       if (!dart.notNull(this.isPaused))
         return;
       this.pauseTokens.remove(resume);
       if (this.pauseTokens.isEmpty) {
         while (this.delayedEvents.isNotEmpty) {
@@ skipping 16 matching lines @@
       if (this.doneHandlers === null)
         return;
       dart.dinvoke(this.doneHandlers, 'remove', responsePort);
     }
     setErrorsFatal(authentification, errorsAreFatal) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
       this.errorsAreFatal = errorsAreFatal;
     }
     handlePing(responsePort, pingType) {
-      if (dart.notNull(pingType === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(pingType === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this[_isExecutingEvent])))) {
+      if (pingType === isolate.Isolate.IMMEDIATE || pingType === isolate.Isolate.BEFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
         responsePort.send(null);
         return;
       }
       // Function respond: () → void
       function respond() {
         responsePort.send(null);
       }
       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.dinvoke(this[_scheduledControlEvents], 'addLast', respond);
     }
     handleKill(authentification, priority) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
-      if (dart.notNull(priority === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(priority === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this[_isExecutingEvent])))) {
+      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, this.kill, "kill");
         return;
       }
       dart.assert(priority === isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this[_scheduledControlEvents] === null) {
         this[_scheduledControlEvents] = new collection.Queue();
@@ skipping 103 matching lines @@
     }
     register(portId, port) {
       this[_addRegistration](portId, port);
       this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
       this[_addRegistration](portId, port);
     }
     [_updateGlobalState]() {
-      if (dart.notNull(dart.notNull(this.ports.length - this.weakPorts.length > 0) || dart.notNull(this.isPaused)) || dart.notNull(!dart.notNull(this.initialized))) {
+      if (dart.notNull(this.ports.length) - dart.notNull(this.weakPorts.length) > 0 || dart.notNull(this.isPaused) || !dart.notNull(this.initialized)) {
         exports._globalState.isolates.set(this.id, this);
       } else {
         this.kill();
       }
     }
     kill() {
       if (this[_scheduledControlEvents] !== null) {
         dart.dinvoke(this[_scheduledControlEvents], 'clear');
       }
       for (let port of this.ports.values) {
@@ skipping 27 matching lines @@
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (this.events.isEmpty)
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
-      if (dart.notNull(dart.notNull(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)) {
+      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.");
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event === null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
@@ skipping 231 matching lines @@
       let completer = dart.as(new async.Completer(), async.Completer$(core.List));
       port.first.then(((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));
         }
       }).bind(this));
       let signalReply = port.sendPort;
-      if (dart.notNull(exports._globalState.useWorkers) && dart.notNull(!dart.notNull(isLight))) {
+      if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight)) {
         _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, ((message) => completer.completeError(message)).bind(this));
       } else {
         _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.from(args);
       if (exports._globalState.isWorker) {
@@ skipping 52 matching lines @@
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(workerOnError), uri, onError);
       worker.onerror = onerrorTrampoline;
       let processWorkerMessageTrampoline = function(f, a) {
         return function(e) {
           e.onerror = null;
           return f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(_processWorkerMessage), worker);
       worker.onmessage = processWorkerMessageTrampoline;
-      let workerId = exports._globalState.nextManagerId++;
+      let workerId = dart.notNull(exports._globalState.nextManagerId)++;
       workerIds.set(worker, workerId);
       exports._globalState.managers.set(workerId, worker);
       worker.postMessage(_serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName})));
     }
     static workerOnError(event, uri, onError) {
       event.preventDefault();
       let message = dart.as(event.message, core.String);
       if (message === null) {
         message = `Error spawning worker for ${uri}`;
       } else {
@@ skipping 13 matching lines @@
       return new core.Expando();
     }
   });
   let _isolateId = Symbol('_isolateId');
   let _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends dart.Object {
     _BaseSendPort($_isolateId) {
       this[_isolateId] = $_isolateId;
     }
     [_checkReplyTo](replyTo) {
-      if (dart.notNull(dart.notNull(replyTo !== null) && dart.notNull(!dart.is(replyTo, _NativeJsSendPort))) && dart.notNull(!dart.is(replyTo, _WorkerSendPort))) {
+      if (dart.notNull(replyTo !== null) && dart.notNull(!dart.is(replyTo, _NativeJsSendPort)) && dart.notNull(!dart.is(replyTo, _WorkerSendPort))) {
         throw new core.Exception("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   let _receivePort = Symbol('_receivePort');
   let _isClosed = Symbol('_isClosed');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort($_receivePort, isolateId) {
       this[_receivePort] = $_receivePort;
       super._BaseSendPort(isolateId);
@@ skipping 35 matching lines @@
       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.notNull(dart.notNull(dart.notNull(dart.is(other, _WorkerSendPort)) && dart.notNull(this[_workerId] === dart.dload(other, '_workerId'))) && dart.notNull(this[_isolateId] === dart.dload(other, '_isolateId'))) && dart.notNull(this[_receivePortId] === dart.dload(other, '_receivePortId'));
+      return dart.notNull(dart.is(other, _WorkerSendPort)) && this[_workerId] === dart.dload(other, '_workerId') && this[_isolateId] === dart.dload(other, '_isolateId') && this[_receivePortId] === dart.dload(other, '_receivePortId');
     }
     get hashCode() {
-      return this[_workerId] << 16 ^ this[_isolateId] << 8 ^ this[_receivePortId];
+      return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
     }
   }
   let _handler = Symbol('_handler');
   let _close = Symbol('_close');
   let _add = Symbol('_add');
   class RawReceivePortImpl extends dart.Object {
     RawReceivePortImpl($_handler) {
       this[_handler] = $_handler;
-      this[_id] = _nextFreeId++;
+      this[_id] = dart.notNull(_nextFreeId)++;
       this[_isClosed] = false;
       exports._globalState.currentContext.register(this[_id], this);
     }
     RawReceivePortImpl$weak($_handler) {
       this[_handler] = $_handler;
-      this[_id] = _nextFreeId++;
+      this[_id] = dart.notNull(_nextFreeId)++;
       this[_isClosed] = false;
       exports._globalState.currentContext.registerWeak(this[_id], this);
     }
     RawReceivePortImpl$_controlPort() {
       this[_handler] = null;
       this[_id] = 0;
       this[_isClosed] = false;
     }
     set handler(newHandler) {
       this[_handler] = newHandler;
@@ skipping 53 matching lines @@
   }
   dart.defineNamedConstructor(ReceivePortImpl, 'weak');
   dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
   let _once = Symbol('_once');
   let _inEventLoop = Symbol('_inEventLoop');
   let _handle = Symbol('_handle');
   class TimerImpl extends dart.Object {
     TimerImpl(milliseconds, callback) {
       this[_once] = true;
       this[_inEventLoop] = false;
-      this[_handle] = dart.as(null, core.int);
-      if (dart.notNull(milliseconds === 0) && dart.notNull(dart.notNull(!dart.notNull(hasTimer())) || dart.notNull(exports._globalState.isWorker))) {
+      this[_handle] = null;
+      if (milliseconds === 0 && (!dart.notNull(hasTimer()) || dart.notNull(exports._globalState.isWorker))) {
         // Function internalCallback: () → void
         function internalCallback() {
-          this[_handle] = dart.as(null, core.int);
+          this[_handle] = null;
           callback();
         }
         this[_handle] = 1;
         exports._globalState.topEventLoop.enqueue(exports._globalState.currentContext, internalCallback, 'timer');
         this[_inEventLoop] = true;
       } else if (hasTimer()) {
         // Function internalCallback: () → void
         function internalCallback() {
-          this[_handle] = dart.as(null, core.int);
+          this[_handle] = null;
           leaveJsAsync();
           callback();
         }
         enterJsAsync();
         this[_handle] = self.setTimeout(_js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds);
       } else {
-        dart.assert(milliseconds > 0);
+        dart.assert(dart.notNull(milliseconds) > 0);
         throw new core.UnsupportedError("Timer greater than 0.");
       }
     }
     TimerImpl$periodic(milliseconds, callback) {
       this[_once] = false;
       this[_inEventLoop] = false;
-      this[_handle] = dart.as(null, core.int);
+      this[_handle] = null;
       if (hasTimer()) {
         enterJsAsync();
         this[_handle] = self.setInterval(_js_helper.convertDartClosureToJS((() => {
           callback(this);
         }).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] = dart.as(null, core.int);
+        this[_handle] = null;
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
       return this[_handle] !== null;
     }
   }
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
     return self.setTimeout !== null;
   }
   class CapabilityImpl extends dart.Object {
     CapabilityImpl() {
       this.CapabilityImpl$_internal(_js_helper.random64());
     }
     CapabilityImpl$_internal($_id) {
       this[_id] = $_id;
     }
     get hashCode() {
       let hash = this[_id];
-      hash = hash >> 0 ^ (hash / 4294967296).truncate();
-      hash = ~hash + (hash << 15) & 4294967295;
-      hash = hash >> 12;
-      hash = hash * 5 & 4294967295;
-      hash = hash >> 4;
-      hash = hash * 2057 & 4294967295;
-      hash = hash >> 16;
+      hash = dart.notNull(hash) >> 0 ^ (dart.notNull(hash) / 4294967296).truncate();
+      hash = ~dart.notNull(hash) + (dart.notNull(hash) << 15) & 4294967295;
+      hash = dart.notNull(hash) >> 12;
+      hash = dart.notNull(hash) * 5 & 4294967295;
+      hash = dart.notNull(hash) >> 4;
+      hash = dart.notNull(hash) * 2057 & 4294967295;
+      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;
     }
@@ skipping 55 matching lines @@
       if (message === void 0)
         message = null;
       if (message === null)
         message = "Can't transmit:";
       throw new core.UnsupportedError(`${message} ${x}`);
     }
     makeRef(serializationId) {
       return new List.from(["ref", serializationId]);
     }
     isPrimitive(x) {
-      return dart.notNull(dart.notNull(dart.notNull(x === null) || dart.notNull(typeof x == string)) || dart.notNull(dart.is(x, core.num))) || dart.notNull(typeof x == boolean);
+      return dart.notNull(x === null) || dart.notNull(typeof x == string) || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == boolean);
     }
     serializePrimitive(primitive) {
       return primitive;
     }
     serializeByteBuffer(buffer) {
       return new List.from(["buffer", buffer]);
     }
     serializeTypedData(data) {
       return new List.from(["typed", data]);
     }
     serializeJSIndexable(indexable) {
       dart.assert(!(typeof indexable == string));
       let serialized = dart.as(this.serializeArray(dart.as(indexable, _interceptors.JSArray)), core.List);
       if (dart.is(indexable, _interceptors.JSFixedArray))
         return new List.from(["fixed", serialized]);
       if (dart.is(indexable, _interceptors.JSExtendableArray))
         return new List.from(["extendable", serialized]);
       if (dart.is(indexable, _interceptors.JSMutableArray))
         return new List.from(["mutable", serialized]);
       if (dart.is(indexable, _interceptors.JSArray))
         return new List.from(["const", serialized]);
       this.unsupported(indexable, "Can't serialize indexable: ");
       return null;
     }
     serializeArray(x) {
       let serialized = new List.from([]);
       serialized.length = x.length;
-      for (let i = 0; i < x.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(x.length); dart.notNull(i)++) {
         serialized.set(i, this.serialize(x.get(i)));
       }
       return serialized;
     }
     serializeArrayInPlace(x) {
-      for (let i = 0; i < x.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(x.length); dart.notNull(i)++) {
         x.set(i, this.serialize(x.get(i)));
       }
       return x;
     }
     serializeMap(x) {
       let serializeTearOff = this.serialize;
       return new List.from(['map', x.keys.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList(), x.values.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList()]);
     }
     serializeJSObject(x) {
-      if (dart.notNull(!!x.constructor) && dart.notNull(x.constructor !== Object)) {
+      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 = new List.from([]);
       values.length = keys.length;
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         values.set(i, this.serialize(x[keys.get(i)]));
       }
       return new List.from(['js-object', keys, values]);
     }
     serializeWorkerSendPort(x) {
       if (this[_serializeSendPorts]) {
         return new List.from(['sendport', x[_workerId], x[_isolateId], x[_receivePortId]]);
       }
       return new List.from(['raw sendport', x]);
     }
@@ skipping 59 matching lines @@
           return this.deserializeJSObject(x);
         case "function":
           return this.deserializeClosure(x);
         case "dart":
           return this.deserializeDartObject(x);
         default:
           throw `couldn't deserialize: ${x}`;
       }
     }
     isPrimitive(x) {
-      return dart.notNull(dart.notNull(dart.notNull(x === null) || dart.notNull(typeof x == string)) || dart.notNull(dart.is(x, core.num))) || dart.notNull(typeof x == boolean);
+      return dart.notNull(x === null) || dart.notNull(typeof x == string) || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == boolean);
     }
     deserializePrimitive(x) {
       return x;
     }
     deserializeRef(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
       let serializationId = dart.as(dart.dindex(x, 1), core.int);
       return this.deserializedObjects.get(serializationId);
     }
     deserializeByteBuffer(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
       let result = dart.as(dart.dindex(x, 1), _native_typed_data.NativeByteBuffer);
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeTypedData(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'typed'));
       let result = dart.as(dart.dindex(x, 1), _native_typed_data.NativeTypedData);
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeArrayInPlace(x) {
-      for (let i = 0; i < x.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(x.length); dart.notNull(i)++) {
         x.set(i, this.deserialize(x.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.add(result);
       return new _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(dart.as(result, _interceptors.JSArray)));
     }
@@ skipping 15 matching lines @@
       this.deserializedObjects.add(result);
       return new _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.add(result);
       keys = keys.map(this.deserialize).toList();
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         result.set(keys.get(i), this.deserialize(values.get(i)));
       }
       return result;
     }
     deserializeSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'sendport'));
       let managerId = dart.as(dart.dindex(x, 1), core.int);
       let isolateId = dart.as(dart.dindex(x, 2), core.int);
       let receivePortId = dart.as(dart.dindex(x, 3), core.int);
       let result = null;
@@ skipping 16 matching lines @@
       let result = dart.as(dart.dindex(x, 1), isolate.SendPort);
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeJSObject(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'js-object'));
       let keys = dart.as(dart.dindex(x, 1), core.List);
       let values = dart.as(dart.dindex(x, 2), core.List);
       let o = {};
       this.deserializedObjects.add(o);
-      for (let i = 0; i < keys.length; i++) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); dart.notNull(i)++) {
         o[keys.get(i)] = this.deserialize(values.get(i));
       }
       return o;
     }
     deserializeClosure(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'function'));
       let name = dart.as(dart.dindex(x, 1), core.String);
       let result = dart.as(IsolateNatives._getJSFunctionFromName(name), core.Function);
       this.deserializedObjects.add(result);
       return result;
@@ skipping 18 matching lines @@
   exports.globalWindow = globalWindow;
   exports.globalWorker = globalWorker;
   exports.globalPostMessageDefined = globalPostMessageDefined;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper || (_isolate_helper = {}));