Extension method support to move us closer to a valid List implementation.

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 32 matching lines @@
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
         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.closureWrap(((value) => {
-          controller._add(dart.as(value, T));
-          controller._closeUnchecked();
+          controller[_add](dart.as(value, T));
+          controller[_closeUnchecked]();
         }).bind(this), "(T) → dynamic"), {onError: ((error, stackTrace) => {
-            controller._addError(error, dart.as(stackTrace, core.StackTrace));
-            controller._closeUnchecked();
+            controller[_addError](error, dart.as(stackTrace, core.StackTrace));
+            controller[_closeUnchecked]();
           }).bind(this)});
         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)
@@ skipping 165 matching lines @@
         }, {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);
+              result[_complete](value);
             }
           }).bind(this), 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) => {
             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));
+            result[_completeError](e, dart.as(st, core.StackTrace));
           }).bind(this), onDone: (() => {
-            result._complete(value);
+            result[_complete](value);
           }).bind(this), 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) => {
           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);
           }
 
         }).bind(this), {onError: ((e) => {
-            result._completeError(e);
+            result[_completeError](e);
           }).bind(this), onDone: (() => {
-            result._complete(buffer.toString());
+            result[_complete](buffer.toString());
           }).bind(this), 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) => {
             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);
+            future[_complete](false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
         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);
+            future[_complete](null);
           }).bind(this), cancelOnError: true});
         return future;
       }
       every(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         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);
+            future[_complete](true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       any(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         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);
+            future[_complete](false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.closureWrap((_) => {
           count = dart.notNull(count) + 1;
         }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
-            future._complete(count);
+            future[_complete](count);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.closureWrap((_) => {
           _cancelAndValue(subscription, future, false);
         }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
-            future._complete(true);
+            future[_complete](true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
         let future = new (_Future$(core.List$(T)))();
         this.listen(((data) => {
-          result.add(data);
+          result[core.$add](data);
         }).bind(this), {onError: future[_completeError], onDone: (() => {
-            future._complete(result);
+            future[_complete](result);
           }).bind(this), cancelOnError: true});
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
         this.listen(((data) => {
           result.add(data);
         }).bind(this), {onError: future[_completeError], onDone: (() => {
-            future._complete(result);
+            future[_complete](result);
           }).bind(this), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
         return dart.as(new _TakeStream(this, count), Stream$(T));
@@ skipping 35 matching lines @@
       get last() {
         let future = new (_Future$(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);
+              future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
@@ skipping 12 matching lines @@
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
         }, {onError: future[_completeError], onDone: (() => {
             if (foundResult) {
-              future._complete(result);
+              future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
@@ skipping 32 matching lines @@
         let subscription = null;
         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);
+              future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
@@ skipping 20 matching lines @@
                 }
 
                 return;
               }
               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);
+              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;
       }
       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) => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = 1;
         }, {onError: future[_completeError], onDone: (() => {
-            future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
+            future[_completeError](new core.RangeError.index(index, this, "index", null, elementIndex));
           }).bind(this), cancelOnError: true});
         return future;
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
@@ skipping 78 matching lines @@
     return _StreamImpl;
   });
   let _StreamImpl = _StreamImpl$(dart.dynamic);
   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);
+        return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         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);
@@ skipping 28 matching lines @@
   let _STATE_EVENT_ID = Symbol('_STATE_EVENT_ID');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   let _STATE_REMOVE_AFTER_FIRING = Symbol('_STATE_REMOVE_AFTER_FIRING');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _onPause = Symbol('_onPause');
   let _onResume = Symbol('_onResume');
   let _onCancel = Symbol('_onCancel');
+  let _recordCancel = Symbol('_recordCancel');
+  let _recordPause = Symbol('_recordPause');
+  let _recordResume = Symbol('_recordResume');
   let _zone = Symbol('_zone');
   let _state = Symbol('_state');
   let _STATE_CANCEL_ON_ERROR = Symbol('_STATE_CANCEL_ON_ERROR');
   let _onData = Symbol('_onData');
   let _onError = Symbol('_onError');
   let _onDone = Symbol('_onDone');
   let _cancelFuture = Symbol('_cancelFuture');
   let _pending = Symbol('_pending');
   let _setPendingEvents = Symbol('_setPendingEvents');
   let _STATE_HAS_PENDING = Symbol('_STATE_HAS_PENDING');
@@ skipping 11 matching lines @@
   let _STATE_WAIT_FOR_CANCEL = Symbol('_STATE_WAIT_FOR_CANCEL');
   let _cancel = Symbol('_cancel');
   let _isClosed = Symbol('_isClosed');
   let _STATE_CLOSED = Symbol('_STATE_CLOSED');
   let _STATE_CANCELED = Symbol('_STATE_CANCELED');
   let _waitsForCancel = Symbol('_waitsForCancel');
   let _STATE_IN_CALLBACK = Symbol('_STATE_IN_CALLBACK');
   let _canFire = Symbol('_canFire');
   let _cancelOnError = Symbol('_cancelOnError');
   let _incrementPauseCount = Symbol('_incrementPauseCount');
