implement opassign, fix bugs in pre/postfix, introduce a let* helper

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 25 matching lines @@
       if (stackTrace != null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
-        result = `\nStack Trace:\n${this.stackTrace}`;
+        result = core.String['+'](result, `\nStack Trace:\n${this.stackTrace}`);
       }
       return result;
     }
   }
   let _controller = Symbol('_controller');
   let _createSubscription = Symbol('_createSubscription');
   let _subscribe = Symbol('_subscribe');
   let _onListen = Symbol('_onListen');
   let _add = Symbol('_add');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       fromFuture(future) {
         let controller = new (StreamController$(T))({sync: true});
-        future.then(dart.as((value) => {
+        future.then(dart.as(value => {
           controller[_add](dart.as(value, T));
           controller[_closeUnchecked]();
         }, dart.throw_("Unimplemented type (T) → dynamic")), {
           onError: (error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
             controller[_closeUnchecked]();
           }
         });
         return controller.stream;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
-          computation = dart.as((i) => null, dart.throw_("Unimplemented type (int) → T"));
+          computation = dart.as(i => null, dart.throw_("Unimplemented type (int) → T"));
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
-          let data = computation(((x) => computationCount = dart.notNull(x) + 1, x)(computationCount));
+          let data = computation((() => {
+            let x = computationCount;
+            computationCount = dart.notNull(x) + 1;
+            return x;
+          })());
           controller.add(data);
         }
         // Function startPeriodicTimer: () → void
         function startPeriodicTimer() {
           dart.assert(timer == null);
-          timer = new Timer.periodic(period, (timer) => {
+          timer = new Timer.periodic(period, timer => {
             sendEvent();
           });
         }
         controller = new (StreamController$(T))({
           sync: true,
           onListen: () => {
             watch.start();
             startPeriodicTimer();
           },
           onPause: () => {
@@ skipping 38 matching lines @@
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           let add = controller.add;
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
           let addError = eventSink[_addError];
-          subscription = this.listen((event) => {
+          subscription = this.listen(event => {
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
@@ skipping 29 matching lines @@
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
-          subscription = this.listen((event) => {
+          subscription = this.listen(event => {
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (newStream != null) {
@@ skipping 28 matching lines @@
         return controller.stream;
       }
       handleError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
         return new (_ExpandStream$(T, dynamic))(this, convert);
       }
       pipe(streamConsumer) {
-        return streamConsumer.addStream(this).then((_) => streamConsumer.close());
+        return streamConsumer.addStream(this).then(_ => streamConsumer.close());
       }
       transform(streamTransformer) {
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
-        subscription = this.listen((element) => {
+        subscription = this.listen(element => {
           if (seenFirst) {
-            _runUserCode(() => combine(value, element), (newValue) => {
+            _runUserCode(() => combine(value, element), newValue => {
               value = newValue;
             }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
           } else {
             value = element;
             seenFirst = true;
           }
         }, {
           onError: result[_completeError],
           onDone: () => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result[_complete](value);
             }
           },
           cancelOnError: true
         });
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => dart.dinvokef(combine, value, element), (newValue) => {
+        subscription = this.listen(element => {
+          _runUserCode(() => dart.dinvokef(combine, value, element), newValue => {
             value = newValue;
           }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: (e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           },
           onDone: () => {
             result[_complete](value);
           },
           cancelOnError: true
         });
         return result;
       }
       join(separator) {
         if (separator === void 0)
           separator = "";
         let result = new (_Future$(core.String))();
         let buffer = new core.StringBuffer();
         let subscription = null;
         let first = true;
-        subscription = this.listen((element) => {
+        subscription = this.listen(element => {
           if (!dart.notNull(first)) {
             buffer.write(separator);
           }
           first = false;
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
         }, {
-          onError: (e) => {
+          onError: e => {
             result[_completeError](e);
           },
           onDone: () => {
             result[_complete](buffer.toString());
           },
           cancelOnError: true
         });
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => dart.equals(element, needle), (isMatch) => {
+        subscription = this.listen(element => {
+          _runUserCode(() => dart.equals(element, needle), isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => action(element), (_) => {
+        subscription = this.listen(element => {
+          _runUserCode(() => action(element), _ => {
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](null);
           },
           cancelOnError: true
         });
         return future;
       }
       every(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => test(element), (isMatch) => {
+        subscription = this.listen(element => {
+          _runUserCode(() => test(element), isMatch => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       any(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => test(element), (isMatch) => {
+        subscription = this.listen(element => {
+          _runUserCode(() => test(element), isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
-        this.listen(dart.as((_) => {
+        this.listen(dart.as(_ => {
           count = dart.notNull(count) + 1;
         }, dart.throw_("Unimplemented type (T) → void")), {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](count);
           },
           cancelOnError: true
         });
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.as((_) => {
+        subscription = this.listen(dart.as(_ => {
           _cancelAndValue(subscription, future, false);
         }, dart.throw_("Unimplemented type (T) → void")), {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
         let future = new (_Future$(core.List$(T)))();
-        this.listen((data) => {
+        this.listen(data => {
           result[core.$add](data);
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](result);
           },
           cancelOnError: true
         });
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
-        this.listen((data) => {
+        this.listen(data => {
           result.add(data);
         }, {
           onError: future[_completeError],
           onDone: () => {
             future[_complete](result);
           },
           cancelOnError: true
         });
         return future;
       }
@@ skipping 15 matching lines @@
         return dart.as(new _SkipWhileStream(this, test), Stream$(T));
       }
       distinct(equals) {
         if (equals === void 0)
           equals = null;
         return dart.as(new _DistinctStream(this, equals), Stream$(T));
       }
       get first() {
         let future = new (_Future$(T))();
         let subscription = null;
-        subscription = this.listen((value) => {
+        subscription = this.listen(value => {
           _cancelAndValue(subscription, future, value);
         }, {
           onError: future[_completeError],
           onDone: () => {
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen((value) => {
+        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);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen((value) => {
+        subscription = this.listen(value => {
           if (foundResult) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
@@ skipping 15 matching lines @@
 
           },
           cancelOnError: true
         });
         return future;
       }
       firstWhere(test, opts) {
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => test(value), (isMatch) => {
+        subscription = this.listen(value => {
+          _runUserCode(() => test(value), isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], 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) {
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => true == test(value), (isMatch) => {
+        subscription = this.listen(value => {
+          _runUserCode(() => true == test(value), isMatch => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {
           onError: future[_completeError],
           onDone: () => {
             if (foundResult) {
               future[_complete](result);
@@ skipping 13 matching lines @@
           },
           cancelOnError: true
         });
         return future;
       }
       singleWhere(test) {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => true == test(value), (isMatch) => {
+        subscription = this.listen(value => {
+          _runUserCode(() => true == test(value), isMatch => {
             if (isMatch) {
               if (foundResult) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
@@ skipping 20 matching lines @@
           cancelOnError: true
         });
         return future;
       }
       elementAt(index) {
         if (dart.notNull(!(typeof index == 'number')) || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
-        subscription = this.listen((value) => {
+        subscription = this.listen(value => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
-          elementIndex = 1;
+          elementIndex = dart.notNull(elementIndex) + 1;
         }, {
           onError: future[_completeError],
           onDone: (() => {
             future[_completeError](new core.RangeError.index(index, this, "index", null, elementIndex));
           }).bind(this),
           cancelOnError: true
         });
         return future;
       }
       timeout(timeLimit, opts) {
@@ skipping 193 matching lines @@
         this.onData(onData);
         this.onError(onError);
         this.onDone(onDone);
       }
       [_setPendingEvents](pendingEvents) {
         dart.assert(this[_pending] == null);
         if (pendingEvents == null)
           return;
         this[_pending] = pendingEvents;
         if (!dart.notNull(pendingEvents.isEmpty)) {
-          this[_state] = _BufferingStreamSubscription[_STATE_HAS_PENDING];
+          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING]);
           this[_pending].schedule(this);
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
@@ skipping 29 matching lines @@
       resume() {
         if (this[_isCanceled])
           return;
         if (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(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
+              this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
               if (!dart.notNull(this[_inCallback]))
                 this[_guardCallback](this[_onResume]);
             }
           }
         }
       }
       cancel() {
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_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$(T))();
         this[_onDone] = () => {
@@ skipping 32 matching lines @@
       get [_mayResumeInput]() {
         return !dart.notNull(this[_isPaused]) && (dart.notNull(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] = _BufferingStreamSubscription[_STATE_CANCELED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_CANCELED]);
         if (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] = _BufferingStreamSubscription[_STATE_PAUSE_COUNT];
+        this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription[_STATE_PAUSE_COUNT]);
       }
       [_add](data) {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
           this[_sendData](data);
         } else {
           this[_addPending](new _DelayedData(data));
         }
       }
       [_addError](error, stackTrace) {
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
           this[_sendError](error, stackTrace);
         } else {
           this[_addPending](new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
-        this[_state] = _BufferingStreamSubscription[_STATE_CLOSED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED]);
         if (this[_canFire]) {
           this[_sendDone]();
         } else {
           this[_addPending](new _DelayedDone());
         }
       }
       [_onPause]() {
         dart.assert(this[_isInputPaused]);
       }
       [_onResume]() {
         dart.assert(!dart.notNull(this[_isInputPaused]));
       }
       [_onCancel]() {
         dart.assert(this[_isCanceled]);
         return null;
       }
       [_addPending](event) {
         let pending = dart.as(this[_pending], _StreamImplEvents);
         if (this[_pending] == null)
           pending = this[_pending] = new _StreamImplEvents();
         pending.add(event);
         if (!dart.notNull(this[_hasPending])) {
-          this[_state] = _BufferingStreamSubscription[_STATE_HAS_PENDING];
+          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING]);
           if (!dart.notNull(this[_isPaused])) {
             this[_pending].schedule(this);
           }
         }
       }
       [_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] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         this[_zone].runUnaryGuarded(this[_onData], data);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_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(this[_waitsForCancel]))
             return;
-          this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
+          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], 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] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         }
         if (this[_cancelOnError]) {
-          this[_state] = _BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL];
+          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);
         }
       }
       [_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] = dart.notNull(_BufferingStreamSubscription[_STATE_CANCELED]) | dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED]) | dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_CANCELED]) | dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED]) | dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
           this[_zone].runGuarded(this[_onDone]);
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         }
         this[_cancel]();
-        this[_state] = _BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_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] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         dart.dinvokef(callback);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_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] = ~dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING]);
+          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(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
+            this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
           }
         }
         while (true) {
           if (this[_isCanceled]) {
             this[_pending] = null;
             return;
           }
           let isInputPaused = this[_isInputPaused];
           if (wasInputPaused == isInputPaused)
             break;
-          this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
+          this[_state] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
           if (isInputPaused) {
             this[_onPause]();
           } else {
             this[_onResume]();
           }
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
+          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);
         }
       }
     }
     _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
     _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
     _BufferingStreamSubscription._STATE_CLOSED = 2;
@@ skipping 35 matching lines @@
         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 (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_EVENT_ID])) == eventId;
       }
       [_toggleEventId]() {
-        this[_eventState] = _BroadcastSubscription[_STATE_EVENT_ID];
+        this[_eventState] = dart.notNull(this[_eventState]) ^ dart.notNull(_BroadcastSubscription[_STATE_EVENT_ID]);
       }
       get [_isFiring]() {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_FIRING])) != 0;
       }
       [_setRemoveAfterFiring]() {
         dart.assert(this[_isFiring]);
-        this[_eventState] = _BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING];
+        this[_eventState] = dart.notNull(this[_eventState]) | dart.notNull(_BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING]);
       }
       get [_removeAfterFiring]() {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING])) != 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink];
     _BroadcastSubscription._STATE_EVENT_ID = 1;
     _BroadcastSubscription._STATE_FIRING = 2;
@@ skipping 137 matching lines @@
         }
         this[_sendError](error, stackTrace);
       }
       close() {
         if (this.isClosed) {
           dart.assert(this[_doneFuture] != null);
           return this[_doneFuture];
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
-        this[_state] = _BroadcastStreamController[_STATE_CLOSED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController[_STATE_CLOSED]);
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       addStream(stream, opts) {
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
-        this[_state] = _BroadcastStreamController[_STATE_ADDSTREAM];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController[_STATE_ADDSTREAM]);
         this[_addStreamState] = dart.as(new _AddStreamState(this, stream, cancelOnError), _AddStreamState$(T));
         return this[_addStreamState].addStreamFuture;
       }
       [_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] = ~dart.notNull(_BroadcastStreamController[_STATE_ADDSTREAM]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController[_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 = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_EVENT_ID]);
-        this[_state] = dart.notNull(_BroadcastStreamController[_STATE_EVENT_ID]) | dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
+        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)) {
-            subscription[_eventState] = _BroadcastSubscription[_STATE_FIRING];
+            subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
             action(subscription);
             subscription[_toggleEventId]();
             link = subscription[_next];
             if (subscription[_removeAfterFiring]) {
               this[_removeListener](subscription);
             }
-            subscription[_eventState] = ~dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
+            subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
           } else {
             link = subscription[_next];
           }
         }
-        this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController[_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 10 matching lines @@
   let _BroadcastStreamController = _BroadcastStreamController$();
   let _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         if (this[_isEmpty])
           return;
         if (this[_hasOneListener]) {
-          this[_state] = _BroadcastStreamController[_STATE_FIRING];
+          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(_BroadcastStreamController[_STATE_FIRING]);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
-        this[_forEachListener]((subscription) => {
+        this[_forEachListener](subscription => {
           subscription[_add](data);
         });
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
-        this[_forEachListener]((subscription) => {
+        this[_forEachListener](subscription => {
           subscription[_addError](error, stackTrace);
         });
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.as((subscription) => {
+          this[_forEachListener](dart.as(subscription => {
             subscription[_close]();
           }, dart.throw_("Unimplemented type (_BufferingStreamSubscription<T>) → void")));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     return _SyncBroadcastStreamController;
@@ skipping 68 matching lines @@
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_sendError](error, stackTrace);
         while (this[_hasPending]) {
           this[_pending].handleNext(this);
         }
       }
       close() {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new _DelayedDone());
-          this[_state] = _BroadcastStreamController[_STATE_CLOSED];
+          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]) {
           this[_pending].clear();
           this[_pending] = null;
@@ skipping 19 matching lines @@
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (resumeSignal != null)
           resumeSignal.then(this[_resume]);
         this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
       }
       resume() {
         this[_resume](null);
       }
       [_resume](_) {
-        if (dart.notNull(this[_pauseCount]) > 0)
+        if (dart.notNull(this[_pauseCount]) > 0) {
           this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
+        }
       }
       cancel() {
         return new _Future.immediate(null);
       }
       get isPaused() {
         return dart.notNull(this[_pauseCount]) > 0;
       }
       asFuture(value) {
         if (value === void 0)
           value = null;
@@ skipping 122 matching lines @@
               result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result[_completeError](error, stackTrace);
           }
         }
         for (let future of futures) {
-          let pos = ((x) => remaining = dart.notNull(x) + 1, x)(remaining);
-          future.then((value) => {
+          let pos = remaining;
+          remaining = dart.notNull(pos) + 1;
+          future.then(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[core.$set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
               if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
                 new Future.sync(() => {
                   dart.dinvokef(cleanUp, value);
                 });
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, {onError: handleError});
         }
         if (remaining == 0) {
           return dart.as(new Future.value(/* Unimplemented const */new core.List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input[core.$iterator];
         return Future.doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new Future.sync(() => dart.dinvokef(f, iterator.current)).then((_) => true);
+          return new Future.sync(() => dart.dinvokef(f, iterator.current)).then(_ => true);
         });
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
-        nextIteration = Zone.current.bindUnaryCallback((keepGoing) => {
+        nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
           if (keepGoing) {
             new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: doneSignal[_completeError]});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
         dart.dinvokef(nextIteration, true);
         return doneSignal;
       }
     }
@@ skipping 345 matching lines @@
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
       static [_chainForeignFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(!dart.is(source, _Future));
         target[_isChained] = true;
-        source.then((value) => {
+        source.then(value => {
           dart.assert(target[_isChained]);
           target[_completeWithValue](value);
         }, {
           onError: (error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target[_completeError](error, dart.as(stackTrace, core.StackTrace));
           }
         });
@@ skipping 167 matching lines @@
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
-                dart.dinvoke(completeResult, 'then', (ignored) => {
+                dart.dinvoke(completeResult, 'then', ignored => {
                   _Future[_propagateToListeners](source, new _FutureListener.chain(result));
                 }, {
                   onError: (error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future)) {
                       completeResult = new _Future();
                       dart.dinvoke(completeResult, '_setError', error, stackTrace);
                     }
                     _Future[_propagateToListeners](dart.as(completeResult, _Future), new _FutureListener.chain(result));
@@ skipping 60 matching lines @@
           timer = new Timer(timeLimit, () => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
           });
         }
-        this.then((v) => {
+        this.then(v => {
           if (timer.isActive) {
             timer.cancel();
             result[_completeWithValue](v);
           }
         }, {
           onError: (e, s) => {
             if (timer.isActive) {
               timer.cancel();
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
@@ skipping 108 matching lines @@
         // Function internalCallback: (dynamic) → dynamic
         function internalCallback(_) {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dinvokef(f);
         }
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
-        return (callback) => {
+        return callback => {
           dart.assert(storedCallback == null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         };
       } else if (self.setImmediate != null) {
         return _AsyncRun[_scheduleImmediateWithSetImmediate];
       }
       return _AsyncRun[_scheduleImmediateWithTimer];
     }
@@ skipping 231 matching lines @@
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         if (this[_isCanceled])
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
-        this[_state] = _StreamController[_STATE_ADDSTREAM];
+        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();
         }
         return this[_doneFuture];
@@ skipping 19 matching lines @@
       close() {
         if (this.isClosed) {
           return this[_ensureDoneFuture]();
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_closeUnchecked]();
         return this[_ensureDoneFuture]();
       }
       [_closeUnchecked]() {
-        this[_state] = _StreamController[_STATE_CLOSED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController[_STATE_CLOSED]);
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedDone());
         }
       }
       [_add](value) {
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
         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] = ~dart.notNull(_StreamController[_STATE_ADDSTREAM]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamController[_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, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
-        this[_state] = _StreamController[_STATE_SUBSCRIBED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController[_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]);
@@ skipping 243 matching lines @@
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending$) {
         this[_pending] = pending$;
         this[_isUsed] = false;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         if (this[_isUsed])
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
-        return ((_$) => {
-          _$[_setPendingEvents](this[_pending]());
-          return _$;
-        }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
+        let _$ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
+        _$[_setPendingEvents](this[_pending]());
+        return _$;
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _iterator = Symbol('_iterator');
   let _STATE_UNSCHEDULED = Symbol('_STATE_UNSCHEDULED');
   let _STATE_SCHEDULED = Symbol('_STATE_SCHEDULED');
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
@@ skipping 203 matching lines @@
       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])
           return;
         this[_zone].scheduleMicrotask(this[_sendDone]);
-        this[_state] = _DoneStreamSubscription[_SCHEDULED];
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        this[_state] = _DoneStreamSubscription[_PAUSED];
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription[_PAUSED]);
         if (resumeSignal != null)
           resumeSignal.whenComplete(this.resume);
       }
       resume() {
         if (this.isPaused) {
-          this[_state] = _DoneStreamSubscription[_PAUSED];
+          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] = () => {
           result[_completeWithValue](null);
         };
         return result;
       }
       [_sendDone]() {
-        this[_state] = ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
         if (this.isPaused)
           return;
-        this[_state] = _DoneStreamSubscription[_DONE_SENT];
+        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)];
     _DoneStreamSubscription._DONE_SENT = 1;
     _DoneStreamSubscription._SCHEDULED = 2;
     _DoneStreamSubscription._PAUSED = 4;
     return _DoneStreamSubscription;
   });
@@ skipping 509 matching lines @@
     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 (dart.notNull(this[_remaining]) > 0) {
           sink[_add](inputEvent);
-          this[_remaining] = 1;
+          this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
             sink[_close]();
           }
         }
       }
     }
     return _TakeStream;
   });
   let _TakeStream = _TakeStream$();
   let _TakeWhileStream$ = dart.generic(function(T) {
@@ skipping 312 matching lines @@
   let _HandlerEventSink = _HandlerEventSink$();
   let _defaultHandleData = Symbol('_defaultHandleData');
   let _defaultHandleError = Symbol('_defaultHandleError');
   let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
-        super._StreamSinkTransformer(dart.as((outputSink) => {
+        super._StreamSinkTransformer(dart.as(outputSink => {
           if (handleData == null)
             handleData = dart.as(_StreamHandlerTransformer[_defaultHandleData], dart.throw_("Unimplemented type (S, EventSink<T>) → void"));
           if (handleError == null)
             handleError = dart.as(_StreamHandlerTransformer[_defaultHandleError], dart.throw_("Unimplemented type (Object, StackTrace, EventSink<T>) → void"));
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer[_defaultHandleDone];
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, _SinkMapper));
       }
       bind(stream) {
@@ skipping 359 matching lines @@
       if (runGuarded) {
         return (() => this.runGuarded(registered)).bind(this);
       } else {
         return (() => this.run(registered)).bind(this);
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerUnaryCallback(f);
       if (runGuarded) {
-        return ((arg) => this.runUnaryGuarded(registered, arg)).bind(this);
+        return (arg => this.runUnaryGuarded(registered, arg)).bind(this);
       } else {
-        return ((arg) => this.runUnary(registered, arg)).bind(this);
+        return (arg => this.runUnary(registered, arg)).bind(this);
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
       if (runGuarded) {
         return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this);
       } else {
         return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this);
       }
@@ skipping 342 matching lines @@
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
         return (() => this.runGuarded(f)).bind(this);
       } else {
         return (() => this.run(f)).bind(this);
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return ((arg) => this.runUnaryGuarded(f, arg)).bind(this);
+        return (arg => this.runUnaryGuarded(f, arg)).bind(this);
       } else {
-        return ((arg) => this.runUnary(f, arg)).bind(this);
+        return (arg => this.runUnary(f, arg)).bind(this);
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
         return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
       } else {
         return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
       }
     }
@@ skipping 140 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));