Make int and double nullable by default

test/codegen/expect/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   dart.copyProperties(exports, {
     get _hasDocument() {
       return dart.equals(typeof document, 'object');
     }
   });
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
@@ skipping 57 matching lines @@
   let _expectsEvent = Symbol('_expectsEvent');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _onPause = Symbol('_onPause');
   let _onResume = Symbol('_onResume');
   let _BroadcastSubscription$ = dart.generic(function(T) {
     class _BroadcastSubscription extends _ControllerSubscription$(T) {
       _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
-        this[_eventState] = dart.as(null, core.int);
+        this[_eventState] = null;
         this[_next] = null;
         this[_previous] = null;
         super._ControllerSubscription(dart.as(controller, _StreamControllerLifecycle$(T)), onData, onError, onDone, cancelOnError);
         this[_next] = this[_previous] = this;
       }
       get [_controller]() {
         return dart.as(super[_controller], _BroadcastStreamController);
       }
       [_expectsEvent](eventId) {
-        return (this[_eventState] & _STATE_EVENT_ID) === eventId;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_STATE_EVENT_ID)) === eventId;
       }
       [_toggleEventId]() {
         this[_eventState] = _STATE_EVENT_ID;
       }
       get [_isFiring]() {
-        return (this[_eventState] & _STATE_FIRING) !== 0;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_STATE_FIRING)) !== 0;
       }
       [_setRemoveAfterFiring]() {
         dart.assert(this[_isFiring]);
         this[_eventState] = _STATE_REMOVE_AFTER_FIRING;
       }
       get [_removeAfterFiring]() {
-        return (this[_eventState] & _STATE_REMOVE_AFTER_FIRING) !== 0;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_STATE_REMOVE_AFTER_FIRING)) !== 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription._STATE_EVENT_ID = 1;
     _BroadcastSubscription._STATE_FIRING = 2;
     _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$(dynamic);
@@ skipping 36 matching lines @@
         this[_doneFuture] = null;
         this[_next] = this[_previous] = this;
       }
       get stream() {
         return new _BroadcastStream(this);
       }
       get sink() {
         return new _StreamSinkWrapper(this);
       }
       get isClosed() {
-        return (this[_state] & _STATE_CLOSED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CLOSED)) !== 0;
       }
       get isPaused() {
         return false;
       }
       get hasListener() {
         return !dart.notNull(this[_isEmpty]);
       }
       get [_hasOneListener]() {
         dart.assert(!dart.notNull(this[_isEmpty]));
         return core.identical(this[_next][_next], this);
       }
       get [_isFiring]() {
-        return (this[_state] & _STATE_FIRING) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_FIRING)) !== 0;
       }
       get [_isAddingStream]() {
-        return (this[_state] & _STATE_ADDSTREAM) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_ADDSTREAM)) !== 0;
       }
       get [_mayAddEvent]() {
-        return this[_state] < _STATE_CLOSED;
+        return dart.notNull(this[_state]) < dart.notNull(_STATE_CLOSED);
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] !== null)
           return this[_doneFuture];
         return this[_doneFuture] = new _Future();
       }
       get [_isEmpty]() {
         return core.identical(this[_next], this);
       }
       [_addListener](subscription) {
         dart.assert(core.identical(subscription[_next], subscription));
         subscription[_previous] = this[_previous];
         subscription[_next] = this;
         this[_previous][_next] = subscription;
         this[_previous] = subscription;
-        subscription[_eventState] = this[_state] & _STATE_EVENT_ID;
+        subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_STATE_EVENT_ID);
       }
       [_removeListener](subscription) {
         dart.assert(core.identical(subscription[_controller], this));
         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;
       }
