refactor emitMemberName to be used more consistently

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 138 matching lines @@
       }
       map(convert) {
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           let add = controller.add;
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           let addError = eventSink[_addError];
           subscription = this.listen(event => {
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
-              dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
+              dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
             } else {
               controller.add(newValue);
             }
           }, {onError: dart.as(addError, core.Function), onDone: controller.close});
         }
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
@@ skipping 15 matching lines @@
             sync: true
           });
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           subscription = this.listen(event => {
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
@@ skipping 455 matching lines @@
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       elementAt(index) {
-        if (dart.notNull(!(typeof index == 'number')) || dart.notNull(index) < 0)
+        if (!(typeof index == 'number') || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen(value => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
@@ skipping 15 matching lines @@
         let timeout = null;
         // Function onData: (T) → void
         function onData(event) {
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onError: (dynamic, StackTrace) → void
         function onError(error, stackTrace) {
           timer.cancel();
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
-          dart.dinvoke(eventSink, '_addError', error, stackTrace);
+          dart.dsend(eventSink, _addError, error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onDone: () → void
         function onDone() {
           timer.cancel();
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
@@ skipping 1626 matching lines @@
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
-                dart.dinvoke(completeResult, 'then', ignored => {
+                dart.dsend(completeResult, 'then', ignored => {
                   _Future[_propagateToListeners](source, new _FutureListener.chain(result));
                 }, {
                   onError: (error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future)) {
                       completeResult = new _Future();
-                      dart.dinvoke(completeResult, '_setError', error, stackTrace);
+                      dart.dsend(completeResult, _setError, error, stackTrace);
                     }
                     _Future[_propagateToListeners](dart.as(completeResult, _Future), new _FutureListener.chain(result));
                   }
                 });
               }
             }
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
             if (oldZone != null)
               Zone[_leave](oldZone);
             if (isPropagationAborted)
               return;
-            if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.notNull(dart.is(listenerValueOrError, Future))) {
+            if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.is(listenerValueOrError, Future)) {
               let chainSource = dart.as(listenerValueOrError, Future);
               let result = listener.result;
               if (dart.is(chainSource, _Future)) {
                 if (chainSource[_isComplete]) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
                   _Future[_chainCoreFuture](chainSource, result);
@@ skipping 1586 matching lines @@
       }
     }
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
-        if (dart.notNull(!(typeof count == 'number')) || dart.notNull(count) < 0)
+        if (!(typeof count == 'number') || dart.notNull(count) < 0)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink[_add](inputEvent);
       }
     }
@@ skipping 1178 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));