fixes #206, add checking for unary ops

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var _js_helper = dart.import(_js_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _isolate_helper, _js_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
@@ skipping 166 matching lines @@
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
           }, core.Object, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
         };
         dart.fn(onListen, dart.void, []);
-        if (this.isBroadcast) {
+        if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
               subscription.resume();
             }), onCancel: dart.fn(() => {
               subscription.cancel();
@@ skipping 19 matching lines @@
               return;
             }
 
             if (newStream != null) {
               subscription.pause();
               controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
             }
           }, core.Object, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
         };
         dart.fn(onListen, dart.void, []);
-        if (this.isBroadcast) {
+        if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
               subscription.resume();
             }), onCancel: dart.fn(() => {
               subscription.cancel();
@@ skipping 19 matching lines @@
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(T, [T, T]));
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          if (seenFirst) {
+          if (dart.notNull(seenFirst)) {
             _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
             }, core.Object, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
         }, core.Object, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
@@ skipping 53 matching lines @@
             result[_complete](dart.toString(buffer));
           }), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
-            if (isMatch) {
+            if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
           }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](false);
           }), cancelOnError: true});
         return future;
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [T]));
@@ skipping 24 matching lines @@
           }), cancelOnError: true});
         return future;
       }
       any(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
-            if (isMatch) {
+            if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
           }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](false);
           }), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
@@ skipping 82 matching lines @@
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           foundResult = true;
           result = value;
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            if (foundResult) {
+            if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
-          if (foundResult) {
+          if (dart.notNull(foundResult)) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            if (foundResult) {
+            if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       firstWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
-            if (isMatch) {
+            if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, value);
             }
           }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       lastWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
-            if (isMatch) {
+            if (dart.notNull(isMatch)) {
               foundResult = true;
               result = value;
             }
           }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            if (foundResult) {
+            if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
-            if (isMatch) {
-              if (foundResult) {
+            if (dart.notNull(isMatch)) {
+              if (dart.notNull(foundResult)) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
           }, core.Object, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(core.Object, [dart.bottom, core.StackTrace])));
         }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
-            if (foundResult) {
+            if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
@@ skipping 65 matching lines @@
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         };
         dart.fn(onListen, dart.void, []);
         let onCancel = () => {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         };
         dart.fn(onCancel, Future, []);
-        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
+        controller = dart.notNull(this.isBroadcast) ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
           timer.cancel();
           subscription.pause();
         }), dart.fn(() => {
           subscription.resume();
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }), onCancel);
         return controller.stream;
       }
     }
     dart.setSignature(Stream, {
@@ skipping 83 matching lines @@
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
-        if (core.identical(this, other))
+        if (dart.notNull(core.identical(this, other)))
           return true;
         if (!dart.is(other, _ControllerStream$()))
           return false;
         let otherStream = dart.as(other, _ControllerStream$());
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
     dart.setSignature(_ControllerStream, {
       constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamControllerLifecycle$(T)]]}),
       methods: () => ({
@@ skipping 56 matching lines @@
   let _sendData = Symbol('_sendData');
   let _addPending = Symbol('_addPending');
   let _sendError = Symbol('_sendError');
   let _close = Symbol('_close');
   let _sendDone = Symbol('_sendDone');
   let _checkState = Symbol('_checkState');
   let _BufferingStreamSubscription$ = dart.generic(function(T) {
     class _BufferingStreamSubscription extends core.Object {
       _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
         this[_zone] = Zone.current;
-        this[_state] = cancelOnError ? _BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR : 0;
+        this[_state] = dart.notNull(cancelOnError) ? _BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR : 0;
         this[_onData] = null;
         this[_onError] = null;
         this[_onDone] = null;
         this[_cancelFuture] = null;
         this[_pending] = null;
         this.onData(onData);
         this.onError(onError);
         this.onDone(onDone);
       }
       [_setPendingEvents](pendingEvents) {
@@ skipping 25 matching lines @@
       }
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         if (handleDone == null)
           handleDone = _nullDoneHandler;
         this[_onDone] = this[_zone].registerCallback(handleDone);
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return;
         let wasPaused = this[_isPaused];
         let wasInputPaused = this[_isInputPaused];
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
         if (resumeSignal != null)
           resumeSignal.whenComplete(dart.bind(this, 'resume'));
-        if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] != null))
+        if (!dart.notNull(wasPaused) && this[_pending] != null)
           this[_pending].cancelSchedule();
         if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
           this[_guardCallback](dart.bind(this, _onPause));
       }
       resume() {
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return;
-        if (this[_isPaused]) {
+        if (dart.notNull(this[_isPaused])) {
           this[_decrementPauseCount]();
           if (!dart.notNull(this[_isPaused])) {
             if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
               this[_pending].schedule(this);
             } else {
               dart.assert(this[_mayResumeInput]);
               this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
               if (!dart.notNull(this[_inCallback]))
                 this[_guardCallback](dart.bind(this, _onResume));
             }
           }
         }
       }
       cancel() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new (_Future$(T))();
         this[_onDone] = dart.fn(() => {
           result[_complete](futureValue);
@@ skipping 22 matching lines @@
       get [_hasPending]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING)) != 0;
       }
       get [_isPaused]() {
         return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT);
       }
       get [_canFire]() {
         return dart.notNull(this[_state]) < dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
       }
       get [_mayResumeInput]() {
-        return !dart.notNull(this[_isPaused]) && (dart.notNull(this[_pending] == null) || dart.notNull(this[_pending].isEmpty));
+        return !dart.notNull(this[_isPaused]) && (this[_pending] == null || dart.notNull(this[_pending].isEmpty));
       }
       get [_cancelOnError]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR)) != 0;
       }
       get isPaused() {
         return this[_isPaused];
       }
       [_cancel]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED);