-  let _add = Symbol('_add');
   let _sendData = Symbol('_sendData');
   let _addPending = Symbol('_addPending');
   let _sendError = Symbol('_sendError');
   let _close = Symbol('_close');
   let _sendDone = Symbol('_sendDone');
   let _checkState = Symbol('_checkState');
   let _BufferingStreamSubscription$ = dart.generic(function(T) {
     class _BufferingStreamSubscription extends core.Object {
       _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
         this[_zone] = Zone.current;
@@ skipping 75 matching lines @@
         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] = (() => {
-          result._complete(futureValue);
+          result[_complete](futureValue);
         }).bind(this);
         this[_onError] = ((error, stackTrace) => {
           this.cancel();
-          result._completeError(error, dart.as(stackTrace, core.StackTrace));
+          result[_completeError](error, dart.as(stackTrace, core.StackTrace));
         }).bind(this);
         return result;
       }
       get [_isInputPaused]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED])) != 0;
       }
       get [_isClosed]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED])) != 0;
       }
       get [_isCanceled]() {
@@ skipping 202 matching lines @@
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$(dart.dynamic);
   let _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
       _ControllerSubscription(controller$, onData, onError, onDone, cancelOnError) {
         this[_controller] = controller$;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
-        return this[_controller]._recordCancel(this);
+        return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
-        this[_controller]._recordPause(this);
+        this[_controller][_recordPause](this);
       }
       [_onResume]() {
-        this[_controller]._recordResume(this);
+        this[_controller][_recordResume](this);
       }
     }
     return _ControllerSubscription;
   });
   let _ControllerSubscription = _ControllerSubscription$(dart.dynamic);
   let _BroadcastSubscription$ = dart.generic(function(T) {
     class _BroadcastSubscription extends _ControllerSubscription$(T) {
       _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_eventState] = null;
         this[_next] = null;
@@ skipping 34 matching lines @@
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
   let _isEmpty = Symbol('_isEmpty');
   let _hasOneListener = Symbol('_hasOneListener');
   let _isAddingStream = Symbol('_isAddingStream');
   let _STATE_ADDSTREAM = Symbol('_STATE_ADDSTREAM');
   let _mayAddEvent = Symbol('_mayAddEvent');
   let _ensureDoneFuture = Symbol('_ensureDoneFuture');
   let _addListener = Symbol('_addListener');
   let _removeListener = Symbol('_removeListener');
-  let _subscribe = Symbol('_subscribe');
-  let _recordCancel = Symbol('_recordCancel');
   let _callOnCancel = Symbol('_callOnCancel');
-  let _recordPause = Symbol('_recordPause');
-  let _recordResume = Symbol('_recordResume');
   let _addEventError = Symbol('_addEventError');
   let _forEachListener = Symbol('_forEachListener');
   let _mayComplete = Symbol('_mayComplete');
+  let _asyncComplete = Symbol('_asyncComplete');
   let _BroadcastStreamController$ = dart.generic(function(T) {
     class _BroadcastStreamController extends core.Object {
       _BroadcastStreamController(onListen$, onCancel$) {
         this[_onListen] = onListen$;
         this[_onCancel] = onCancel$;
         this[_state] = _BroadcastStreamController[_STATE_INITIAL];
         this[_next] = null;
         this[_previous] = null;
         this[_addStreamState] = null;
         this[_doneFuture] = null;
@@ skipping 63 matching lines @@
         if (core.identical(this[_next], this[_previous])) {
           _runGuarded(this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         if (core.identical(subscription[_next], subscription))
           return null;
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
         if (subscription[_isFiring]) {
-          subscription._setRemoveAfterFiring();
+          subscription[_setRemoveAfterFiring]();
         } else {
           dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
           this[_removeListener](subscription);
           if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
         }
         return null;
       }
       [_recordPause](subscription) {}
@@ skipping 63 matching lines @@
         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]);
         let link = this[_next];
         while (!dart.notNull(core.identical(link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          if (subscription._expectsEvent(id)) {
+          if (subscription[_expectsEvent](id)) {
             subscription[_eventState] = _BroadcastSubscription[_STATE_FIRING];
             action(subscription);
-            subscription._toggleEventId();
+            subscription[_toggleEventId]();
             link = subscription[_next];
             if (subscription[_removeAfterFiring]) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = ~dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
           } else {
             link = subscription[_next];
           }
         }
         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);
+          this[_doneFuture][_asyncComplete](null);
         }
         _runGuarded(this[_onCancel]);
       }
     }
     _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
     _BroadcastStreamController._STATE_INITIAL = 0;
     _BroadcastStreamController._STATE_EVENT_ID = 1;
     _BroadcastStreamController._STATE_FIRING = 2;
     _BroadcastStreamController._STATE_CLOSED = 4;
     _BroadcastStreamController._STATE_ADDSTREAM = 8;
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$(dart.dynamic);
   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];
           let subscription = dart.as(this[_next], _BroadcastSubscription);
-          subscription._add(data);
+          subscription[_add](data);
           this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](((subscription) => {
-          subscription._add(data);
+          subscription[_add](data);
         }).bind(this));
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
         this[_forEachListener](((subscription) => {
-          subscription._addError(error, stackTrace);
+          subscription[_addError](error, stackTrace);
         }).bind(this));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.closureWrap(((subscription) => {
-            subscription._close();
+            subscription[_close]();
           }).bind(this), "(_BufferingStreamSubscription<T>) → void"));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
-          this[_doneFuture]._asyncComplete(null);
+          this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dart.dynamic);
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          subscription._addPending(new _DelayedData(data));
+          subscription[_addPending](new _DelayedData(data));
         }
       }
       [_sendError](error, stackTrace) {
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
-          subscription._addPending(new _DelayedError(error, stackTrace));
+          subscription[_addPending](new _DelayedError(error, stackTrace));
         }
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
             let subscription = dart.as(link, _BroadcastSubscription$(T));
