fixes #206, add checking for unary ops

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.import(_interceptors);
 var _js_helper = dart.import(_js_helper);
 var isolate = dart.import(isolate);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var collection = dart.import(collection);
 var async = dart.import(async);
@@ skipping 19 matching lines @@
   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[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
-      if (this.isPrimitive(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);
       if (dart.is(x, _native_typed_data.NativeByteBuffer))
         return this.serializeByteBuffer(dart.as(x, _native_typed_data.NativeByteBuffer));
       if (dart.is(x, _native_typed_data.NativeTypedData))
         return this.serializeTypedData(dart.as(x, _native_typed_data.NativeTypedData));
@@ skipping 20 matching lines @@
       if (message === void 0)
         message = null;
       if (message == null)
         message = "Can't transmit:";
       throw new core.UnsupportedError(`${message} ${x}`);
     }
     makeRef(serializationId) {
       return ["ref", serializationId];
     }
     isPrimitive(x) {
-      return dart.notNull(x == null) || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
+      return x == null || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
     }
     serializePrimitive(primitive) {
       return primitive;
     }
     serializeByteBuffer(buffer) {
       return ["buffer", buffer];
     }
     serializeTypedData(data) {
       return ["typed", data];
     }
@@ skipping 35 matching lines @@
       }
       let keys = dart.as(Object.keys(x), core.List);
       let values = [];
       values.length = keys.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
       }
       return ['js-object', keys, values];
     }
     serializeWorkerSendPort(x) {
-      if (this[_serializeSendPorts]) {
+      if (dart.notNull(this[_serializeSendPorts])) {
         return ['sendport', x[_workerId], x[_isolateId], x[_receivePortId]];
       }
       return ['raw sendport', x];
     }
     serializeJsSendPort(x) {
-      if (this[_serializeSendPorts]) {
+      if (dart.notNull(this[_serializeSendPorts])) {
         let workerId = exports._globalState.currentManagerId;
         return ['sendport', workerId, x[_isolateId], x[_receivePort][_id]];
       }
       return ['raw sendport', x];
     }
     serializeCapability(x) {
       return ['capability', x[_id]];
     }
     serializeClosure(x) {
       let name = IsolateNatives._getJSFunctionName(x);
@@ skipping 33 matching lines @@
     })
   });
   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) {
-      if (this.isPrimitive(x))
+      if (dart.notNull(this.isPrimitive(x)))
         return this.deserializePrimitive(x);
       if (!dart.is(x, _interceptors.JSArray))
         throw new core.ArgumentError(`Bad serialized message: ${x}`);
       switch (dart.dload(x, 'first')) {
         case "ref":
         {
           return this.deserializeRef(x);
         }
         case "buffer":
         {
@@ skipping 43 matching lines @@
         {
           return this.deserializeDartObject(x);
         }
         default:
         {
           throw `couldn't deserialize: ${x}`;
         }
       }
     }
     isPrimitive(x) {
-      return dart.notNull(x == null) || typeof x == 'string' || dart.is(x, core.num) || typeof x == 'boolean';
+      return x == null || typeof x == 'string' || dart.is(x, core.num) || 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[dartx.get](serializationId);
     }
     deserializeByteBuffer(x) {
@@ skipping 156 matching lines @@
   }
   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)