-        if (this[_hasPending]) {
+        if (dart.notNull(this[_hasPending])) {
           this[_pending].cancelSchedule();
         }
         if (!dart.notNull(this[_inCallback]))
           this[_pending] = null;
         this[_cancelFuture] = this[_onCancel]();
       }
       [_incrementPauseCount]() {
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
       }
       [_decrementPauseCount]() {
         dart.assert(this[_isPaused]);
         this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT);
       }
       [_add](data) {
         dart.as(data, T);
         dart.assert(!dart.notNull(this[_isClosed]));
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return;
-        if (this[_canFire]) {
+        if (dart.notNull(this[_canFire])) {
           this[_sendData](data);
         } else {
           this[_addPending](new _DelayedData(data));
         }
       }
       [_addError](error, stackTrace) {
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return;
-        if (this[_canFire]) {
+        if (dart.notNull(this[_canFire])) {
           this[_sendError](error, stackTrace);
         } else {
           this[_addPending](new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(!dart.notNull(this[_isClosed]));
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED);
-        if (this[_canFire]) {
+        if (dart.notNull(this[_canFire])) {
           this[_sendDone]();
         } else {
           this[_addPending](dart.const(new _DelayedDone()));
         }
       }
       [_onPause]() {
         dart.assert(this[_isInputPaused]);
       }
       [_onResume]() {
         dart.assert(!dart.notNull(this[_isInputPaused]));
@@ skipping 35 matching lines @@
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), error);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         };
         dart.fn(sendError, dart.void, []);
-        if (this[_cancelOnError]) {
+        if (dart.notNull(this[_cancelOnError])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
           }
         } else {
           sendError();
           this[_checkState](wasInputPaused);
@@ skipping 29 matching lines @@
       }
       [_checkState](wasInputPaused) {
         dart.assert(!dart.notNull(this[_inCallback]));
         if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING);
           if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
             this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
           }
         }
         while (true) {
-          if (this[_isCanceled]) {
+          if (dart.notNull(this[_isCanceled])) {
             this[_pending] = null;
             return;
           }
           let isInputPaused = this[_isInputPaused];
           if (wasInputPaused == isInputPaused)
             break;
           this[_state] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-          if (isInputPaused) {
+          if (dart.notNull(isInputPaused)) {
             this[_onPause]();
           } else {
             this[_onResume]();
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
@@ skipping 186 matching lines @@
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
         let previous = subscription[_previous];
         let next = subscription[_next];
         previous[_next] = next;
         next[_previous] = previous;
         subscription[_next] = subscription[_previous] = subscription;
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
-        if (this.isClosed) {
+        if (dart.notNull(this.isClosed)) {
           if (onDone == null)
             onDone = _nullDoneHandler;
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         let subscription = new (_BroadcastSubscription$(T))(this, onData, onError, onDone, cancelOnError);
         this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
-        if (core.identical(this[_next], this[_previous])) {
+        if (dart.notNull(core.identical(this[_next], this[_previous]))) {
           _runGuarded(this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
-        if (core.identical(subscription[_next], subscription))
+        if (dart.notNull(core.identical(subscription[_next], subscription)))
           return null;
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
-        if (subscription[_isFiring]) {
+        if (dart.notNull(dart.as(subscription[_isFiring], core.bool))) {
           dart.dcall(subscription[_setRemoveAfterFiring]);
         } else {
           dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
           this[_removeListener](dart.as(subscription, _BroadcastSubscription$(T)));
           if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
         }
         return null;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_addEventError]() {
-        if (this.isClosed) {
+        if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add new events after calling close");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add new events while doing an addStream");
       }
       add(data) {
         dart.as(data, T);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_sendData](data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_sendError](error, stackTrace);
       }
       close() {
-        if (this.isClosed) {
+        if (dart.notNull(this.isClosed)) {
           dart.assert(this[_doneFuture] != null);
           return this[_doneFuture];
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_CLOSED);
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
@@ skipping 18 matching lines @@
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = this[_addStreamState];
         this[_addStreamState] = null;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_forEachListener](action) {
         dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
-        if (this[_isFiring]) {
+        if (dart.notNull(this[_isFiring])) {
           throw new core.StateError("Cannot fire new event. Controller is already firing an event");
         }
-        if (this[_isEmpty])
+        if (dart.notNull(this[_isEmpty]))
           return;
         let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
         this[_state] = dart.notNull(this[_state]) ^ (dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController$()._STATE_FIRING));
         let link = this[_next];
         while (!dart.notNull(core.identical(link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          if (subscription[_expectsEvent](id)) {
+          if (dart.notNull(subscription[_expectsEvent](id))) {
             subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
             action(subscription);
             subscription[_toggleEventId]();
             link = subscription[_next];
-            if (subscription[_removeAfterFiring]) {
+            if (dart.notNull(subscription[_removeAfterFiring])) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription._STATE_FIRING);
           } else {
             link = subscription[_next];
           }
         }
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_FIRING);
-        if (this[_isEmpty]) {
+        if (dart.notNull(this[_isEmpty])) {
           this[_callOnCancel]();
         }
       }
       [_callOnCancel]() {
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
           this[_doneFuture][_asyncComplete](null);
         }
         _runGuarded(this[_onCancel]);
       }
@@ skipping 29 matching lines @@
   _BroadcastStreamController._STATE_FIRING = 2;
   _BroadcastStreamController._STATE_CLOSED = 4;
   _BroadcastStreamController._STATE_ADDSTREAM = 8;
   let _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
-        if (this[_isEmpty])
+        if (dart.notNull(this[_isEmpty]))
           return;
-        if (this[_hasOneListener]) {
+        if (dart.notNull(this[_hasOneListener])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
           let subscription = dart.as(this[_next], _BroadcastSubscription);
           subscription[_add](data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
-          if (this[_isEmpty]) {
+          if (dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_add](data);
         }, core.Object, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
-        if (this[_isEmpty])
+        if (dart.notNull(this[_isEmpty]))
           return;
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_addError](error, stackTrace);
         }, core.Object, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.as(dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
@@ skipping 60 matching lines @@
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
-        return dart.notNull(this[_pending] != null) && !dart.notNull(this[_pending].isEmpty);
+        return this[_pending] != null && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
         if (this[_pending] == null) {
           this[_pending] = new _StreamImplEvents();
         }
         this[_pending].add(event);
       }
       add(data) {
         dart.as(data, T);
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new (_DelayedData$(T))(data));
           return;
         }
         super.add(data);
-        while (this[_hasPending]) {
+        while (dart.notNull(this[_hasPending])) {
           this[_pending].handleNext(this);
         }
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new _DelayedError(error, stackTrace));
           return;
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_sendError](error, stackTrace);
-        while (this[_hasPending]) {
+        while (dart.notNull(this[_hasPending])) {
           this[_pending].handleNext(this);
         }
       }
       close() {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](dart.const(new _DelayedDone()));
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_CLOSED);
           return super.done;
         }
         let result = super.close();
         dart.assert(!dart.notNull(this[_hasPending]));
         return result;
       }
       [_callOnCancel]() {
-        if (this[_hasPending]) {
+        if (dart.notNull(this[_hasPending])) {
           this[_pending].clear();
           this[_pending] = null;
         }
         super[_callOnCancel]();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
       constructors: () => ({_AsBroadcastStreamController: [_AsBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
@@ skipping 202 matching lines @@
           let pos = remaining;
           remaining = dart.notNull(pos) + 1;
           future.then(dart.fn(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[dartx.set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
-              if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
+              if (cleanUp != null && value != null) {
                 Future$().sync(dart.fn(() => {
                   dart.dcall(cleanUp, value);
                 }));
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, core.Object, [core.Object]), {onError: handleError});
         }
@@ skipping 10 matching lines @@
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return Future$().sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [core.Object]));
         }));
       }
       static doWhile(f) {
         dart.as(f, dart.functionType(core.Object, []));
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
-          if (keepGoing) {
+          if (dart.notNull(keepGoing)) {
             Future$().sync(f).then(dart.as(nextIteration, __CastType4), {onError: dart.bind(doneSignal, _completeError)});
           } else {
             doneSignal[_complete](null);
           }
         }, core.Object, [core.bool]), {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.setSignature(Future, {
@@ skipping 287 matching lines @@
       get [_isComplete]() {
         return dart.notNull(this[_state]) >= dart.notNull(_Future$()._VALUE);
       }
       get [_hasValue]() {
         return this[_state] == _Future$()._VALUE;
       }
       get [_hasError]() {
         return this[_state] == _Future$()._ERROR;
       }
       set [_isChained](value) {
-        if (value) {
+        if (dart.notNull(value)) {
           dart.assert(!dart.notNull(this[_isComplete]));
           this[_state] = _Future$()._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future$()._INCOMPLETE;
         }
       }
       then(f, opts) {
         dart.as(f, dart.functionType(core.Object, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
@@ skipping 53 matching lines @@
       [_setErrorObject](error) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future$()._ERROR;
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
         this[_setErrorObject](new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] == null);
-        if (this[_isComplete]) {
+        if (dart.notNull(this[_isComplete])) {
           this[_zone].scheduleMicrotask(dart.fn(() => {
             _Future$()._propagateToListeners(this, listener);
           }));
         } else {
           listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureListener);
           this[_resultOrListeners] = listener;
         }
       }
       [_removeListeners]() {
         dart.assert(!dart.notNull(this[_isComplete]));
@@ skipping 20 matching lines @@
               stackTrace = null;
             dart.assert(target[_isChained]);
             target[_completeError](error, dart.as(stackTrace, core.StackTrace));
           }, core.Object, [core.Object], [core.Object])});
       }
       static _chainCoreFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future$()));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
-        if (source[_isComplete]) {
+        if (dart.notNull(source[_isComplete])) {
           _Future$()._propagateToListeners(source, listener);
         } else {
           source[_addListener](listener);
         }
       }
       [_complete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (dart.is(value, Future)) {
           if (dart.is(value, _Future$())) {
             _Future$()._chainCoreFuture(dart.as(value, _Future$()), this);
@@ skipping 53 matching lines @@
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask(dart.fn(() => {
           this[_completeError](error, stackTrace);
         }));
       }
       static _propagateToListeners(source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners == null) {
-            if (hasError) {
+            if (dart.notNull(hasError)) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
             return;
           }
           while (listeners[_nextListener] != null) {
             let listener = listeners;
             listeners = listener[_nextListener];
             listener[_nextListener] = null;
             _Future$()._propagateToListeners(source, listener);
           }
           let listener = listeners;
           let listenerHasValue = true;
-          let sourceValue = hasError ? null : source[_value];
+          let sourceValue = dart.notNull(hasError) ? null : source[_value];
           let listenerValueOrError = sourceValue;
           let isPropagationAborted = false;
           if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
             if (!dart.notNull(core.identical(Zone.current, zone))) {
               oldZone = Zone._enter(zone);
             }
             let handleValueCallback = () => {
               try {
                 listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
               }
 
             };
             dart.fn(handleValueCallback, core.bool, []);
             let handleError = () => {
               let asyncError = source[_error];
               let matchesTest = true;
-              if (listener.hasErrorTest) {
+              if (dart.notNull(listener.hasErrorTest)) {
                 let test = listener[_errorTest];
                 try {
                   matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
               }
               let errorCallback = listener[_onError];
-              if (dart.notNull(matchesTest) && dart.notNull(errorCallback != null)) {
+              if (dart.notNull(matchesTest) && errorCallback != null) {
                 try {
                   if (dart.is(errorCallback, ZoneBinaryCallback)) {
                     listenerValueOrError = zone.runBinary(errorCallback, asyncError.error, asyncError.stackTrace);
                   } else {
                     listenerValueOrError = zone.runUnary(dart.as(errorCallback, __CastType10), asyncError.error);
                   }
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
                 listenerValueOrError = asyncError;
                 listenerHasValue = false;
               }
             };
@@ skipping 25 matching lines @@
                     if (!dart.is(completeResult, _Future$())) {
                       completeResult = new (_Future$())();
                       dart.dsend(completeResult, _setError, error, stackTrace);
                     }
                     _Future$()._propagateToListeners(dart.as(completeResult, _Future$()), new _FutureListener.chain(result));
                   }, core.Object, [core.Object], [core.Object])});
               }
             };
             dart.fn(handleWhenCompleteCallback, dart.void, []);
             if (!dart.notNull(hasError)) {
-              if (listener.handlesValue) {
+              if (dart.notNull(listener.handlesValue)) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
-            if (listener.handlesComplete) {
+            if (dart.notNull(listener.handlesComplete)) {
               handleWhenCompleteCallback();
             }
             if (oldZone != null)
               Zone._leave(oldZone);
-            if (isPropagationAborted)
+            if (dart.notNull(isPropagationAborted))
               return;
             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]) {
+                if (dart.notNull(chainSource[_isComplete])) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
                   _Future$()._chainCoreFuture(chainSource, result);
                 }
               } else {
                 _Future$()._chainForeignFuture(chainSource, result);
               }
               return;
             }
           }
           let result = listener.result;
           listeners = result[_removeListeners]();
-          if (listenerHasValue) {
+          if (dart.notNull(listenerHasValue)) {
             result[_setValue](listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
             result[_setErrorObject](asyncError);
           }
           source = result;
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(core.Object, []));
-        if (this[_isComplete])
+        if (dart.notNull(this[_isComplete]))
           return new (_Future$()).immediate(this);
         let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
           timer = Timer.new(timeLimit, dart.fn(() => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
           }));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = Timer.new(timeLimit, dart.fn(() => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
           }));
         }
         this.then(dart.fn(v => {
           dart.as(v, T);
-          if (timer.isActive) {
+          if (dart.notNull(timer.isActive)) {
             timer.cancel();
             result[_completeWithValue](v);
           }
         }, core.Object, [T]), {onError: dart.fn((e, s) => {
-            if (timer.isActive) {
+            if (dart.notNull(timer.isActive)) {
               timer.cancel();
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
           })});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
@@ skipping 105 matching lines @@
       entry.next = exports._lastPriorityCallback.next;
       exports._lastPriorityCallback.next = entry;
       exports._lastPriorityCallback = entry;
       if (entry.next == null) {
         exports._lastCallback = entry;
       }
     }
   }
   dart.fn(_schedulePriorityAsyncCallback, dart.void, [core.Object]);
   function scheduleMicrotask(callback) {
-    if (core.identical(_ROOT_ZONE, Zone.current)) {
+    if (dart.notNull(core.identical(_ROOT_ZONE, Zone.current))) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
   class _AsyncRun extends core.Object {
     static _scheduleImmediate(callback) {
       dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
     }
     static _initializeScheduleImmediate() {
       if (self.scheduleImmediate != null) {
         return _AsyncRun._scheduleImmediateJsOverride;
       }
-      if (dart.notNull(self.MutationObserver != null) && dart.notNull(self.document != null)) {
+      if (self.MutationObserver != null && self.document != null) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         let internalCallback = _ => {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dcall(f);
         };
         dart.fn(internalCallback);
@@ skipping 173 matching lines @@
   let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, []));
   let __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
   let StreamController$ = dart.generic(function(T) {
     class StreamController extends core.Object {
       static new(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
-        if (dart.notNull(onListen == null) && dart.notNull(onPause == null) && dart.notNull(onResume == null) && dart.notNull(onCancel == null)) {
-          return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
+        if (onListen == null && onPause == null && onResume == null && onCancel == null) {
+          return dart.as(dart.notNull(sync) ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
-        return sync ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
+        return dart.notNull(sync) ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       static broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
-        return sync ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
+        return dart.notNull(sync) ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(StreamController, {
       constructors: () => ({
         new: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onPause: dart.functionType(dart.void, []), onResume: dart.functionType(dart.void, []), onCancel: dart.functionType(core.Object, []), sync: core.bool}],
         broadcast: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onCancel: dart.functionType(dart.void, []), sync: core.bool}]
       })
     });
     return StreamController;
@@ skipping 47 matching lines @@
       get hasListener() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._STATE_SUBSCRIBED)) != 0;
       }
       get [_isInitialState]() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._STATE_SUBSCRIPTION_MASK)) == _StreamController$()._STATE_INITIAL;
       }
       get isClosed() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._STATE_CLOSED)) != 0;
       }
       get isPaused() {
-        return this.hasListener ? this[_subscription][_isInputPaused] : !dart.notNull(this[_isCanceled]);
+        return dart.notNull(this.hasListener) ? this[_subscription][_isInputPaused] : !dart.notNull(this[_isCanceled]);
       }
       get [_isAddingStream]() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._STATE_ADDSTREAM)) != 0;
       }
       get [_mayAddEvent]() {
         return dart.notNull(this[_state]) < dart.notNull(_StreamController$()._STATE_CLOSED);
       }
       get [_pendingEvents]() {
         dart.assert(this[_isInitialState]);
         if (!dart.notNull(this[_isAddingStream])) {
           return dart.as(this[_varData], _PendingEvents);
         }
         let state = dart.as(this[_varData], _StreamControllerAddStreamState);
         return dart.as(state.varData, _PendingEvents);
       }
       [_ensurePendingEvents]() {
         dart.assert(this[_isInitialState]);
         if (!dart.notNull(this[_isAddingStream])) {
           if (this[_varData] == null)
             this[_varData] = new _StreamImplEvents();
           return dart.as(this[_varData], _StreamImplEvents);
         }
         let state = dart.as(this[_varData], _StreamControllerAddStreamState);
         if (state.varData == null)
           state.varData = new _StreamImplEvents();
         return dart.as(state.varData, _StreamImplEvents);
       }
       get [_subscription]() {
         dart.assert(this.hasListener);
-        if (this[_isAddingStream]) {
+        if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           return dart.as(addState.varData, _ControllerSubscription);
         }
         return dart.as(this[_varData], _ControllerSubscription);
       }
       [_badEventState]() {
-        if (this.isClosed) {
+        if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add event after closing");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
-        if (this[_isCanceled])
+        if (dart.notNull(this[_isCanceled]))
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         return addState.addStreamFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] == null) {
-          this[_doneFuture] = this[_isCanceled] ? Future._nullFuture : new _Future();
+          this[_doneFuture] = dart.notNull(this[_isCanceled]) ? Future._nullFuture : new _Future();
         }
         return this[_doneFuture];
       }
       add(value) {
         dart.as(value, T);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_add](value);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_addError](error, stackTrace);
       }
       close() {
-        if (this.isClosed) {
+        if (dart.notNull(this.isClosed)) {
           return this[_ensureDoneFuture]();
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_closeUnchecked]();
         return this[_ensureDoneFuture]();
       }
       [_closeUnchecked]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_CLOSED);