-            subscription._addPending(new _DelayedDone());
+            subscription[_addPending](new _DelayedDone());
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
-          this[_doneFuture]._asyncComplete(null);
+          this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     return _AsyncBroadcastStreamController;
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$(dart.dynamic);
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
@@ skipping 41 matching lines @@
         }
         let result = super.close();
         dart.assert(!dart.notNull(this[_hasPending]));
         return result;
       }
       [_callOnCancel]() {
         if (this[_hasPending]) {
           this[_pending].clear();
           this[_pending] = null;
         }
-        super._callOnCancel();
+        super[_callOnCancel]();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     return _AsBroadcastStreamController;
   });
   let _AsBroadcastStreamController = _AsBroadcastStreamController$(dart.dynamic);
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
   let _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
@@ skipping 46 matching lines @@
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s$) {
       this[_s] = s$;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
+  let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
         Timer.run((() => {
           try {
-            result._complete(computation());
+            result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       microtask(computation) {
         let result = new (_Future$(T))();
         scheduleMicrotask((() => {
           try {
-            result._complete(computation());
+            result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       sync(computation) {
         try {
@@ skipping 22 matching lines @@
           }
         }
         return new _Future$(T).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new (_Future$(T))();
         new Timer(duration, (() => {
           try {
-            result._complete(computation == null ? null : computation());
+            result[_complete](computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       static wait(futures, opts) {
         let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
@@ skipping 11 matching lines @@
               for (let value of values) {
                 if (value != null) {
                   new Future.sync(() => {
                     dart.dinvokef(cleanUp, value);
                   });
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
-              result._completeError(theError, dart.as(theStackTrace, core.StackTrace));
+              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);
+            result[_completeError](error, stackTrace);
           }
         }
         for (let future of futures) {
           let pos = ((x) => remaining = dart.notNull(x) + 1, x)(remaining);
           future.then(((value) => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
-              values.set(pos, value);
+              values[core.$set](pos, value);
               if (remaining == 0) {
-                result._completeWithValue(values);
+                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);
+                result[_completeError](error, stackTrace);
               }
             }
           }).bind(this), {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.iterator;
+        let iterator = input[core.$iterator];
         return Future.doWhile((() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new Future.sync((() => dart.dinvokef(f, iterator.current)).bind(this)).then((_) => true);
         }).bind(this));
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
         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);
+            doneSignal[_complete](null);
           }
         }).bind(this), {runGuarded: true});
         dart.dinvokef(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
@@ skipping 36 matching lines @@
     return Completer;
   });
   let Completer = Completer$(dart.dynamic);
   // Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
-    result._completeError(error, dart.as(stackTrace, core.StackTrace));
+    result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
   // Function _nonNullError: (Object) → Object
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
         this.future = new (_Future$(T))();
       }
@@ skipping 11 matching lines @@
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     return _Completer;
   });
   let _Completer = _Completer$(dart.dynamic);
+  let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
-        this.future._asyncComplete(value);
+        this.future[_asyncComplete](value);
       }
       [_completeError](error, stackTrace) {
-        this.future._asyncCompleteError(error, stackTrace);
+        this.future[_asyncCompleteError](error, stackTrace);
       }
     }
     return _AsyncCompleter;
   });
   let _AsyncCompleter = _AsyncCompleter$(dart.dynamic);
   let _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
-        this.future._complete(value);
+        this.future[_complete](value);
       }
       [_completeError](error, stackTrace) {
-        this.future._completeError(error, stackTrace);
+        this.future[_completeError](error, stackTrace);
       }
     }
     return _SyncCompleter;
   });
   let _SyncCompleter = _SyncCompleter$(dart.dynamic);
   let _nextListener = Symbol('_nextListener');
   let _onValue = Symbol('_onValue');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
@@ skipping 65 matching lines @@
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
   _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
   _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
   _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
   _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
   _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
   let _INCOMPLETE = Symbol('_INCOMPLETE');
   let _resultOrListeners = Symbol('_resultOrListeners');
-  let _asyncComplete = Symbol('_asyncComplete');
-  let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _isChained = Symbol('_isChained');
   let _CHAINED = Symbol('_CHAINED');
   let _isComplete = Symbol('_isComplete');
   let _VALUE = Symbol('_VALUE');
   let _hasValue = Symbol('_hasValue');
   let _hasError = Symbol('_hasError');
   let _ERROR = Symbol('_ERROR');
   let _markPendingCompletion = Symbol('_markPendingCompletion');
   let _PENDING_COMPLETE = Symbol('_PENDING_COMPLETE');
   let _value = Symbol('_value');
   let _error = Symbol('_error');
   let _setValue = Symbol('_setValue');
   let _setErrorObject = Symbol('_setErrorObject');
   let _setError = Symbol('_setError');
   let _propagateToListeners = Symbol('_propagateToListeners');
   let _removeListeners = Symbol('_removeListeners');
   let _chainForeignFuture = Symbol('_chainForeignFuture');
   let _chainCoreFuture = Symbol('_chainCoreFuture');