@@ skipping 12 matching lines @@
       }
       [_recordCancel](subscription) {
         if (core.identical(subscription[_next], subscription))
           return null;
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
         if (subscription[_isFiring]) {
           subscription._setRemoveAfterFiring();
         } else {
           dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
           this[_removeListener](subscription);
-          if (dart.notNull(!dart.notNull(this[_isFiring])) && dart.notNull(this[_isEmpty])) {
+          if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
         }
         return null;
       }
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_addEventError]() {
         if (this.isClosed) {
           return new core.StateError("Cannot add new events after calling close");
@@ skipping 45 matching lines @@
       [_add](data) {
         this[_sendData](data);
       }
       [_addError](error, stackTrace) {
         this[_sendError](error, stackTrace);
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = this[_addStreamState];
         this[_addStreamState] = null;
-        this[_state] = ~_STATE_ADDSTREAM;
+        this[_state] = ~dart.notNull(_STATE_ADDSTREAM);
         addState.complete();
       }
       [_forEachListener](action) {
         if (this[_isFiring]) {
           throw new core.StateError("Cannot fire new event. Controller is already firing an event");
         }
         if (this[_isEmpty])
           return;
-        let id = this[_state] & _STATE_EVENT_ID;
-        this[_state] = _STATE_EVENT_ID | _STATE_FIRING;
+        let id = dart.notNull(this[_state]) & dart.notNull(_STATE_EVENT_ID);
+        this[_state] = dart.notNull(_STATE_EVENT_ID) | dart.notNull(_STATE_FIRING);
         let link = this[_next];
         while (!dart.notNull(core.identical(link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           if (subscription._expectsEvent(id)) {
             subscription[_eventState] = _BroadcastSubscription[_STATE_FIRING];
             action(subscription);
             subscription._toggleEventId();
             link = subscription[_next];
             if (subscription[_removeAfterFiring]) {
               this[_removeListener](subscription);
             }
-            subscription[_eventState] = ~_BroadcastSubscription[_STATE_FIRING];
+            subscription[_eventState] = ~dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
           } else {
             link = subscription[_next];
           }
         }
-        this[_state] = ~_STATE_FIRING;
+        this[_state] = ~dart.notNull(_STATE_FIRING);
         if (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 12 matching lines @@
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         if (this[_isEmpty])
           return;
         if (this[_hasOneListener]) {
           this[_state] = _BroadcastStreamController[_STATE_FIRING];
           let subscription = dart.as(this[_next], _BroadcastSubscription);
           subscription._add(data);
-          this[_state] = ~_BroadcastStreamController[_STATE_FIRING];
+          this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](((subscription) => {
           subscription._add(data);
         }).bind(this));
       }
       [_sendError](error, stackTrace) {
@@ skipping 55 matching lines @@
   let _hasPending = Symbol('_hasPending');
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _STATE_CLOSED = Symbol('_STATE_CLOSED');
   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(!dart.notNull(this[_pending].isEmpty));
+        return dart.notNull(this[_pending] !== null) && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
         if (this[_pending] === null) {
           this[_pending] = new _StreamImplEvents();
         }
         this[_pending].add(event);
       }
       add(data) {
-        if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this[_isFiring])) {
+        if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new _DelayedData(data));
           return;
         }
         super.add(data);
         while (this[_hasPending]) {
           this[_pending].handleNext(this);
         }
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this[_isFiring])) {
+        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]) {
           this[_pending].handleNext(this);
         }
       }
       close() {
-        if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this[_isFiring])) {
+        if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new _DelayedDone());
           this[_state] = _BroadcastStreamController[_STATE_CLOSED];
           return super.done;
         }
         let result = super.close();
         dart.assert(!dart.notNull(this[_hasPending]));
         return result;
       }
       [_callOnCancel]() {
         if (this[_hasPending]) {
@@ skipping 14 matching lines @@
         this[_pauseCount] = 0;
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {}
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (resumeSignal !== null)
           resumeSignal.then(this[_resume]);
-        this[_pauseCount]++;
+        dart.notNull(this[_pauseCount])++;
       }
       resume() {
         this[_resume](null);
       }
       [_resume](_) {
-        if (this[_pauseCount] > 0)
-          this[_pauseCount]--;
+        if (dart.notNull(this[_pauseCount]) > 0)
+          dart.notNull(this[_pauseCount])--;
       }
       cancel() {
         return new _Future.immediate(null);
       }
       get isPaused() {
-        return this[_pauseCount] > 0;
+        return dart.notNull(this[_pauseCount]) > 0;
       }
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$(dynamic);
@@ skipping 91 matching lines @@
       static wait(futures, opt$) {
         let eagerError = opt$.eagerError === void 0 ? false : opt$.eagerError;
         let cleanUp = opt$.cleanUp === void 0 ? null : opt$.cleanUp;
         let result = new _Future();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         function handleError(theError, theStackTrace) {
-          remaining--;
+          dart.notNull(remaining)--;
           if (values !== null) {
             if (cleanUp !== null) {
               for (let value of values) {
                 if (value !== null) {
                   new Future.sync(() => {
                     cleanUp(value);
                   });
                 }
               }
             }
             values = null;
-            if (dart.notNull(remaining === 0) || dart.notNull(eagerError)) {
+            if (remaining === 0 || dart.notNull(eagerError)) {
               result._completeError(theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
-          } else if (dart.notNull(remaining === 0) && dart.notNull(!dart.notNull(eagerError))) {
+          } else if (remaining === 0 && !dart.notNull(eagerError)) {
             result._completeError(error, stackTrace);
           }
         }
         for (let future of futures) {
-          let pos = remaining++;
+          let pos = dart.notNull(remaining)++;
           future.then(dart.as(((value) => {
-            remaining--;
+            dart.notNull(remaining)--;
             if (values !== null) {
               values.set(pos, value);
               if (remaining === 0) {
                 result._completeWithValue(values);
               }
             } else {
               if (dart.notNull(cleanUp !== null) && dart.notNull(value !== null)) {
                 new Future.sync(() => {
                   cleanUp(value);
                 });
               }
-              if (dart.notNull(remaining === 0) && dart.notNull(!dart.notNull(eagerError))) {
+              if (remaining === 0 && !dart.notNull(eagerError)) {
                 result._completeError(error, stackTrace);
               }
             }
           }).bind(this), dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: handleError});
         }
         if (remaining === 0) {
           return dart.as(new Future.value(/* Unimplemented const */new List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
@@ skipping 164 matching lines @@
       this.result = result;
       this.callback = null;
       this.errorCallback = null;
       this.state = STATE_CHAIN;
       this[_nextListener] = null;
     }
     get [_zone]() {
       return this.result[_zone];
     }
     get handlesValue() {
-      return (this.state & MASK_VALUE) !== 0;
+      return (dart.notNull(this.state) & dart.notNull(MASK_VALUE)) !== 0;
     }
     get handlesError() {
-      return (this.state & MASK_ERROR) !== 0;
+      return (dart.notNull(this.state) & dart.notNull(MASK_ERROR)) !== 0;
     }
     get hasErrorTest() {
       return this.state === STATE_CATCHERROR_TEST;
     }
     get handlesComplete() {
       return this.state === STATE_WHENCOMPLETE;
     }
     get [_onValue]() {
       dart.assert(this.handlesValue);
       return dart.as(this.callback, _FutureOnValue);
@@ skipping 13 matching lines @@
   dart.defineNamedConstructor(_FutureListener, 'then');
   dart.defineNamedConstructor(_FutureListener, 'catchError');
   dart.defineNamedConstructor(_FutureListener, 'whenComplete');
   dart.defineNamedConstructor(_FutureListener, 'chain');
   _FutureListener.MASK_VALUE = 1;
   _FutureListener.MASK_ERROR = 2;
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
   _FutureListener.STATE_THEN = MASK_VALUE;
-  _FutureListener.STATE_THEN_ONERROR = MASK_VALUE | MASK_ERROR;
+  _FutureListener.STATE_THEN_ONERROR = dart.notNull(MASK_VALUE) | dart.notNull(MASK_ERROR);
   _FutureListener.STATE_CATCHERROR = MASK_ERROR;
-  _FutureListener.STATE_CATCHERROR_TEST = MASK_ERROR | MASK_TEST_ERROR;
+  _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(MASK_ERROR) | dart.notNull(MASK_TEST_ERROR);
   _FutureListener.STATE_WHENCOMPLETE = MASK_WHENCOMPLETE;
   let _resultOrListeners = Symbol('_resultOrListeners');
   let _asyncComplete = Symbol('_asyncComplete');
   let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _isChained = Symbol('_isChained');
   let _isComplete = Symbol('_isComplete');
   let _hasValue = Symbol('_hasValue');
   let _hasError = Symbol('_hasError');
   let _markPendingCompletion = Symbol('_markPendingCompletion');
   let _value = Symbol('_value');
@@ skipping 28 matching lines @@
         this[_resultOrListeners] = null;
         this[_asyncCompleteError](error, stackTrace);
       }
       get [_mayComplete]() {
         return this[_state] === _INCOMPLETE;
       }
       get [_isChained]() {
         return this[_state] === _CHAINED;
       }
       get [_isComplete]() {
-        return this[_state] >= _VALUE;
+        return dart.notNull(this[_state]) >= dart.notNull(_VALUE);
       }
       get [_hasValue]() {
         return this[_state] === _VALUE;
       }
       get [_hasError]() {
         return this[_state] === _ERROR;
       }
       set [_isChained](value) {
         if (value) {
           dart.assert(!dart.notNull(this[_isComplete]));
@@ skipping 190 matching lines @@
             let listener = listeners;
             listeners = listener[_nextListener];
             listener[_nextListener] = null;
             _propagateToListeners(source, listener);
           }
           let listener = listeners;
           let listenerHasValue = true;
           let sourceValue = hasError ? null : source[_value];
           let listenerValueOrError = sourceValue;
           let isPropagationAborted = false;
-          if (dart.notNull(hasError) || dart.notNull(dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete))) {
+          if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
-            if (dart.notNull(hasError) && dart.notNull(!dart.notNull(source[_zone].inSameErrorZone(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);
             }
             // Function handleValueCallback: () → bool
             function handleValueCallback() {
@@ skipping 86 matching lines @@
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
             if (oldZone !== null)
               Zone._leave(oldZone);
             if (isPropagationAborted)
               return;
-            if (dart.notNull(dart.notNull(listenerHasValue) && dart.notNull(!dart.notNull(core.identical(sourceValue, listenerValueOrError)))) && dart.notNull(dart.is(listenerValueOrError, Future))) {
+            if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.notNull(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 {
                   _chainCoreFuture(chainSource, result);
@@ skipping 218 matching lines @@
           }).bind(this)});
         return controller.stream;
       }
       Stream$fromIterable(data) {
         return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
       }
       Stream$periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation === null)
-          computation = dart.as((i) => null, dart.throw_("Unimplemented type (int) → T"));
+          computation = (i) => null;
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
-          let data = computation(computationCount++);
+          let data = computation(dart.notNull(computationCount)++);
           controller.add(data);
         }
         // Function startPeriodicTimer: () → void
         function startPeriodicTimer() {
           dart.assert(timer === null);
           timer = new Timer.periodic(period, (timer) => {
             sendEvent();
           });
         }
         controller = new StreamController({sync: true, onListen: (() => {
@@ skipping 249 matching lines @@
           }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new _Future();
         let count = 0;
         this.listen((_) => {
-          count++;
+          dart.notNull(count)++;
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(count);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((_) => {
           _cancelAndValue(subscription, future, false);
@@ skipping 59 matching lines @@
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get last() {
         let future = new _Future();
-        let result = dart.as(null, T);
+        let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           foundResult = true;
           result = value;
         }, {onError: future[_completeError], onDone: (() => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new _Future();
-        let result = dart.as(null, T);
+        let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           if (foundResult) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
@@ skipping 38 matching lines @@
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       lastWhere(test, opt$) {
         let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
         let future = new _Future();
-        let result = dart.as(null, T);
+        let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true === test(value), dart.as((isMatch) => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
           }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
@@ skipping 10 matching lines @@
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         let future = new _Future();
-        let result = dart.as(null, T);
+        let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true === test(value), dart.as((isMatch) => {
             if (isMatch) {
               if (foundResult) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
                   let s = dart.stackTrace(e);
@@ skipping 15 matching lines @@
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       elementAt(index) {
-        if (dart.notNull(!(typeof index == number)) || dart.notNull(index < 0))
+        if (dart.notNull(!(typeof index == number)) || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new _Future();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen((value) => {
           if (index === elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = 1;
@@ skipping 163 matching lines @@
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dynamic);
   let StreamController$ = dart.generic(function(T) {
     class StreamController extends dart.Object {
       StreamController(opt$) {
         let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
         let onPause = opt$.onPause === void 0 ? null : opt$.onPause;
         let onResume = opt$.onResume === void 0 ? null : opt$.onResume;
         let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
         let sync = opt$.sync === void 0 ? false : opt$.sync;
-        if (dart.notNull(dart.notNull(dart.notNull(onListen === null) && dart.notNull(onPause === null)) && dart.notNull(onResume === null)) && dart.notNull(onCancel === null)) {
+        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));
         }
         return sync ? new _SyncStreamController(onListen, onPause, onResume, onCancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
       }
       StreamController$broadcast(opt$) {
         let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
         let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
         let sync = opt$.sync === void 0 ? false : opt$.sync;
         return sync ? new _SyncBroadcastStreamController(onListen, onCancel) : new _AsyncBroadcastStreamController(onListen, onCancel);
       }
@@ skipping 30 matching lines @@
         this[_state] = _STATE_INITIAL;
         this[_doneFuture] = null;
       }
       get stream() {
         return dart.as(new _ControllerStream(this), Stream$(T));
       }
       get sink() {
         return new _StreamSinkWrapper(this);
       }
       get [_isCanceled]() {
-        return (this[_state] & _STATE_CANCELED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CANCELED)) !== 0;
       }
       get hasListener() {
-        return (this[_state] & _STATE_SUBSCRIBED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_SUBSCRIBED)) !== 0;
       }
       get [_isInitialState]() {
-        return (this[_state] & _STATE_SUBSCRIPTION_MASK) === _STATE_INITIAL;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_SUBSCRIPTION_MASK)) === _STATE_INITIAL;
       }
       get isClosed() {
-        return (this[_state] & _STATE_CLOSED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CLOSED)) !== 0;
       }
       get isPaused() {
         return this.hasListener ? this[_subscription][_isInputPaused] : !dart.notNull(this[_isCanceled]);
       }
       get [_isAddingStream]() {
-        return (this[_state] & _STATE_ADDSTREAM) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_ADDSTREAM)) !== 0;
       }
       get [_mayAddEvent]() {
-        return this[_state] < _STATE_CLOSED;
+        return dart.notNull(this[_state]) < dart.notNull(_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]() {
@@ skipping 89 matching lines @@
         if (this.hasListener) {
           this[_sendError](error, stackTrace);
         } else if (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] = ~_STATE_ADDSTREAM;
+        this[_state] = ~dart.notNull(_STATE_ADDSTREAM);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         if (!dart.notNull(this[_isInitialState])) {
           throw new core.StateError("Stream has already been listened to.");
         }
         let subscription = new _ControllerSubscription(this, dart.as(onData, dart.throw_("Unimplemented type (dynamic) → void")), onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = _STATE_SUBSCRIBED;
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
         }
         subscription._setPendingEvents(pendingEvents);
         subscription._guardCallback((() => {
           _runGuarded(this[_onListen]);
         }).bind(this));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         let result = null;
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
-        this[_state] = this[_state] & ~(_STATE_SUBSCRIBED | _STATE_ADDSTREAM) | _STATE_CANCELED;
+        this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_STATE_SUBSCRIBED) | dart.notNull(_STATE_ADDSTREAM)) | dart.notNull(_STATE_CANCELED);
         if (this[_onCancel] !== null) {
           if (result === null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = ((_) => {
                 _._asyncCompleteError(e, s);
                 return _;
               }).bind(this)(new _Future());
@@ skipping 133 matching lines @@
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream($_controller) {
         this[_controller] = $_controller;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
-        return this[_controller].hashCode ^ 892482866;
+        return dart.notNull(this[_controller].hashCode) ^ 892482866;
       }
       ['=='](other) {
         if (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]);
       }
     }
@@ skipping 170 matching lines @@
           handleDone = _nullDoneHandler;
         this[_onDone] = this[_zone].registerCallback(handleDone);
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (this[_isCanceled])
           return;
         let wasPaused = this[_isPaused];
         let wasInputPaused = this[_isInputPaused];
-        this[_state] = this[_state] + _STATE_PAUSE_COUNT | _STATE_INPUT_PAUSED;
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_STATE_PAUSE_COUNT) | dart.notNull(_STATE_INPUT_PAUSED);
         if (resumeSignal !== null)
           resumeSignal.whenComplete(this.resume);
-        if (dart.notNull(!dart.notNull(wasPaused)) && dart.notNull(this[_pending] !== null))
+        if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] !== null))
           this[_pending].cancelSchedule();
-        if (dart.notNull(!dart.notNull(wasInputPaused)) && dart.notNull(!dart.notNull(this[_inCallback])))
+        if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
           this[_guardCallback](this[_onPause]);
       }
       resume() {
         if (this[_isCanceled])
           return;
         if (this[_isPaused]) {
           this[_decrementPauseCount]();
           if (!dart.notNull(this[_isPaused])) {
-            if (dart.notNull(this[_hasPending]) && dart.notNull(!dart.notNull(this[_pending].isEmpty))) {
+            if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
               this[_pending].schedule(this);
             } else {
               dart.assert(this[_mayResumeInput]);
-              this[_state] = ~_STATE_INPUT_PAUSED;
+              this[_state] = ~dart.notNull(_STATE_INPUT_PAUSED);
               if (!dart.notNull(this[_inCallback]))
                 this[_guardCallback](this[_onResume]);
             }
           }
         }
       }
       cancel() {
-        this[_state] = ~_STATE_WAIT_FOR_CANCEL;
+        this[_state] = ~dart.notNull(_STATE_WAIT_FOR_CANCEL);
         if (this[_isCanceled])
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = (() => {
           result._complete(futureValue);
         }).bind(this);
         this[_onError] = ((error, stackTrace) => {
           this.cancel();
           result._completeError(error, dart.as(stackTrace, core.StackTrace));
         }).bind(this);
         return result;
       }
       get [_isInputPaused]() {
-        return (this[_state] & _STATE_INPUT_PAUSED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_INPUT_PAUSED)) !== 0;
       }
       get [_isClosed]() {
-        return (this[_state] & _STATE_CLOSED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CLOSED)) !== 0;
       }
       get [_isCanceled]() {
-        return (this[_state] & _STATE_CANCELED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CANCELED)) !== 0;
       }
       get [_waitsForCancel]() {
-        return (this[_state] & _STATE_WAIT_FOR_CANCEL) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_WAIT_FOR_CANCEL)) !== 0;
       }
       get [_inCallback]() {
-        return (this[_state] & _STATE_IN_CALLBACK) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_IN_CALLBACK)) !== 0;
       }
       get [_hasPending]() {
-        return (this[_state] & _STATE_HAS_PENDING) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_HAS_PENDING)) !== 0;
       }
       get [_isPaused]() {
-        return this[_state] >= _STATE_PAUSE_COUNT;
+        return dart.notNull(this[_state]) >= dart.notNull(_STATE_PAUSE_COUNT);
       }
       get [_canFire]() {
-        return this[_state] < _STATE_IN_CALLBACK;
+        return dart.notNull(this[_state]) < dart.notNull(_STATE_IN_CALLBACK);
       }
       get [_mayResumeInput]() {
-        return dart.notNull(!dart.notNull(this[_isPaused])) && dart.notNull(dart.notNull(this[_pending] === null) || dart.notNull(this[_pending].isEmpty));
+        return !dart.notNull(this[_isPaused]) && (dart.notNull(this[_pending] === null) || dart.notNull(this[_pending].isEmpty));
       }
       get [_cancelOnError]() {
-        return (this[_state] & _STATE_CANCEL_ON_ERROR) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_STATE_CANCEL_ON_ERROR)) !== 0;
       }
       get isPaused() {
         return this[_isPaused];
       }
       [_cancel]() {
         this[_state] = _STATE_CANCELED;
         if (this[_hasPending]) {
           this[_pending].cancelSchedule();
         }
         if (!dart.notNull(this[_inCallback]))
           this[_pending] = null;
         this[_cancelFuture] = this[_onCancel]();
       }
       [_incrementPauseCount]() {
-        this[_state] = this[_state] + _STATE_PAUSE_COUNT | _STATE_INPUT_PAUSED;
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_STATE_PAUSE_COUNT) | dart.notNull(_STATE_INPUT_PAUSED);
       }
       [_decrementPauseCount]() {
         dart.assert(this[_isPaused]);
         this[_state] = _STATE_PAUSE_COUNT;
       }
       [_add](data) {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
@@ skipping 44 matching lines @@
           }
         }
       }
       [_sendData](data) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         this[_state] = _STATE_IN_CALLBACK;
         this[_zone].runUnaryGuarded(dart.as(this[_onData], dart.throw_("Unimplemented type (dynamic) → dynamic")), data);