+    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(() => {
@@ skipping 30 matching lines @@
       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();
-      if (this.isWorker) {
+      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;
       this.fromCommandLine = !dart.notNull(isWindowDefined) && !dart.notNull(this.isWorker);
@@ skipping 69 matching lines @@
         return;
       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[dartx.isNotEmpty]) {
+      if (dart.notNull(this.pauseTokens.isEmpty)) {
+        while (dart.notNull(this.delayedEvents[dartx.isNotEmpty])) {
           let event = this.delayedEvents[dartx.removeLast]();
           exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers == null) {
         this.doneHandlers = [];
       }
-      if (dart.dsend(this.doneHandlers, 'contains', responsePort))
+      if (dart.notNull(dart.as(dart.dsend(this.doneHandlers, 'contains', responsePort), core.bool)))
         return;
       dart.dsend(this.doneHandlers, 'add', responsePort);
     }
     removeDoneListener(responsePort) {
       if (this.doneHandlers == null)
         return;
       dart.dsend(this.doneHandlers, 'remove', responsePort);
     }
     setErrorsFatal(authentification, errorsAreFatal) {
       if (!dart.equals(this.terminateCapability, authentification))
@@ skipping 36 matching lines @@
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', dart.bind(this, 'kill'));
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
-      if (this.errorPorts.isEmpty) {
+      if (dart.notNull(this.errorPorts.isEmpty)) {
         if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, exports._globalState.rootContext))) {
           return;
         }
         if (self.console && self.console.error) {
           self.console.error(error, stackTrace);
         } else {
           core.print(error);
           if (stackTrace != null)
             core.print(stackTrace);
         }
         return;
       }
       let message = core.List.new(2);
       message[dartx.set](0, dart.toString(error));
       message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
       for (let port of this.errorPorts)
         port.send(message);
     }
     eval(code) {
       let old = exports._globalState.currentContext;
       exports._globalState.currentContext = this;
       this[_setGlobals]();
       let result = null;
       this[_isExecutingEvent] = true;
       try {
         result = dart.dcall(code);
       } catch (e) {
         let s = dart.stackTrace(e);
         this.handleUncaughtError(e, s);
-        if (this.errorsAreFatal) {
+        if (dart.notNull(this.errorsAreFatal)) {
           this.kill();
-          if (core.identical(this, exports._globalState.rootContext)) {
+          if (dart.notNull(core.identical(this, exports._globalState.rootContext))) {
             throw e;
           }
         }
       }
  finally {
         this[_isExecutingEvent] = false;
         exports._globalState.currentContext = old;
         if (old != null)
           old[_setGlobals]();
         if (this[_scheduledControlEvents] != null) {
-          while (dart.dload(this[_scheduledControlEvents], 'isNotEmpty')) {
+          while (dart.notNull(dart.as(dart.dload(this[_scheduledControlEvents], 'isNotEmpty'), core.bool))) {
             dart.dcall(dart.dsend(this[_scheduledControlEvents], 'removeFirst'));
           }
         }
       }
       return result;
     }
     [_setGlobals]() {
       _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
     }
     handleControlMessage(message) {
@@ skipping 43 matching lines @@
           this.removeErrorListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
         }
         default:
       }
     }
     lookup(portId) {
       return this.ports.get(portId);
     }
     [_addRegistration](portId, port) {
-      if (this.ports.containsKey(portId)) {
+      if (dart.notNull(this.ports.containsKey(portId))) {
         throw core.Exception.new("Registry: ports must be registered only once.");
       }
       this.ports.set(portId, port);
     }
     register(portId, port) {
       this[_addRegistration](portId, port);
       this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
@@ skipping 62 matching lines @@
       this.events = collection.Queue$(_IsolateEvent).new();
       this[_activeJsAsyncCount] = 0;
     }
     enqueue(isolate, fn, msg) {
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
-      if (this.events.isEmpty)
+      if (dart.notNull(this.events.isEmpty))
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
-      if (dart.notNull(exports._globalState.rootContext != null) && dart.notNull(exports._globalState.isolates.containsKey(exports._globalState.rootContext.id)) && dart.notNull(exports._globalState.fromCommandLine) && dart.notNull(exports._globalState.rootContext.ports.isEmpty)) {
+      if (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 core.Exception.new("Program exited with open ReceivePorts.");
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     [_runHelper]() {
       if (exports.globalWindow != null) {
         let next = () => {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         };
         dart.fn(next);
         next();
       } else {
-        while (this.runIteration()) {
+        while (dart.notNull(this.runIteration())) {
         }
       }
     }
     run() {
       if (!dart.notNull(exports._globalState.isWorker)) {
         this[_runHelper]();
       } else {
         try {
           this[_runHelper]();
         } catch (e) {
@@ skipping 16 matching lines @@
       run: [dart.void, []]
     })
   });
   class _IsolateEvent extends core.Object {
     _IsolateEvent(isolate, fn, message) {
       this.isolate = isolate;
       this.fn = fn;
       this.message = message;
     }
     process() {
-      if (this.isolate.isPaused) {
+      if (dart.notNull(this.isolate.isPaused)) {
         this.isolate.delayedEvents[dartx.add](this);
         return;
       }
       this.isolate.eval(this.fn);
     }
   }
   dart.setSignature(_IsolateEvent, {
     constructors: () => ({_IsolateEvent: [_IsolateEvent, [_IsolateContext, core.Function, core.String]]}),
     methods: () => ({process: [dart.void, []]})
   });
@@ skipping 20 matching lines @@
   });
   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]));
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = document.currentScript;
       if (currentScript != null) {
         return String(currentScript.src);
       }
-      if (_js_helper.Primitives.isD8)
+      if (dart.notNull(_js_helper.Primitives.isD8))
         return IsolateNatives.computeThisScriptD8();
-      if (_js_helper.Primitives.isJsshell)
+      if (dart.notNull(_js_helper.Primitives.isJsshell))
         return IsolateNatives.computeThisScriptJsshell();
-      if (exports._globalState.isWorker)
+      if (dart.notNull(exports._globalState.isWorker))
         return IsolateNatives.computeThisScriptFromTrace();
       return null;
     }
     static computeThisScriptJsshell() {
       return dart.as(thisFilename(), core.String);
     }
     static computeThisScriptD8() {
       return IsolateNatives.computeThisScriptFromTrace();
     }
     static computeThisScriptFromTrace() {
@@ skipping 67 matching lines @@
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'log':
         {
           IsolateNatives._log(dart.dindex(msg, 'msg'));
           break;
         }
         case 'print':
         {
-          if (exports._globalState.isWorker) {
+          if (dart.notNull(exports._globalState.isWorker)) {
             exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
           } else {
             core.print(dart.dindex(msg, 'msg'));
           }
           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(dart.fn(msg => {
         dart.dsend(replyPort, 'send', msg);
       }), {onError: dart.fn(errorMessage => {
           dart.dsend(replyPort, 'send', [_SPAWN_FAILED_SIGNAL, errorMessage]);
         }, core.Object, [core.String])});
     }
     static _log(msg) {
-      if (exports._globalState.isWorker) {
+      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 45 matching lines @@
       if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight)) {
         IsolateNatives._startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, dart.fn(message => completer.completeError(message), dart.void, [core.String]));
       } else {
         IsolateNatives._startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply);
       }
       return completer.future;
     }
     static _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (args != null)
         args = core.List$(core.String).from(args);