-  let _completeWithValue = Symbol('_completeWithValue');
+  let _enter = Symbol('_enter');
+  let _leave = Symbol('_leave');
   let _Future$ = dart.generic(function(T) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
         this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
       }
       immediate(value) {
         this[_zone] = Zone.current;
         this[_state] = _Future[_INCOMPLETE];
@@ skipping 115 matching lines @@
           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) => {
           dart.assert(target[_isChained]);
-          target._completeWithValue(value);
+          target[_completeWithValue](value);
         }).bind(this), {onError: ((error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
-            target._completeError(error, dart.as(stackTrace, core.StackTrace));
+            target[_completeError](error, dart.as(stackTrace, core.StackTrace));
           }).bind(this)});
       }
       static [_chainCoreFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
           _Future[_propagateToListeners](source, listener);
         } else {
-          source._addListener(listener);
+          source[_addListener](listener);
         }
       }
       [_complete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (dart.is(value, Future)) {
           if (dart.is(value, _Future)) {
             _Future[_chainCoreFuture](dart.as(value, _Future), this);
           } else {
             _Future[_chainForeignFuture](dart.as(value, Future), this);
           }
@@ skipping 76 matching lines @@
           let isPropagationAborted = false;
           if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
             if (!dart.notNull(core.identical(Zone.current, zone))) {
-              oldZone = Zone._enter(zone);
+              oldZone = Zone[_enter](zone);
             }
             // Function handleValueCallback: () → bool
             function handleValueCallback() {
               try {
                 listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
@@ skipping 76 matching lines @@
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
             if (oldZone != null)
-              Zone._leave(oldZone);
+              Zone[_leave](oldZone);
             if (isPropagationAborted)
               return;
             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 {
                   _Future[_chainCoreFuture](chainSource, result);
                 }
               } else {
                 _Future[_chainForeignFuture](chainSource, result);
               }
               return;
             }
           }
           let result = listener.result;
-          listeners = result._removeListeners();
+          listeners = result[_removeListeners]();
           if (listenerHasValue) {
-            result._setValue(listenerValueOrError);
+            result[_setValue](listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
-            result._setErrorObject(asyncError);
+            result[_setErrorObject](asyncError);
           }
           source = result;
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         if (this[_isComplete])
           return new _Future.immediate(this);
         let result = new _Future();
         let timer = null;
         if (onTimeout == null) {
           timer = new Timer(timeLimit, (() => {
-            result._completeError(new TimeoutException("Future not completed", timeLimit));
+            result[_completeError](new TimeoutException("Future not completed", timeLimit));
           }).bind(this));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = new Timer(timeLimit, (() => {
             try {
-              result._complete(zone.run(onTimeout));
+              result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
-              result._completeError(e, s);
+              result[_completeError](e, s);
             }
 
           }).bind(this));
         }
         this.then(((v) => {
           if (timer.isActive) {
             timer.cancel();
-            result._completeWithValue(v);
+            result[_completeWithValue](v);
           }
         }).bind(this), {onError: ((e, s) => {
             if (timer.isActive) {
               timer.cancel();
-              result._completeError(e, dart.as(s, core.StackTrace));
+              result[_completeError](e, dart.as(s, core.StackTrace));
             }
           }).bind(this)});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     _Future._INCOMPLETE = 0;
     _Future._PENDING_COMPLETE = 1;
@@ skipping 17 matching lines @@
   function _asyncRunCallbackLoop() {
     while (exports._nextCallback != null) {
       exports._lastPriorityCallback = null;
       let entry = exports._nextCallback;
       exports._nextCallback = entry.next;
       if (exports._nextCallback == null)
         exports._lastCallback = null;
       entry.callback();
     }
   }
+  let _scheduleImmediate = Symbol('_scheduleImmediate');
   // Function _asyncRunCallback: () → void
   function _asyncRunCallback() {
     exports._isInCallbackLoop = true;
     try {
       _asyncRunCallbackLoop();
     } finally {
       exports._lastPriorityCallback = null;
       exports._isInCallbackLoop = false;
       if (exports._nextCallback != null)
-        _AsyncRun._scheduleImmediate(_asyncRunCallback);
+        _AsyncRun[_scheduleImmediate](_asyncRunCallback);
     }
   }
   // Function _scheduleAsyncCallback: (dynamic) → void
   function _scheduleAsyncCallback(callback) {
     if (exports._nextCallback == null) {
       exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       if (!dart.notNull(exports._isInCallbackLoop)) {
-        _AsyncRun._scheduleImmediate(_asyncRunCallback);
+        _AsyncRun[_scheduleImmediate](_asyncRunCallback);
       }
     } else {
       let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       exports._lastCallback.next = newEntry;
       exports._lastCallback = newEntry;
     }
   }
   // Function _schedulePriorityAsyncCallback: (dynamic) → void
   function _schedulePriorityAsyncCallback(callback) {
     let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
@@ skipping 13 matching lines @@
     }
   }
   // Function scheduleMicrotask: (() → void) → void
   function scheduleMicrotask(callback) {
     if (core.identical(_ROOT_ZONE, Zone.current)) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
-  let _scheduleImmediate = Symbol('_scheduleImmediate');
   let _initializeScheduleImmediate = Symbol('_initializeScheduleImmediate');
   let _scheduleImmediateJsOverride = Symbol('_scheduleImmediateJsOverride');
   let _scheduleImmediateWithSetImmediate = Symbol('_scheduleImmediateWithSetImmediate');
   let _scheduleImmediateWithTimer = Symbol('_scheduleImmediateWithTimer');
+  let _createTimer = Symbol('_createTimer');
   class _AsyncRun extends core.Object {
     static [_scheduleImmediate](callback) {
       dart.dinvokef(_AsyncRun.scheduleImmediateClosure, callback);
     }
     static [_initializeScheduleImmediate]() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate != null) {
         return _AsyncRun[_scheduleImmediateJsOverride];
       }
       if (dart.notNull(self.MutationObserver != null) && dart.notNull(self.document != null)) {
@@ skipping 35 matching lines @@
       // Function internalCallback: () → dynamic
       function internalCallback() {
         _isolate_helper.leaveJsAsync();
         callback();
       }
       ;
       _isolate_helper.enterJsAsync();
       self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
     static [_scheduleImmediateWithTimer](callback) {
-      Timer._createTimer(core.Duration.ZERO, callback);
+      Timer[_createTimer](core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _AsyncRun[_initializeScheduleImmediate]();
     }
   });
   let StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {
     }
@@ skipping 126 matching lines @@
   let _StreamControllerLifecycle = _StreamControllerLifecycle$(dart.dynamic);
   let _varData = Symbol('_varData');
   let _STATE_SUBSCRIBED = Symbol('_STATE_SUBSCRIBED');
   let _isInitialState = Symbol('_isInitialState');
   let _STATE_SUBSCRIPTION_MASK = Symbol('_STATE_SUBSCRIPTION_MASK');
   let _subscription = Symbol('_subscription');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
   let _badEventState = Symbol('_badEventState');
   let _nullFuture = Symbol('_nullFuture');
-  let _closeUnchecked = Symbol('_closeUnchecked');
   let _StreamController$ = dart.generic(function(T) {
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
         this[_state] = _StreamController[_STATE_INITIAL];
         this[_doneFuture] = null;
       }
       get stream() {
         return dart.as(new _ControllerStream(this), Stream$(T));
       }
@@ skipping 139 matching lines @@
         let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = _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((() => {
+        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] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController[_STATE_SUBSCRIBED]) | dart.notNull(_StreamController[_STATE_ADDSTREAM])) | dart.notNull(_StreamController[_STATE_CANCELED]);
         if (this[_onCancel] != null) {
           if (result == null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = ((_$) => {
-                _$._asyncCompleteError(e, s);
+                _$[_asyncCompleteError](e, s);
                 return _$;
               }).bind(this)(new _Future());
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
         // Function complete: () → void
         function complete() {
           if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
-            this[_doneFuture]._asyncComplete(null);
+            this[_doneFuture][_asyncComplete](null);
           }
         }
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
         return result;
       }
       [_recordPause](subscription) {
@@ skipping 17 matching lines @@
     _StreamController._STATE_CANCELED = 2;
     _StreamController._STATE_SUBSCRIPTION_MASK = 3;
     _StreamController._STATE_CLOSED = 4;
     _StreamController._STATE_ADDSTREAM = 8;
     return _StreamController;
   });
   let _StreamController = _StreamController$(dart.dynamic);
   let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
-        this[_subscription]._add(data);
+        this[_subscription][_add](data);
       }
       [_sendError](error, stackTrace) {
-        this[_subscription]._addError(error, stackTrace);
+        this[_subscription][_addError](error, stackTrace);
       }
       [_sendDone]() {
-        this[_subscription]._close();
+        this[_subscription][_close]();
       }
     }
     _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _SyncStreamControllerDispatch;
   });
   let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$(dart.dynamic);
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
-        this[_subscription]._addPending(new _DelayedData(data));
+        this[_subscription][_addPending](new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
-        this[_subscription]._addPending(new _DelayedError(error, stackTrace));
+        this[_subscription][_addPending](new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
-        this[_subscription]._addPending(new _DelayedDone());
+        this[_subscription][_addPending](new _DelayedDone());
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dart.dynamic);
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
         this[_onListen] = onListen$;
@@ skipping 82 matching lines @@
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
         this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return ((e, s) => {
-          controller._addError(e, s);
-          controller._close();
+          controller[_addError](e, s);
+          controller[_close]();
         }).bind(this);
       }
       pause() {
         this.addSubscription.pause();
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel = this.addSubscription.cancel();
         if (cancel == null) {
-          this.addStreamFuture._asyncComplete(null);
+          this.addStreamFuture[_asyncComplete](null);
           return null;
         }
         return cancel.whenComplete((() => {
-          this.addStreamFuture._asyncComplete(null);
+          this.addStreamFuture[_asyncComplete](null);
         }).bind(this));
       }
       complete() {
-        this.addStreamFuture._asyncComplete(null);
+        this.addStreamFuture[_asyncComplete](null);
       }
     }
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$(dart.dynamic);
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
@@ skipping 23 matching lines @@
       _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]());