-        this[_state] = ~_STATE_IN_CALLBACK;
+        this[_state] = ~dart.notNull(_STATE_IN_CALLBACK);
         this[_checkState](wasInputPaused);
       }
       [_sendError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         // Function sendError: () → void
         function sendError() {
-          if (dart.notNull(this[_isCanceled]) && dart.notNull(!dart.notNull(this[_waitsForCancel])))
+          if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = _STATE_IN_CALLBACK;
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
           }
-          this[_state] = ~_STATE_IN_CALLBACK;
+          this[_state] = ~dart.notNull(_STATE_IN_CALLBACK);
         }
         if (this[_cancelOnError]) {
           this[_state] = _STATE_WAIT_FOR_CANCEL;
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
           }
         } else {
           sendError();
           this[_checkState](wasInputPaused);
         }
       }
       [_sendDone]() {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         // Function sendDone: () → void
         function sendDone() {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
-          this[_state] = _STATE_CANCELED | _STATE_CLOSED | _STATE_IN_CALLBACK;
+          this[_state] = dart.notNull(_STATE_CANCELED) | dart.notNull(_STATE_CLOSED) | dart.notNull(_STATE_IN_CALLBACK);
           this[_zone].runGuarded(this[_onDone]);
-          this[_state] = ~_STATE_IN_CALLBACK;
+          this[_state] = ~dart.notNull(_STATE_IN_CALLBACK);
         }
         this[_cancel]();
         this[_state] = _STATE_WAIT_FOR_CANCEL;
         if (dart.is(this[_cancelFuture], Future)) {
           this[_cancelFuture].whenComplete(sendDone);
         } else {
           sendDone();
         }
       }
       [_guardCallback](callback) {
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         this[_state] = _STATE_IN_CALLBACK;
         dart.dinvokef(callback);
-        this[_state] = ~_STATE_IN_CALLBACK;
+        this[_state] = ~dart.notNull(_STATE_IN_CALLBACK);
         this[_checkState](wasInputPaused);
       }
       [_checkState](wasInputPaused) {
         dart.assert(!dart.notNull(this[_inCallback]));
         if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
-          this[_state] = ~_STATE_HAS_PENDING;
+          this[_state] = ~dart.notNull(_STATE_HAS_PENDING);
           if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
-            this[_state] = ~_STATE_INPUT_PAUSED;
+            this[_state] = ~dart.notNull(_STATE_INPUT_PAUSED);
           }
         }
         while (true) {
           if (this[_isCanceled]) {
             this[_pending] = null;
             return;
           }
           let isInputPaused = this[_isInputPaused];
           if (wasInputPaused === isInputPaused)
             break;
           this[_state] = _STATE_IN_CALLBACK;
           if (isInputPaused) {
             this[_onPause]();
           } else {
             this[_onResume]();
           }
-          this[_state] = ~_STATE_IN_CALLBACK;
+          this[_state] = ~dart.notNull(_STATE_IN_CALLBACK);
           wasInputPaused = isInputPaused;
         }