-      if (exports._globalState.isWorker) {
+      if (dart.notNull(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);
@@ skipping 18 matching lines @@
           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) {
+      if (dart.notNull(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;
       let worker = new Worker(uri);
@@ skipping 63 matching lines @@
     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)) {
+      if (replyTo != null && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(replyTo, _WorkerSendPort)) {
         throw core.Exception.new("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_BaseSendPort, {
     constructors: () => ({_BaseSendPort: [_BaseSendPort, [core.int]]}),
     methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
   });
   let _isClosed = Symbol('_isClosed');
   let _add = Symbol('_add');
   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])
+      if (dart.notNull(this[_receivePort][_isClosed]))
         return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
       exports._globalState.topEventLoop.enqueue(isolate, dart.fn(() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort][_add](msg);
         }
       }), `receive ${message}`);
     }
     ['=='](other) {
-      return dart.is(other, _NativeJsSendPort) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, _receivePort)));
+      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]]})
   });
   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) {
+      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));
@@ skipping 35 matching lines @@
       this[_isClosed] = false;
     }
     set handler(newHandler) {
       this[_handler] = newHandler;
     }
     [_close]() {
       this[_isClosed] = true;
       this[_handler] = null;
     }
     close() {
-      if (this[_isClosed])
+      if (dart.notNull(this[_isClosed]))
         return;
       this[_isClosed] = true;
       this[_handler] = null;
       exports._globalState.currentContext.unregister(this[_id]);
     }
     [_add](dataEvent) {
-      if (this[_isClosed])
+      if (dart.notNull(this[_isClosed]))
         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');
@@ skipping 64 matching lines @@
       this[_handle] = null;
       if (milliseconds == 0 && (!dart.notNull(hasTimer()) || dart.notNull(exports._globalState.isWorker))) {
         let internalCallback = () => {
           this[_handle] = null;
           callback();
         };
         dart.fn(internalCallback, dart.void, []);
         this[_handle] = 1;
         exports._globalState.topEventLoop.enqueue(exports._globalState.currentContext, internalCallback, 'timer');
         this[_inEventLoop] = true;
-      } else if (hasTimer()) {
+      } else if (dart.notNull(hasTimer())) {
         let internalCallback = () => {
           this[_handle] = null;
           leaveJsAsync();
           callback();
         };
         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()) {
+      if (dart.notNull(hasTimer())) {
         enterJsAsync();
         this[_handle] = self.setInterval(_js_helper.convertDartClosureToJS(dart.fn(() => {
           callback(this);
         }), 0), milliseconds);
       } else {
         throw new core.UnsupportedError("Periodic timer.");
       }
     }
     cancel() {
-      if (hasTimer()) {
-        if (this[_inEventLoop]) {
+      if (dart.notNull(hasTimer())) {
+        if (dart.notNull(this[_inEventLoop])) {
           throw new core.UnsupportedError("Timer in event loop cannot be canceled.");
         }
         if (this[_handle] == null)
           return;
         leaveJsAsync();
-        if (this[_once]) {
+        if (dart.notNull(this[_once])) {
           self.clearTimeout(this[_handle]);
         } else {
           self.clearInterval(this[_handle]);
         }
         this[_handle] = null;
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
@@ skipping 25 matching lines @@
       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))
+      if (dart.notNull(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, {
     constructors: () => ({
       CapabilityImpl: [CapabilityImpl, []],
       _internal: [CapabilityImpl, [core.int]]
     }),
     methods: () => ({'==': [core.bool, [core.Object]]})
   });
   // Exports:
   exports.enterJsAsync = enterJsAsync;
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper, core, _native_typed_data, _interceptors, _js_helper, isolate, _foreign_helper, _js_embedded_names, collection, async);