use == and != to enable handling null/undefined

lib/runtime/dart/_isolate_helper.js

 var _isolate_helper;
 (function(exports) {
   'use strict';
   // Function _serializeMessage: (dynamic) → dynamic
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
   // Function _deserializeMessage: (dynamic) → dynamic
   function _deserializeMessage(message) {
     return new _Deserializer().deserialize(message);
@@ skipping 13 matching lines @@
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = new core.Map.identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (this.isPrimitive(x))
         return this.serializePrimitive(x);
       let serializationId = this.serializedObjectIds.get(x);
-      if (serializationId !== null)
+      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));
       if (dart.is(x, _interceptors.JSIndexable))
         return this.serializeJSIndexable(dart.as(x, _interceptors.JSIndexable));
       if (dart.is(x, _js_helper.InternalMap))
         return this.serializeMap(dart.as(x, core.Map));
       if (dart.is(x, _interceptors.JSObject))
         return this.serializeJSObject(dart.as(x, _interceptors.JSObject));
       if (dart.is(x, _interceptors.Interceptor))
         this.unsupported(x);
       if (dart.is(x, isolate.RawReceivePort)) {
         this.unsupported(x, "RawReceivePorts can't be transmitted:");
       }
       if (dart.is(x, _NativeJsSendPort))
         return this.serializeJsSendPort(dart.as(x, _NativeJsSendPort));
       if (dart.is(x, _WorkerSendPort))
         return this.serializeWorkerSendPort(dart.as(x, _WorkerSendPort));
       if (dart.is(x, _js_helper.Closure))
         return this.serializeClosure(dart.as(x, _js_helper.Closure));
       return this.serializeDartObject(x);
     }
     unsupported(x, message) {
       if (message === void 0)
         message = null;
-      if (message === null)
+      if (message == null)
         message = "Can't transmit:";
       throw new core.UnsupportedError(`${message} ${x}`);
     }
     makeRef(serializationId) {
       return new core.List.from(["ref", serializationId]);
     }
     isPrimitive(x) {
-      return 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 core.List.from(["buffer", buffer]);
     }
     serializeTypedData(data) {
       return new core.List.from(["typed", data]);
     }
@@ skipping 52 matching lines @@
         let workerId = exports._globalState.currentManagerId;
         return new core.List.from(['sendport', workerId, x[_isolateId], x[_receivePort][_id]]);
       }
       return new core.List.from(['raw sendport', x]);
     }
     serializeCapability(x) {
       return new core.List.from(['capability', x[_id]]);
     }
     serializeClosure(x) {
       let name = IsolateNatives._getJSFunctionName(x);
-      if (name === null) {
+      if (name == null) {
         this.unsupported(x, "Closures can't be transmitted:");
       }
       return new core.List.from(['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 new core.List.from(['dart', classId, this.serializeArrayInPlace(dart.as(fields, _interceptors.JSArray))]);
@@ skipping 64 matching lines @@
         {
           return this.deserializeDartObject(x);
         }
         default:
         {
           throw `couldn't deserialize: ${x}`;
         }
       }
     }
     isPrimitive(x) {
-      return 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) {
@@ skipping 49 matching lines @@
         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;
-      if (managerId === exports._globalState.currentManagerId) {
+      if (managerId == exports._globalState.currentManagerId) {
         let isolate = exports._globalState.isolates.get(isolateId);
-        if (isolate === null)
+        if (isolate == null)
           return null;
         let receivePort = isolate.lookup(receivePortId);
-        if (receivePort === null)
+        if (receivePort == null)
           return null;
         result = new _NativeJsSendPort(receivePort, isolateId);
       } else {
         result = new _WorkerSendPort(managerId, isolateId, receivePortId);
       }
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeRawSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'raw sendport'));
@@ skipping 51 matching lines @@
   function isWorker() {
     return exports._globalState.isWorker;
   }
   // Function _currentIsolate: () → _IsolateContext
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
   // Function startRootIsolate: (dynamic, dynamic) → void
   function startRootIsolate(entry, args) {
     args = args;
-    if (args === null)
+    if (args == null)
       args = new core.List.from([]);
     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;
@@ skipping 43 matching lines @@
       this[_nativeDetectEnvironment]();
       this.topEventLoop = new _EventLoop();
       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;
+      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) && dart.notNull(IsolateNatives.thisScript !== null);
+      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$0 = function(f, a) {
         return function(e) {
           f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives[_processWorkerMessage]), this.mainManager);
       self.onmessage = function$0;
       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(_Manager[_serializePrintMessage]));
     }
     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) {
+      if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] == 0) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   let _controlPort = Symbol('_controlPort');
   let _scheduledControlEvents = Symbol('_scheduledControlEvents');
   let _isExecutingEvent = Symbol('_isExecutingEvent');
   let _updateGlobalState = Symbol('_updateGlobalState');
   let _setGlobals = Symbol('_setGlobals');
   let _addRegistration = Symbol('_addRegistration');