-        if (dart.notNull(this[_hasPending]) && dart.notNull(!dart.notNull(this[_isPaused]))) {
+        if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
     _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
     _BufferingStreamSubscription._STATE_CLOSED = 2;
     _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
     _BufferingStreamSubscription._STATE_CANCELED = 8;
     _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
     _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
@@ skipping 138 matching lines @@
   }
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends dart.Object {
     _PendingEvents() {
       this[_state] = _STATE_UNSCHEDULED;
     }
     get isScheduled() {
       return this[_state] === _STATE_SCHEDULED;
     }
     get [_eventScheduled]() {
-      return this[_state] >= _STATE_SCHEDULED;
+      return dart.notNull(this[_state]) >= dart.notNull(_STATE_SCHEDULED);
     }
     schedule(dispatch) {
       if (this.isScheduled)
         return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (this[_eventScheduled]) {
         dart.assert(this[_state] === _STATE_CANCELED);
         this[_state] = _STATE_SCHEDULED;
         return;
       }
@@ skipping 70 matching lines @@
   let _isScheduled = Symbol('_isScheduled');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends dart.Object {
       _DoneStreamSubscription($_onDone) {
         this[_onDone] = $_onDone;
         this[_zone] = Zone.current;
         this[_state] = 0;
         this[_schedule]();
       }
       get [_isSent]() {
-        return (this[_state] & _DONE_SENT) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_DONE_SENT)) !== 0;
       }
       get [_isScheduled]() {
-        return (this[_state] & _SCHEDULED) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_SCHEDULED)) !== 0;
       }
       get isPaused() {
-        return this[_state] >= _PAUSED;
+        return dart.notNull(this[_state]) >= dart.notNull(_PAUSED);
       }
       [_schedule]() {
         if (this[_isScheduled])
           return;
         this[_zone].scheduleMicrotask(this[_sendDone]);
         this[_state] = _SCHEDULED;
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         this[_state] = _PAUSED;
         if (resumeSignal !== null)
           resumeSignal.whenComplete(this.resume);
       }
       resume() {
         if (this.isPaused) {
           this[_state] = _PAUSED;
-          if (dart.notNull(!dart.notNull(this.isPaused)) && dart.notNull(!dart.notNull(this[_isSent]))) {
+          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] = (() => {
           result._completeWithValue(null);
         }).bind(this);
         return result;
       }
       [_sendDone]() {
-        this[_state] = ~_SCHEDULED;
+        this[_state] = ~dart.notNull(_SCHEDULED);
         if (this.isPaused)
           return;
         this[_state] = _DONE_SENT;
         if (this[_onDone] !== null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription._DONE_SENT = 1;
     _DoneStreamSubscription._SCHEDULED = 2;
     _DoneStreamSubscription._PAUSED = 4;
@@ skipping 117 matching lines @@
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dynamic);
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends dart.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
-        this[_current] = dart.as(null, T);
+        this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _STATE_FOUND;
         this[_subscription] = stream.listen(this[_onData], {onError: this[_onError], onDone: this[_onDone], cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] === _STATE_DONE) {
           return new _Future.immediate(false);
         }
         if (this[_state] === _STATE_MOVING) {
           throw new core.StateError("Already waiting for next.");
         }
         if (this[_state] === _STATE_FOUND) {
           this[_state] = _STATE_MOVING;
-          this[_current] = dart.as(null, T);
+          this[_current] = null;
           this[_futureOrPrefetch] = new _Future();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
-          dart.assert(this[_state] >= _STATE_EXTRA_DATA);
+          dart.assert(dart.notNull(this[_state]) >= dart.notNull(_STATE_EXTRA_DATA));
           switch (this[_state]) {
             case _STATE_EXTRA_DATA:
               this[_state] = _STATE_FOUND;
               this[_current] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
               return new _Future.immediate(true);
             case _STATE_EXTRA_ERROR:
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
               return new _Future.immediateError(prefetch.error, prefetch.stackTrace);
             case _STATE_EXTRA_DONE:
               this[_clear]();
               return new _Future.immediate(false);
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
-        this[_current] = dart.as(null, T);
+        this[_current] = null;
         this[_state] = _STATE_DONE;
       }
       cancel() {
         let subscription = this[_subscription];
         if (this[_state] === _STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._complete(false);
         } else {
           this[_clear]();
@@ skipping 304 matching lines @@
   let _remaining = Symbol('_remaining');
   let _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == number))
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
-        if (this[_remaining] > 0) {
+        if (dart.notNull(this[_remaining]) > 0) {
           sink._add(inputEvent);
           this[_remaining] = 1;
           if (this[_remaining] === 0) {
             sink._close();
           }
         }
       }
     }
     return _TakeStream;
   });
@@ skipping 23 matching lines @@
       }
     }
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$(dynamic);
   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 (dart.notNull(!(typeof count == number)) || dart.notNull(count) < 0)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
-        if (this[_remaining] > 0) {
-          this[_remaining]--;
+        if (dart.notNull(this[_remaining]) > 0) {
+          dart.notNull(this[_remaining])--;
           return;
         }
         sink._add(inputEvent);
       }
     }
     return _SkipStream;
   });
   let _SkipStream = _SkipStream$(dynamic);
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
@@ skipping 317 matching lines @@
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createPeriodicTimer(duration, callback);
       }
       return Zone.current.createPeriodicTimer(duration, Zone.current.bindUnaryCallback(dart.as(callback, dart.throw_("Unimplemented type (dynamic) → dynamic")), {runGuarded: true}));
     }
     static run(callback) {
       new Timer(core.Duration.ZERO, callback);
     }
     static [_createTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
-      if (milliseconds < 0)
+      if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
     static [_createPeriodicTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
-      if (milliseconds < 0)
+      if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
     }
   }
   dart.defineNamedConstructor(Timer, 'periodic');
   class AsyncError extends dart.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
@@ skipping 763 matching lines @@
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.AsyncError = AsyncError;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));