-        if (this.hasListener) {
+        if (dart.notNull(this.hasListener)) {
           this[_sendDone]();
-        } else if (this[_isInitialState]) {
+        } else if (dart.notNull(this[_isInitialState])) {
           this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
         }
       }
       [_add](value) {
         dart.as(value, T);
-        if (this.hasListener) {
+        if (dart.notNull(this.hasListener)) {
           this[_sendData](value);
-        } else if (this[_isInitialState]) {
+        } else if (dart.notNull(this[_isInitialState])) {
           this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
-        if (this.hasListener) {
+        if (dart.notNull(this.hasListener)) {
           this[_sendError](error, stackTrace);
-        } else if (this[_isInitialState]) {
+        } else if (dart.notNull(this[_isInitialState])) {
           this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
         this[_varData] = addState.varData;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (!dart.notNull(this[_isInitialState])) {
           throw new core.StateError("Stream has already been listened to.");
         }
         let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
-        if (this[_isAddingStream]) {
+        if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
         }
         subscription[_setPendingEvents](pendingEvents);
         subscription[_guardCallback](dart.fn(() => {
           _runGuarded(this[_onListen]);
         }));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         let result = null;
-        if (this[_isAddingStream]) {
+        if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
         this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController$()._STATE_SUBSCRIBED) | dart.notNull(_StreamController$()._STATE_ADDSTREAM)) | dart.notNull(_StreamController$()._STATE_CANCELED);
         if (this[_onCancel] != null) {
           if (result == null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
         let complete = () => {
-          if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
+          if (this[_doneFuture] != null && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture][_asyncComplete](null);
           }
         };
         dart.fn(complete, dart.void, []);
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
         return result;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
-        if (this[_isAddingStream]) {
+        if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.pause();
         }
         _runGuarded(this[_onPause]);
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
-        if (this[_isAddingStream]) {
+        if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.resume();
         }
         _runGuarded(this[_onResume]);
       }
     }
     _StreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_StreamController, {
       constructors: () => ({_StreamController: [_StreamController$(T), []]}),
       methods: () => ({
@@ skipping 172 matching lines @@
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(dart.bind(controller, _add), {onError: cancelOnError ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(dart.bind(controller, _add), {onError: dart.notNull(cancelOnError) ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
         }, core.Object, [core.Object, core.StackTrace]);
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 26 matching lines @@
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$();
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
-        if (controller.isPaused) {
+        if (dart.notNull(controller.isPaused)) {
           this.addSubscription.pause();
         }
       }
     }
     dart.setSignature(_StreamControllerAddStreamState, {
       constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, core.Object, Stream, core.bool]]})
     });
     return _StreamControllerAddStreamState;
   });
   let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
@@ skipping 20 matching lines @@
   let _isUsed = Symbol('_isUsed');
   let _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending) {
         this[_pending] = pending;
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
-        if (this[_isUsed])
+        if (dart.notNull(this[_isUsed]))
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
           _[_setPendingEvents](this[_pending]());
           return _;
         })(), StreamSubscription$(T));
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
       constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
       methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
     get isScheduled() {
       return this[_state] == _PendingEvents._STATE_SCHEDULED;
     }
     get [_eventScheduled]() {
       return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
     }
     schedule(dispatch) {
-      if (this.isScheduled)
+      if (dart.notNull(this.isScheduled))
         return;
       dart.assert(!dart.notNull(this.isEmpty));
-      if (this[_eventScheduled]) {
+      if (dart.notNull(this[_eventScheduled])) {
         dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
         this[_state] = _PendingEvents._STATE_SCHEDULED;
         return;
       }
       scheduleMicrotask(dart.fn(() => {
         let oldState = this[_state];
         this[_state] = _PendingEvents._STATE_UNSCHEDULED;
         if (oldState == _PendingEvents._STATE_CANCELED)
           return;
         this.handleNext(dispatch);
       }));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
-      if (this.isScheduled)
+      if (dart.notNull(this.isScheduled))
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
       schedule: [dart.void, [_EventDispatch]],
       cancelSchedule: [dart.void, []]
     })
   });
   let _iterator = Symbol('_iterator');
