refactor emitMemberName to be used more consistently

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);
   }
   // Function _clone: (dynamic) → dynamic
   function _clone(message) {
     let serializer = new _Serializer({serializeSendPorts: false});
     let deserializer = new _Deserializer();
     return deserializer.deserialize(serializer.serialize(message));
   }
   let _serializeSendPorts = Symbol('_serializeSendPorts');
   let _workerId = Symbol('_workerId');
   let _isolateId = Symbol('_isolateId');
   let _receivePortId = Symbol('_receivePortId');
+  let _id = Symbol('_id');
   let _receivePort = Symbol('_receivePort');
-  let _id = Symbol('_id');
   let _getJSFunctionName = Symbol('_getJSFunctionName');
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = new core.Map$(dart.dynamic, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (this.isPrimitive(x))
         return this.serializePrimitive(x);
@@ skipping 29 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 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) || typeof x == 'string' || dart.is(x, core.num) || 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 138 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) || 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[core.$get](serializationId);
     }
     deserializeByteBuffer(x) {
@@ skipping 280 matching lines @@
           exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers == null) {
         this.doneHandlers = new core.List.from([]);
       }
-      if (dart.dinvoke(this.doneHandlers, 'contains', responsePort))
+      if (dart.dsend(this.doneHandlers, 'contains', responsePort))
         return;
-      dart.dinvoke(this.doneHandlers, 'add', responsePort);
+      dart.dsend(this.doneHandlers, 'add', responsePort);
     }
     removeDoneListener(responsePort) {
       if (this.doneHandlers == null)
         return;
-      dart.dinvoke(this.doneHandlers, 'remove', responsePort);
+      dart.dsend(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])) {
         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);
+      dart.dsend(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])) {
         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();
       }
-      dart.dinvoke(this[_scheduledControlEvents], 'addLast', this.kill);
+      dart.dsend(this[_scheduledControlEvents], 'addLast', this.kill);
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
       if (this.errorPorts[core.$isEmpty]) {
         if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, exports._globalState.rootContext))) {
@@ skipping 32 matching lines @@
           }
         }
       }
  finally {
         this[_isExecutingEvent] = false;
         exports._globalState.currentContext = old;
         if (old != null)
           old[_setGlobals]();
         if (this[_scheduledControlEvents] != null) {
           while (dart.dload(this[_scheduledControlEvents], 'isNotEmpty')) {
-            dart.dinvokef(dart.dinvoke(this[_scheduledControlEvents], 'removeFirst'));
+            dart.dinvokef(dart.dsend(this[_scheduledControlEvents], 'removeFirst'));
           }
         }
       }
       return result;
     }
     [_setGlobals]() {
       _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
     }
     handleControlMessage(message) {
       switch (dart.dindex(message, 0)) {
@@ skipping 64 matching lines @@
     }
     [_updateGlobalState]() {
       if (dart.notNull(this.ports.length) - dart.notNull(this.weakPorts[core.$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');
+        dart.dsend(this[_scheduledControlEvents], 'clear');
       }
       for (let port of this.ports.values) {
         port[_close]();
       }
       this.ports.clear();
       this.weakPorts.clear();
       exports._globalState.isolates.remove(this.id);
       this.errorPorts.clear();
       if (this.doneHandlers != null) {
         for (let port of dart.as(this.doneHandlers, core.Iterable$(isolate.SendPort))) {
@@ skipping 188 matching lines @@
         case 'spawn-worker':
         {
           if (IsolateNatives.enableSpawnWorker != null)
             IsolateNatives.handleSpawnWorkerRequest(msg);
           break;
         }
         case 'message':
         {
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
           if (port != null) {
-            dart.dinvoke(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
+            dart.dsend(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();
           break;
@@ skipping 14 matching lines @@
         }
         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.as(msg => {
-        dart.dinvoke(replyPort, 'send', msg);
+        dart.dsend(replyPort, 'send', msg);
       }, dart.functionType(dart.dynamic, [core.List])), {
         onError: errorMessage => {
-          dart.dinvoke(replyPort, 'send', new core.List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
+          dart.dsend(replyPort, 'send', new core.List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
         }
       });
     }
     static [_log](msg) {
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           IsolateNatives[_consoleLog](msg);
         } catch (e) {
@@ skipping 149 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.notNull(!dart.is(replyTo, _NativeJsSendPort)) && dart.notNull(!dart.is(replyTo, _WorkerSendPort))) {
+      if (dart.notNull(replyTo != null) && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(replyTo, _WorkerSendPort)) {
         throw new core.Exception("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
   let _isClosed = Symbol('_isClosed');
   let _add = Symbol('_add');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort$, isolateId) {
       this[_receivePort] = receivePort$;
@@ skipping 10 matching lines @@
         isolate.handleControlMessage(msg);
         return;
       }
       exports._globalState.topEventLoop.enqueue(isolate, (() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort][_add](msg);
         }
       }).bind(this), `receive ${message}`);
     }
     ['=='](other) {
-      return dart.notNull(dart.is(other, _NativeJsSendPort)) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, '_receivePort')));
+      return dart.is(other, _NativeJsSendPort) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, _receivePort)));
     }
     get hashCode() {
       return this[_receivePort][_id];
     }
   }
   _NativeJsSendPort[dart.implements] = () => [isolate.SendPort];
   class _WorkerSendPort extends _BaseSendPort {
     _WorkerSendPort(workerId$, isolateId, receivePortId$) {
       this[_workerId] = workerId$;
       this[_receivePortId] = receivePortId$;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(workerMessage);
       } else {
         let manager = exports._globalState.managers.get(this[_workerId]);
         if (manager != null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
-      return dart.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'));
+      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];
   let _handler = Symbol('_handler');
   let _nextFreeId = Symbol('_nextFreeId');
   class RawReceivePortImpl extends core.Object {
     RawReceivePortImpl(handler) {
@@ skipping 189 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 = {}));