+          _$[_setPendingEvents](this[_pending]());
           return _$;
         }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
   let _iterator = Symbol('_iterator');
   let _STATE_UNSCHEDULED = Symbol('_STATE_UNSCHEDULED');
   let _STATE_SCHEDULED = Symbol('_STATE_SCHEDULED');
@@ skipping 30 matching lines @@
       if (this.isScheduled)
         this[_state] = _PendingEvents[_STATE_CANCELED];
     }
   }
   _PendingEvents._STATE_UNSCHEDULED = 0;
   _PendingEvents._STATE_SCHEDULED = 1;
   _PendingEvents._STATE_CANCELED = 3;
   let _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
-        this[_iterator] = data.iterator;
+        this[_iterator] = data[core.$iterator];
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
       handleNext(dispatch) {
         if (this[_iterator] == null) {
           throw new core.StateError("No events pending.");
         }
         let isDone = null;
         try {
           isDone = !dart.notNull(this[_iterator].moveNext());
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_iterator] = null;
-          dispatch._sendError(e, s);
+          dispatch[_sendError](e, s);
           return;
         }
 
         if (!dart.notNull(isDone)) {
-          dispatch._sendData(this[_iterator].current);
+          dispatch[_sendData](this[_iterator].current);
         } else {
           this[_iterator] = null;
-          dispatch._sendDone();
+          dispatch[_sendDone]();
         }
       }
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     return _IterablePendingEvents;
   });