@@ skipping 32 matching lines @@
       if (this.pauseTokens.isEmpty) {
         while (this.delayedEvents.isNotEmpty) {
           let event = this.delayedEvents.removeLast();
           exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
-      if (this.doneHandlers === null) {
+      if (this.doneHandlers == null) {
         this.doneHandlers = new core.List.from([]);
       }
       if (dart.dinvoke(this.doneHandlers, 'contains', responsePort))
         return;
       dart.dinvoke(this.doneHandlers, 'add', responsePort);
     }
     removeDoneListener(responsePort) {
-      if (this.doneHandlers === null)
+      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 (pingType === isolate.Isolate.IMMEDIATE || pingType === isolate.Isolate.BEFORE_NEXT_EVENT && !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) {
+      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) {
+      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 (priority === isolate.Isolate.IMMEDIATE || priority === isolate.Isolate.BEFORE_NEXT_EVENT && !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) {
+      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) {
+      dart.assert(priority == isolate.Isolate.BEFORE_NEXT_EVENT);
+      if (this[_scheduledControlEvents] == null) {
         this[_scheduledControlEvents] = new collection.Queue();
       }
       dart.dinvoke(this[_scheduledControlEvents], 'addLast', 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.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)
+          if (stackTrace != null)
             core.print(stackTrace);
         }
         return;
       }
       let message = new core.List(2);
       message.set(0, dart.dinvoke(error, 'toString'));
-      message.set(1, stackTrace === null ? null : stackTrace.toString());
+      message.set(1, stackTrace == null ? null : stackTrace.toString());
       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.dinvokef(code);
       } catch (e) {
         let s = dart.stackTrace(e);
         this.handleUncaughtError(e, s);
         if (this.errorsAreFatal) {
           this.kill();
           if (core.identical(this, exports._globalState.rootContext)) {
             throw e;
           }
         }
       }
  finally {
         this[_isExecutingEvent] = false;
         exports._globalState.currentContext = old;
-        if (old !== null)
+        if (old != null)
           old._setGlobals();
-        if (this[_scheduledControlEvents] !== null) {
+        if (this[_scheduledControlEvents] != null) {
           while (dart.dload(this[_scheduledControlEvents], 'isNotEmpty')) {
             dart.dinvokef(dart.dinvoke(this[_scheduledControlEvents], 'removeFirst'));
           }
         }
       }
       return result;
     }
     [_setGlobals]() {
       _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
     }
@@ skipping 65 matching lines @@
       this[_addRegistration](portId, port);
     }
     [_updateGlobalState]() {
       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) {
+      if (this[_scheduledControlEvents] != null) {
         dart.dinvoke(this[_scheduledControlEvents], 'clear');
       }
       for (let port of this.ports.values) {
         dart.dinvoke(port, '_close');
       }
       this.ports.clear();
       this.weakPorts.clear();
       exports._globalState.isolates.remove(this.id);
       this.errorPorts.clear();
-      if (this.doneHandlers !== null) {
+      if (this.doneHandlers != null) {
         for (let port of this.doneHandlers) {
           port.send(null);
         }
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
       this.weakPorts.remove(portId);
       this[_updateGlobalState]();
@@ skipping 10 matching lines @@
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (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 (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) {
+      if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     [_runHelper]() {
-      if (exports.globalWindow !== null) {
+      if (exports.globalWindow != null) {
         // Function next: () → void
         function next() {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         }
         next();
       } else {
         while (this.runIteration()) {
         }
@@ skipping 55 matching lines @@
   let _log = Symbol('_log');
   let _consoleLog = Symbol('_consoleLog');
   let _getJSFunctionName = Symbol('_getJSFunctionName');
   let _allocate = Symbol('_allocate');
   let _startWorker = Symbol('_startWorker');
   let _startNonWorker = Symbol('_startNonWorker');
   let _spawnWorker = Symbol('_spawnWorker');
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CURRENT_SCRIPT);
-      if (currentScript !== null) {
+      if (currentScript != null) {
         return String(currentScript.src);
       }
       if (_js_helper.Primitives.isD8)
         return IsolateNatives.computeThisScriptD8();
       if (_js_helper.Primitives.isJsshell)
         return IsolateNatives.computeThisScriptJsshell();
       if (exports._globalState.isWorker)
         return IsolateNatives.computeThisScriptFromTrace();
       return null;
     }
     static computeThisScriptJsshell() {
       return dart.as(thisFilename(), core.String);
     }
     static computeThisScriptD8() {
       return IsolateNatives.computeThisScriptFromTrace();
     }
     static computeThisScriptFromTrace() {
       let stack = new Error().stack;
-      if (stack === null) {
+      if (stack == null) {
         stack = function() {
           try {
             throw new Error();
           } catch (e) {
             return e.stack;
           }
 
         }();
-        if (stack === null)
+        if (stack == null)
           throw new core.UnsupportedError('No stack trace');
       }
       let pattern = null, matches = null;
       pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
       matches = stack.match(pattern);
-      if (matches !== null)
+      if (matches != null)
         return matches[1];
       pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
       matches = stack.match(pattern);
-      if (matches !== null)
+      if (matches != null)
         return matches[1];
       throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
     }
     static [_getEventData](e) {
       return e.data;
     }
     static [_processWorkerMessage](sender, e) {
       let msg = _deserializeMessage(IsolateNatives[_getEventData](e));
       switch (dart.dindex(msg, 'command')) {
         case 'start':
         {
           exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
           let functionName = dart.as(dart.dindex(msg, 'functionName'), core.String);
-          let entryPoint = dart.as(functionName === null ? exports._globalState.entry : IsolateNatives[_getJSFunctionFromName](functionName), core.Function);
+          let entryPoint = dart.as(functionName == null ? exports._globalState.entry : 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, () => {
             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');
           exports._globalState.currentContext = context;
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'spawn-worker':
         {
-          if (IsolateNatives.enableSpawnWorker !== null)
+          if (IsolateNatives.enableSpawnWorker != null)
             IsolateNatives.handleSpawnWorkerRequest(msg);
           break;
         }
         case 'message':
         {
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
-          if (port !== null) {
+          if (port != null) {
             dart.dinvoke(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
           }
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'close':
         {
           exports._globalState.managers.remove(IsolateNatives.workerIds.get(sender));
           sender.terminate();
           exports._globalState.topEventLoop.run();
@@ skipping 52 matching lines @@
     }
     static [_getJSFunctionName](f) {
       return dart.as(dart.is(f, _js_helper.Closure) ? f.$name : null, core.String);
     }
     static [_allocate](ctor) {
       return new ctor();
     }
     static spawnFunction(topLevelFunction, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let name = IsolateNatives[_getJSFunctionName](topLevelFunction);
-      if (name === null) {
+      if (name == null) {
         throw new core.UnsupportedError("only top-level functions can be spawned.");
       }
       let isLight = false;
       let isSpawnUri = false;
       return IsolateNatives.spawn(name, null, null, message, isLight, isSpawnUri, startPaused);
     }
     static spawnUri(uri, args, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let isLight = false;
       let isSpawnUri = true;
       return IsolateNatives.spawn(null, uri.toString(), args, message, isLight, isSpawnUri, startPaused);
     }
     static spawn(functionName, uri, args, message, isLight, isSpawnUri, startPaused) {
-      if (dart.notNull(uri !== null) && dart.notNull(uri.endsWith(".dart")))
+      if (dart.notNull(uri != null) && dart.notNull(uri.endsWith(".dart")))
         uri = ".js";
       let port = new isolate.ReceivePort();
       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(isLight)) {
         IsolateNatives[_startWorker](functionName, uri, args, message, isSpawnUri, startPaused, signalReply, ((message) => completer.completeError(message)).bind(this));
       } 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)
+      if (args != null)
         args = new core.List.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) {
+      if (uri != null) {
         throw new core.UnsupportedError("Currently spawnUri is not supported without web workers.");
       }
       message = _clone(message);
-      if (args !== null)
+      if (args != null)
         args = new core.List.from(args);
       exports._globalState.topEventLoop.enqueue(new _IsolateContext(), () => {
         let func = IsolateNatives[_getJSFunctionFromName](functionName);
         IsolateNatives[_startIsolate](dart.as(func, core.Function), args, message, isSpawnUri, startPaused, replyPort);
       }, '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});
     }
@@ skipping 15 matching lines @@
         }
       }
       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)
+      if (uri == null)
         uri = IsolateNatives.thisScript;
       let worker = new Worker(uri);
       let onerrorTrampoline = function(f, u, c) {
         return function(e) {
           return f(e, u, c);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives.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(IsolateNatives[_processWorkerMessage]), worker);
       worker.onmessage = processWorkerMessageTrampoline;
       let workerId = ((x$) => exports._globalState.nextManagerId = dart.notNull(x$) + 1, x$).bind(this)(exports._globalState.nextManagerId);
       IsolateNatives.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) {
+      if (message == null) {
         message = `Error spawning worker for ${uri}`;
       } else {
         message = `Error spawning worker for ${uri} (${message})`;
       }
       onError(message);
       return true;
     }
   }
   IsolateNatives.enableSpawnWorker = null;
   dart.defineLazyProperties(IsolateNatives, {
     get thisScript() {
       return IsolateNatives.computeThisScript();
     },
     set thisScript(_) {},
     get workerIds() {
       return new core.Expando();
     }
   });
   let _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends core.Object {
     _BaseSendPort(isolateId$) {
       this[_isolateId] = isolateId$;
     }
     [_checkReplyTo](replyTo) {
-      if (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 _isClosed = Symbol('_isClosed');
   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)
+      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, (() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
@@ skipping 13 matching lines @@
       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) {
+        if (manager != null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
-      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');
+      return dart.notNull(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]);
     }
   }
   let _handler = Symbol('_handler');
   let _nextFreeId = Symbol('_nextFreeId');
   let _close = Symbol('_close');
   let _add = Symbol('_add');
   class RawReceivePortImpl extends core.Object {
@@ skipping 73 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 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))) {
+      if (milliseconds == 0 && (!dart.notNull(hasTimer()) || dart.notNull(exports._globalState.isWorker))) {
         // Function internalCallback: () → void
         function internalCallback() {
           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
@@ skipping 20 matching lines @@
         }).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)
+        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;
+      return this[_handle] != null;
     }
   }
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
-    return self.setTimeout !== null;
+    return self.setTimeout != null;
   }
   let _internal = Symbol('_internal');
   class CapabilityImpl extends core.Object {
     CapabilityImpl() {
       this[_internal](_js_helper.random64());
     }
     [_internal](id) {
       this[_id] = id;
     }
     get hashCode() {
@@ skipping 22 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;
 })(_isolate_helper || (_isolate_helper = {}));