@@ skipping 21 matching lines @@
         }
 
         if (!dart.notNull(isDone)) {
           dispatch[_sendData](this[_iterator].current);
         } else {
           this[_iterator] = null;
           dispatch[_sendDone]();
         }
       }
       clear() {
-        if (this.isScheduled)
+        if (dart.notNull(this.isScheduled))
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     dart.setSignature(_IterablePendingEvents, {
       constructors: () => ({_IterablePendingEvents: [_IterablePendingEvents$(T), [core.Iterable$(T)]]}),
       methods: () => ({
         handleNext: [dart.void, [_EventDispatch]],
         clear: [dart.void, []]
       })
@@ skipping 100 matching lines @@
     handleNext(dispatch) {
       dart.assert(!dart.notNull(this.isScheduled));
       let event = this.firstPendingEvent;
       this.firstPendingEvent = event.next;
       if (this.firstPendingEvent == null) {
         this.lastPendingEvent = null;
       }
       event.perform(dispatch);
     }
     clear() {
-      if (this.isScheduled)
+      if (dart.notNull(this.isScheduled))
         this.cancelSchedule();
       this.firstPendingEvent = this.lastPendingEvent = null;
     }
   }
   dart.setSignature(_StreamImplEvents, {
     methods: () => ({
       add: [dart.void, [_DelayedEvent]],
       handleNext: [dart.void, [_EventDispatch]],
       clear: [dart.void, []]
     })
@@ skipping 39 matching lines @@
       get [_isSent]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription$()._DONE_SENT)) != 0;
       }
       get [_isScheduled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription$()._SCHEDULED)) != 0;
       }
       get isPaused() {
         return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscription$()._PAUSED);
       }
       [_schedule]() {
-        if (this[_isScheduled])
+        if (dart.notNull(this[_isScheduled]))
           return;
         this[_zone].scheduleMicrotask(dart.bind(this, _sendDone));
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
       }
       onError(handleError) {}
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription$()._PAUSED);
         if (resumeSignal != null)
           resumeSignal.whenComplete(dart.bind(this, 'resume'));
       }
       resume() {
-        if (this.isPaused) {
+        if (dart.notNull(this.isPaused)) {
           this[_state] = dart.notNull(this[_state]) - dart.notNull(_DoneStreamSubscription$()._PAUSED);
           if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
             this[_schedule]();
           }
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = dart.fn(() => {
           result[_completeWithValue](null);
         });
         return result;
       }
       [_sendDone]() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
-        if (this.isPaused)
+        if (dart.notNull(this.isPaused))
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneStreamSubscription, {
       constructors: () => ({_DoneStreamSubscription: [_DoneStreamSubscription$(T), [_DoneHandler]]}),
       methods: () => ({
@@ skipping 35 matching lines @@
       }
       get isBroadcast() {
         return true;
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
-        if (dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed)) {
+        if (this[_controller] == null || dart.notNull(this[_controller].isClosed)) {
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         if (this[_subscription] == null) {
           this[_subscription] = this[_source].listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind(this[_controller], 'close')});
         }
         cancelOnError = core.identical(true, cancelOnError);
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
-        let shutdown = dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed);
+        let shutdown = this[_controller] == null || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] != null) {
           this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
         }