@@ skipping 15 matching lines @@
       this.next = null;
     }
   }
   let _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent {
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
-        dispatch._sendData(this.value);
+        dispatch[_sendData](this.value);
       }
     }
     return _DelayedData;
   });
   let _DelayedData = _DelayedData$(dart.dynamic);
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
-      dispatch._sendError(this.error, this.stackTrace);
+      dispatch[_sendError](this.error, this.stackTrace);
     }
   }
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
-      dispatch._sendDone();
+      dispatch[_sendDone]();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   class _StreamImplEvents extends _PendingEvents {
@@ skipping 97 matching lines @@
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = (() => {
-          result._completeWithValue(null);
+          result[_completeWithValue](null);
         }).bind(this);
         return result;
       }
       [_sendDone]() {
         this[_state] = ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
         if (this.isPaused)
           return;
         this[_state] = _DoneStreamSubscription[_DONE_SENT];
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
@@ skipping 32 matching lines @@
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         if (dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed)) {
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         if (this[_subscription] == null) {
           this[_subscription] = this[_source].listen(this[_controller].add, {onError: this[_controller].addError, onDone: this[_controller].close});
         }
         cancelOnError = core.identical(true, cancelOnError);
-        return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
+        return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         let shutdown = dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] != null) {
           this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
         }
         if (shutdown) {
           if (this[_subscription] != null) {
             this[_subscription].cancel();
             this[_subscription] = null;
@@ skipping 42 matching lines @@
       }
       onError(handleError) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
       onDone(handleDone) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        this[_stream]._pauseSubscription(resumeSignal);
+        this[_stream][_pauseSubscription](resumeSignal);
       }
       resume() {
-        this[_stream]._resumeSubscription();
+        this[_stream][_resumeSubscription]();
       }
       cancel() {
-        this[_stream]._cancelSubscription();
+        this[_stream][_cancelSubscription]();
         return null;
       }
       get isPaused() {
         return this[_stream][_isSubscriptionPaused];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
@@ skipping 64 matching lines @@
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
         this[_current] = null;
         this[_state] = _StreamIteratorImpl[_STATE_DONE];
       }
       cancel() {
         let subscription = this[_subscription];
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
-          hasNext._complete(false);
+          hasNext[_complete](false);
         } else {
           this[_clear]();
         }
         return subscription.cancel();
       }
       [_onData](data) {
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           this[_current] = data;
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_futureOrPrefetch] = null;
           this[_state] = _StreamIteratorImpl[_STATE_FOUND];
-          hasNext._complete(true);
+          hasNext[_complete](true);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] == null);
         this[_futureOrPrefetch] = data;
         this[_state] = _StreamIteratorImpl[_STATE_EXTRA_DATA];
       }
       [_onError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
-          hasNext._completeError(error, stackTrace);
+          hasNext[_completeError](error, stackTrace);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] == null);
         this[_futureOrPrefetch] = new AsyncError(error, stackTrace);
         this[_state] = _StreamIteratorImpl[_STATE_EXTRA_ERROR];
       }
       [_onDone]() {
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
-          hasNext._complete(false);
+          hasNext[_complete](false);
           return;
         }
         this[_subscription].pause();
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl[_STATE_EXTRA_DONE];
       }
     }
     _StreamIteratorImpl[dart.implements] = () => [StreamIterator$(T)];
     _StreamIteratorImpl._STATE_FOUND = 0;
     _StreamIteratorImpl._STATE_DONE = 1;
@@ skipping 18 matching lines @@
         let stackTrace = replacement.stackTrace;
         dart.dinvokef(onError, error, stackTrace);
       }
     }
 
   }
   // Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
   function _cancelAndError(subscription, future, error, stackTrace) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(() => future._completeError(error, stackTrace));
+      cancelFuture.whenComplete(() => future[_completeError](error, stackTrace));
     } else {
-      future._completeError(error, stackTrace);
+      future[_completeError](error, stackTrace);
     }
   }
   // Function _cancelAndErrorWithReplacement: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
   function _cancelAndErrorWithReplacement(subscription, future, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, stackTrace);
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     _cancelAndError(subscription, future, error, stackTrace);
   }
   // Function _cancelAndErrorClosure: (StreamSubscription<dynamic>, _Future<dynamic>) → dynamic
   function _cancelAndErrorClosure(subscription, future) {
     return (error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace);
   }
   // Function _cancelAndValue: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic) → void
   function _cancelAndValue(subscription, future, value) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(() => future._complete(value));
+      cancelFuture.whenComplete(() => future[_complete](value));
     } else {
-      future._complete(value);
+      future[_complete](value);
     }
   }
   let _handleData = Symbol('_handleData');
   let _handleError = Symbol('_handleError');
   let _handleDone = Symbol('_handleDone');
   let _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
       _ForwardingStream(source$) {
         this[_source] = source$;
         super.Stream();
       }
       get isBroadcast() {
         return this[_source].isBroadcast;
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         return this[_createSubscription](onData, onError, onDone, cancelOnError);
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return new (_ForwardingStreamSubscription$(S, T))(this, onData, onError, onDone, cancelOnError);
       }
       [_handleData](data, sink) {
         let outputData = data;
-        sink._add(outputData);
+        sink[_add](outputData);
       }
       [_handleError](error, stackTrace, sink) {
-        sink._addError(error, stackTrace);
+        sink[_addError](error, stackTrace);
       }
       [_handleDone](sink) {
-        sink._close();
+        sink[_close]();
       }
     }
     return _ForwardingStream;
   });
   let _ForwardingStream = _ForwardingStream$(dart.dynamic, dart.dynamic);
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream$, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream$;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
       }
       [_add](data) {
         if (this[_isClosed])
           return;
-        super._add(data);
+        super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (this[_isClosed])
           return;
-        super._addError(error, stackTrace);
+        super[_addError](error, stackTrace);
       }
       [_onPause]() {
         if (this[_subscription] == null)
           return;
         this[_subscription].pause();
       }
       [_onResume]() {
         if (this[_subscription] == null)
           return;
         this[_subscription].resume();
       }
       [_onCancel]() {
         if (this[_subscription] != null) {
           let subscription = this[_subscription];
           this[_subscription] = null;
           subscription.cancel();
         }
         return null;
       }
       [_handleData](data) {
-        this[_stream]._handleData(data, this);
+        this[_stream][_handleData](data, this);
       }
       [_handleError](error, stackTrace) {
-        this[_stream]._handleError(error, stackTrace, this);
+        this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
-        this[_stream]._handleDone(this);
+        this[_stream][_handleDone](this);
       }
     }
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$(dart.dynamic, dart.dynamic);
   // Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
   function _addErrorWithReplacement(sink, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
-    sink._addError(error, dart.as(stackTrace, core.StackTrace));
+    sink[_addError](error, dart.as(stackTrace, core.StackTrace));
   }
   let _test = Symbol('_test');
   let _WhereStream$ = dart.generic(function(T) {
     class _WhereStream extends _ForwardingStream$(T, T) {
       _WhereStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         if (satisfies) {
-          sink._add(inputEvent);
+          sink[_add](inputEvent);
         }
       }
     }
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$(dart.dynamic);
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let outputEvent = null;
         try {
           outputEvent = dart.as(dart.dinvokef(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
-        sink._add(outputEvent);
+        sink[_add](outputEvent);
       }
     }
     return _MapStream;
   });
   let _MapStream = _MapStream$(dart.dynamic, dart.dynamic);
   let _expand = Symbol('_expand');
   let _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         try {
           for (let value of this[_expand](inputEvent)) {
-            sink._add(value);
+            sink[_add](value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     return _ExpandStream;
   });
@@ skipping 16 matching lines @@
             return;
           }
 
         }
         if (matches) {
           try {
             _invokeErrorHandler(this[_transform], error, stackTrace);
           } catch (e) {
             let s = dart.stackTrace(e);
             if (core.identical(e, error)) {
-              sink._addError(error, stackTrace);
+              sink[_addError](error, stackTrace);
             } else {
               _addErrorWithReplacement(sink, e, s);
             }
             return;
           }
 
         } else {
-          sink._addError(error, stackTrace);
+          sink[_addError](error, stackTrace);
         }
       }
     }
     return _HandleErrorStream;
   });
   let _HandleErrorStream = _HandleErrorStream$(dart.dynamic);
   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 (dart.notNull(this[_remaining]) > 0) {
-          sink._add(inputEvent);
+          sink[_add](inputEvent);
           this[_remaining] = 1;
           if (this[_remaining] == 0) {
-            sink._close();
+            sink[_close]();
           }
         }
       }
     }
     return _TakeStream;
   });
   let _TakeStream = _TakeStream$(dart.dynamic);
   let _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