-        if (shutdown) {
+        if (dart.notNull(shutdown)) {
           if (this[_subscription] != null) {
             this[_subscription].cancel();
             this[_subscription] = null;
           }
         }
       }
       [_onListen]() {
         if (this[_onListenHandler] != null) {
           this[_zone].runUnary(this[_onListenHandler], new _BroadcastSubscriptionWrapper(this));
         }
@@ skipping 332 matching lines @@
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       [_add](data) {
         dart.as(data, T);
-        if (this[_isClosed])
+        if (dart.notNull(this[_isClosed]))
           return;
         super[_add](data);
       }
       [_addError](error, stackTrace) {
-        if (this[_isClosed])
+        if (dart.notNull(this[_isClosed]))
           return;
         super[_addError](error, stackTrace);
       }
       [_onPause]() {
         if (this[_subscription] == null)
           return;
         this[_subscription].pause();
       }
       [_onResume]() {
         if (this[_subscription] == null)
@@ skipping 57 matching lines @@
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
-        if (satisfies) {
+        if (dart.notNull(satisfies)) {
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_WhereStream, {
       constructors: () => ({_WhereStream: [_WhereStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _WhereStream;
   });
@@ skipping 74 matching lines @@
         if (this[_test] != null) {
           try {
             matches = dart.dcall(this[_test], error);
           } catch (e) {
             let s = dart.stackTrace(e);
             _addErrorWithReplacement(sink, e, s);
             return;
           }
 
         }
-        if (matches) {
+        if (dart.notNull(matches)) {
           try {
             _invokeErrorHandler(this[_transform], error, stackTrace);
           } catch (e) {
             let s = dart.stackTrace(e);
-            if (core.identical(e, error)) {
+            if (dart.notNull(core.identical(e, error))) {
               sink[_addError](error, stackTrace);
             } else {
               _addErrorWithReplacement(sink, e, s);
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
@@ skipping 46 matching lines @@
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           sink[_close]();
           return;
         }
 
-        if (satisfies) {
+        if (dart.notNull(satisfies)) {
           sink[_add](inputEvent);
         } else {
           sink[_close]();
         }
       }
     }
     dart.setSignature(_TakeWhileStream, {
       constructors: () => ({_TakeWhileStream: [_TakeWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
@@ skipping 29 matching lines @@
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
-        if (this[_hasFailed]) {
+        if (dart.notNull(this[_hasFailed])) {
           sink[_add](inputEvent);
           return;
         }
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           this[_hasFailed] = true;
@@ skipping 22 matching lines @@
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream$()._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
-        if (core.identical(this[_previous], _DistinctStream$()._SENTINEL)) {
+        if (dart.notNull(core.identical(this[_previous], _DistinctStream$()._SENTINEL))) {
           this[_previous] = inputEvent;
           return sink[_add](inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
               isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
             }
@@ skipping 63 matching lines @@
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
         this[_subscription] = source.listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
         dart.as(data, T);
-        if (this[_isClosed]) {
+        if (dart.notNull(this[_isClosed])) {
           throw new core.StateError("Stream is already closed");
         }
         super[_add](data);
       }
       [_addError](error, stackTrace) {
-        if (this[_isClosed]) {
+        if (dart.notNull(this[_isClosed])) {
           throw new core.StateError("Stream is already closed");
         }
         super[_addError](error, stackTrace);
       }
       [_close]() {
-        if (this[_isClosed]) {
+        if (dart.notNull(this[_isClosed])) {
           throw new core.StateError("Stream is already closed");
         }
         super[_close]();
       }
       [_onPause]() {
-        if (this[_isSubscribed])
+        if (dart.notNull(this[_isSubscribed]))
           this[_subscription].pause();
       }
       [_onResume]() {
-        if (this[_isSubscribed])
+        if (dart.notNull(this[_isSubscribed]))
           this[_subscription].resume();
       }
       [_onCancel]() {
-        if (this[_isSubscribed]) {
+        if (dart.notNull(this[_isSubscribed])) {
           let subscription = this[_subscription];
           this[_subscription] = null;
           subscription.cancel();
         }
         return null;
       }
       [_handleData](data) {
         dart.as(data, S);
         try {
           this[_transformerSink].add(data);
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
       [_handleError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         try {
           this[_transformerSink].addError(error, dart.as(stackTrace, core.StackTrace));
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (core.identical(e, error)) {
+          if (dart.notNull(core.identical(e, error))) {
             this[_addError](error, dart.as(stackTrace, core.StackTrace));
           } else {
             this[_addError](e, s);
           }
         }
 
       }
       [_handleDone]() {
         try {
           this[_subscription] = null;
@@ skipping 458 matching lines @@
     get [_delegate]() {
       if (_RootZone._rootDelegate != null)
         return _RootZone._rootDelegate;
       return _RootZone._rootDelegate = new _ZoneDelegate(this);
     }
     get errorZone() {
       return this;
     }
     runGuarded(f) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone._current)) {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
           return f();
         }
         return _rootRun(null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone._current)) {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
           return dart.dcall(f, arg);
         }
         return _rootRunUnary(null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone._current)) {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
           return dart.dcall(f, arg1, arg2);
         }
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn(() => this.runGuarded(f));
       } else {
         return dart.fn(() => this.run(f));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn(arg => this.runUnaryGuarded(f, arg));
       } else {
         return dart.fn(arg => this.runUnary(f, arg));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2));
       } else {
         return dart.fn((arg1, arg2) => this.runBinary(f, arg1, arg2));
       }
     }
     get(key) {
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       return _rootHandleUncaughtError(null, null, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
       let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       return _rootFork(null, null, this, specification, zoneValues);
     }
     run(f) {
-      if (core.identical(Zone._current, _ROOT_ZONE))
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
         return f();
       return _rootRun(null, null, this, f);
     }
     runUnary(f, arg) {
-      if (core.identical(Zone._current, _ROOT_ZONE))
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
         return dart.dcall(f, arg);
       return _rootRunUnary(null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
-      if (core.identical(Zone._current, _ROOT_ZONE))
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
         return dart.dcall(f, arg1, arg2);
       return _rootRunBinary(null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
@@ skipping 85 matching lines @@
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerBinaryCallback];
       let implZone = implementation.zone;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
     }
     errorCallback(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_errorCallback];
       let implZone = implementation.zone;
-      if (core.identical(implZone, _ROOT_ZONE))
+      if (dart.notNull(core.identical(implZone, _ROOT_ZONE)))
         return null;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(zone, f) {
       let implementation = this[_delegationTarget][_scheduleMicrotask];
       let implZone = implementation.zone;
       dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     createTimer(zone, duration, f) {
       let implementation = this[_delegationTarget][_createTimer];
@@ skipping 101 matching lines @@
         return this.runBinary(f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerCallback(f);
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn(() => this.runGuarded(registered));
       } else {
         return dart.fn(() => this.run(registered));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerUnaryCallback(f);
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn(arg => this.runUnaryGuarded(registered, arg));
       } else {
         return dart.fn(arg => this.runUnary(registered, arg));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
-      if (runGuarded) {
+      if (dart.notNull(runGuarded)) {
         return dart.fn((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2));
       } else {
         return dart.fn((arg1, arg2) => this.runBinary(registered, arg1, arg2));
       }
     }
     get(key) {
       let result = this[_map].get(key);
-      if (dart.notNull(result != null) || dart.notNull(this[_map].containsKey(key)))
+      if (result != null || dart.notNull(this[_map].containsKey(key)))
         return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
           this[_map].set(key, value);
         }
         return value;
       }
       dart.assert(dart.equals(this, _ROOT_ZONE));
       return null;
@@ skipping 45 matching lines @@
     registerBinaryCallback(f) {
       let implementation = this[_registerBinaryCallback];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
     }
     errorCallback(error, stackTrace) {
       let implementation = this[_errorCallback];
       dart.assert(implementation != null);
       let implementationZone = implementation.zone;
-      if (core.identical(implementationZone, _ROOT_ZONE))
+      if (dart.notNull(core.identical(implementationZone, _ROOT_ZONE)))
         return null;
       let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
       return dart.as(dart.dcall(implementation.function, implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(f) {
       let implementation = this[_scheduleMicrotask];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f);
     }
@@ skipping 202 matching lines @@
     let errorHandler = null;
     if (onError != null) {
       errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
           }
           return self.parent.runUnary(dart.as(onError, __CastType38), error);
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (core.identical(e, error)) {
+          if (dart.notNull(core.identical(e, error))) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
       }, core.Object, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = ZoneSpecification.new({handleUncaughtError: errorHandler});
@@ skipping 58 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, core, _internal, _isolate_helper, _js_helper, collection);