-          sink._close();
+          sink[_close]();
           return;
         }
 
         if (satisfies) {
-          sink._add(inputEvent);
+          sink[_add](inputEvent);
         } else {
-          sink._close();
+          sink[_close]();
         }
       }
     }
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$(dart.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)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
-        sink._add(inputEvent);
+        sink[_add](inputEvent);
       }
     }
     return _SkipStream;
   });
   let _SkipStream = _SkipStream$(dart.dynamic);
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         if (this[_hasFailed]) {
-          sink._add(inputEvent);
+          sink[_add](inputEvent);
           return;
         }
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           this[_hasFailed] = true;
           return;
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
-          sink._add(inputEvent);
+          sink[_add](inputEvent);
         }
       }
     }
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$(dart.dynamic);
   let _SENTINEL = Symbol('_SENTINEL');
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream[_SENTINEL];
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         if (core.identical(this[_previous], _DistinctStream[_SENTINEL])) {
           this[_previous] = inputEvent;
-          return sink._add(inputEvent);
+          return sink[_add](inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
               isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
             }
           } catch (e) {
             let s = dart.stackTrace(e);
             _addErrorWithReplacement(sink, e, s);
             return null;
           }
 
           if (!dart.notNull(isEqual)) {
-            sink._add(inputEvent);
+            sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.defineLazyProperties(_DistinctStream, {
       get _SENTINEL() {
         return new core.Object();
       },
       set _SENTINEL(_) {}
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$(dart.dynamic);
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink$) {
         this[_sink] = sink$;
       }
       add(data) {
-        this[_sink]._add(data);
+        this[_sink][_add](data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        this[_sink]._addError(error, stackTrace);
+        this[_sink][_addError](error, stackTrace);
       }
       close() {
-        this[_sink]._close();
+        this[_sink][_close]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     return _EventSinkWrapper;
   });
   let _EventSinkWrapper = _EventSinkWrapper$(dart.dynamic);
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
         this[_subscription] = source.listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
-        super._add(data);
+        super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
-        super._addError(error, stackTrace);
+        super[_addError](error, stackTrace);
       }
       [_close]() {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
-        super._close();
+        super[_close]();
       }
       [_onPause]() {
         if (this[_isSubscribed])
           this[_subscription].pause();
       }
       [_onResume]() {
         if (this[_isSubscribed])
           this[_subscription].resume();
       }
       [_onCancel]() {
@@ skipping 166 matching lines @@
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     return _BoundSubscriptionStream;
   });
   let _BoundSubscriptionStream = _BoundSubscriptionStream$(dart.dynamic, dart.dynamic);
-  let _createTimer = Symbol('_createTimer');
   let _createPeriodicTimer = Symbol('_createPeriodicTimer');
   class Timer extends core.Object {
     Timer(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createTimer(duration, callback);
       }
       return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
     }
     periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
@@ skipping 73 matching lines @@
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
   class ZoneDelegate extends core.Object {
   }
   let _$ = Symbol('_');
-  let _enter = Symbol('_enter');
-  let _leave = Symbol('_leave');
   class Zone extends core.Object {
     [_$]() {
     }
     static get current() {
       return Zone[_current];
     }
     static [_enter](zone) {
       dart.assert(zone != null);
       dart.assert(!dart.notNull(core.identical(zone, Zone[_current])));
       let previous = Zone[_current];
@@ skipping 307 matching lines @@
   // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     });
   }
   // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone[_current], zone))
       return f();
-    let old = Zone._enter(zone);
+    let old = Zone[_enter](zone);
     try {
       return f();
     } finally {
-      Zone._leave(old);
+      Zone[_leave](old);
     }
   }
   // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
   function _rootRunUnary(self, parent, zone, f, arg) {
     if (dart.equals(Zone[_current], zone))
       return dart.dinvokef(f, arg);
-    let old = Zone._enter(zone);
+    let old = Zone[_enter](zone);
     try {
       return dart.dinvokef(f, arg);
     } finally {
-      Zone._leave(old);
+      Zone[_leave](old);
     }
   }
   // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
     if (dart.equals(Zone[_current], zone))
       return dart.dinvokef(f, arg1, arg2);
-    let old = Zone._enter(zone);
+    let old = Zone[_enter](zone);
     try {
       return dart.dinvokef(f, arg1, arg2);
     } finally {
-      Zone._leave(old);
+      Zone[_leave](old);
     }
   }
   // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
   // Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
     return f;
   }
@@ skipping 11 matching lines @@
       let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
       f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
     }
     _scheduleAsyncCallback(f);
   }
   // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
   function _rootCreateTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = zone.bindCallback(callback);
     }
-    return Timer._createTimer(duration, callback);
+    return Timer[_createTimer](duration, callback);
   }
   // Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = dart.closureWrap(zone.bindUnaryCallback(callback), "(Timer) → void");
     }
-    return Timer._createPeriodicTimer(duration, callback);
+    return Timer[_createPeriodicTimer](duration, callback);
   }
   // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   // Function _printToZone: (String) → void
   function _printToZone(line) {
     Zone.current.print(line);
   }
   // Function _rootFork: (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone
@@ skipping 212 matching lines @@
     registerBinaryCallback(f) {
       return f;
     }
     errorCallback(error, stackTrace) {
       return null;
     }
     scheduleMicrotask(f) {
       _rootScheduleMicrotask(null, null, this, f);
     }
     createTimer(duration, f) {
-      return Timer._createTimer(duration, f);
+      return Timer[_createTimer](duration, f);
     }
     createPeriodicTimer(duration, f) {
-      return Timer._createPeriodicTimer(duration, f);
+      return Timer[_createPeriodicTimer](duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return new collection.HashMap();
     },
@@ skipping 68 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));