Fixes #254 - Better stacktrace support

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/_isolate_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 260 matching lines @@
               dart.as(newValue, T);
               value = newValue;
             }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
         }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
               try {
-                throw _internal.IterableElementError.noElement();
+                dart.throw(_internal.IterableElementError.noElement());
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result[_complete](value);
             }
           }), cancelOnError: true});
         return result;
@@ skipping 170 matching lines @@
         return new (_DistinctStream$(T))(this, equals);
       }
       get first() {
         let future = new (_Future$(T))();
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _cancelAndValue(subscription, future, value);
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.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(dart.fn(value => {
           dart.as(value, T);
           foundResult = true;
           result = value;
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (dart.notNull(foundResult)) {
             try {
-              throw _internal.IterableElementError.tooMany();
+              dart.throw(_internal.IterableElementError.tooMany());
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       firstWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, value);
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       lastWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
@@ skipping 14 matching lines @@
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               if (dart.notNull(foundResult)) {
                 try {
-                  throw _internal.IterableElementError.tooMany();
+                  dart.throw(_internal.IterableElementError.tooMany());
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
-              throw _internal.IterableElementError.noElement();
+              dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (!(typeof index == 'number') || dart.notNull(index) < 0)
-          throw new core.ArgumentError(index);
+          dart.throw(new core.ArgumentError(index));
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
@@ skipping 764 matching lines @@
       [_addEventError]() {
         if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add new events after calling close");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add new events while doing an addStream");
       }
       add(data) {
         dart.as(data, T);
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_addEventError]();
+          dart.throw(this[_addEventError]());
         this[_sendData](data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_addEventError]();
+          dart.throw(this[_addEventError]());
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_sendError](error, stackTrace);
       }
       close() {
         if (dart.notNull(this.isClosed)) {
           dart.assert(this[_doneFuture] != null);
           return this[_doneFuture];
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_addEventError]();
+          dart.throw(this[_addEventError]());
         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) {
         dart.as(stream, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_addEventError]();
+          dart.throw(this[_addEventError]());
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         this[_addStreamState] = new (_AddStreamState$(T))(this, stream, cancelOnError);
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
         dart.as(data, T);
         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(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_forEachListener](action) {
         dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
         if (dart.notNull(this[_isFiring])) {
-          throw new core.StateError("Cannot fire new event. Controller is already firing an event");
+          dart.throw(new core.StateError("Cannot fire new event. Controller is already firing an event"));
         }
         if (dart.notNull(this[_isEmpty]))
           return;
         let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
         this[_state] = dart.notNull(this[_state]) ^ (dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController$()._STATE_FIRING));
         let link = this[_next];
         while (!dart.notNull(core.identical(link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           if (dart.notNull(subscription[_expectsEvent](id))) {
             subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
@@ skipping 178 matching lines @@
         }
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new _DelayedError(error, stackTrace));
           return;
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_addEventError]();
+          dart.throw(this[_addEventError]());
         this[_sendError](error, stackTrace);
         while (dart.notNull(this[_hasPending])) {
           this[_pending].handleNext(this);
         }
       }
       close() {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](dart.const(new _DelayedDone()));
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_CLOSED);
           return super.done;
@@ skipping 83 matching lines @@
     return __CastType2;
   });
   let __CastType2 = __CastType2$();
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
-      throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
+      dart.throw('DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.');
     }
   }
   dart.setSignature(DeferredLibrary, {
     constructors: () => ({DeferredLibrary: [DeferredLibrary, [core.String], {uri: core.String}]}),
     methods: () => ({load: [Future$(core.Null), []]})
   });
   DeferredLibrary[dart.metadata] = () => [dart.const(new core.Deprecated("Dart sdk v. 1.8"))];
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
@@ skipping 250 matching lines @@
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
         this.future = new (_Future$(T))();
       }
       completeError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this.future[_mayComplete]))
-          throw new core.StateError("Future already completed");
+          dart.throw(new core.StateError("Future already completed"));
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     dart.setSignature(_Completer, {
       methods: () => ({completeError: [dart.void, [core.Object], [core.StackTrace]]})
     });
     return _Completer;
   });
   let _Completer = _Completer$();
   let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       _AsyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
-          throw new core.StateError("Future already completed");
+          dart.throw(new core.StateError("Future already completed"));
         this.future[_asyncComplete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_asyncCompleteError](error, stackTrace);
       }
     }
     dart.setSignature(_AsyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _AsyncCompleter;
   });
   let _AsyncCompleter = _AsyncCompleter$();
   let _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       _SyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
-          throw new core.StateError("Future already completed");
+          dart.throw(new core.StateError("Future already completed"));
         this.future[_complete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_completeError](error, stackTrace);
       }
     }
     dart.setSignature(_SyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
@@ skipping 177 matching lines @@
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return Stream$(T).fromFuture(this);
       }
       [_markPendingCompletion]() {
         if (!dart.notNull(this[_mayComplete]))
-          throw new core.StateError("Future already completed");
+          dart.throw(new core.StateError("Future already completed"));
         this[_state] = _Future$()._PENDING_COMPLETE;
       }
       get [_value]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasValue]));
         return dart.as(this[_resultOrListeners], T);
       }
       get [_error]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasError]));
         return dart.as(this[_resultOrListeners], AsyncError);
       }
@@ skipping 764 matching lines @@
         if (dart.notNull(this.isClosed)) {
           return new core.StateError("Cannot add event after closing");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_badEventState]();
+          dart.throw(this[_badEventState]());
         if (dart.notNull(this[_isCanceled]))
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         return addState.addStreamFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] == null) {
           this[_doneFuture] = dart.notNull(this[_isCanceled]) ? Future._nullFuture : new _Future();
         }
         return this[_doneFuture];
       }
       add(value) {
         dart.as(value, T);
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_badEventState]();
+          dart.throw(this[_badEventState]());
         this[_add](value);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_badEventState]();
+          dart.throw(this[_badEventState]());
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_addError](error, stackTrace);
       }
       close() {
         if (dart.notNull(this.isClosed)) {
           return this[_ensureDoneFuture]();
         }
         if (!dart.notNull(this[_mayAddEvent]))
-          throw this[_badEventState]();
+          dart.throw(this[_badEventState]());
         this[_closeUnchecked]();
         return this[_ensureDoneFuture]();
       }
       [_closeUnchecked]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_CLOSED);
         if (dart.notNull(this.hasListener)) {
           this[_sendDone]();
         } else if (dart.notNull(this[_isInitialState])) {
           this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
         }
@@ skipping 17 matching lines @@
         dart.assert(this[_isAddingStream]);
         let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
         this[_varData] = addState.varData;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (!dart.notNull(this[_isInitialState])) {
-          throw new core.StateError("Stream has already been listened to.");
+          dart.throw(new core.StateError("Stream has already been listened to."));
         }
         let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
         if (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
@@ skipping 333 matching lines @@
   let _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending) {
         this[_pending] = pending;
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this[_isUsed]))
-          throw new core.StateError("Stream has already been listened to.");
+          dart.throw(new core.StateError("Stream has already been listened to."));
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
           _[_setPendingEvents](this[_pending]());
           return _;
         })(), StreamSubscription$(T));
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
       constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
@@ skipping 47 matching lines @@
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data[dartx.iterator];
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
       handleNext(dispatch) {
         if (this[_iterator] == null) {
-          throw new core.StateError("No events pending.");
+          dart.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);
           return;
         }
@@ skipping 83 matching lines @@
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
       dispatch[_sendDone]();
     }
     get next() {
       return null;
     }
     set next(_) {
-      throw new core.StateError("No events after a done.");
+      dart.throw(new core.StateError("No events after a done."));
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   dart.setSignature(_DelayedDone, {
     constructors: () => ({_DelayedDone: [_DelayedDone, []]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   _PendingEvents._STATE_UNSCHEDULED = 0;
   _PendingEvents._STATE_SCHEDULED = 1;
   _PendingEvents._STATE_CANCELED = 3;
@@ skipping 245 matching lines @@
     return _AsBroadcastStream;
   });
   let _AsBroadcastStream = _AsBroadcastStream$();
   let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
       _BroadcastSubscriptionWrapper(stream) {
         this[_stream] = stream;
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
-        throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
+        dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       onError(handleError) {
-        throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
+        dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
-        throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
+        dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         this[_stream][_pauseSubscription](resumeSignal);
       }
       resume() {
         this[_stream][_resumeSubscription]();
       }
       cancel() {
         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.");
+        dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_BroadcastSubscriptionWrapper, {
       constructors: () => ({_BroadcastSubscriptionWrapper: [_BroadcastSubscriptionWrapper$(T), [_AsBroadcastStream]]}),
       methods: () => ({
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
@@ skipping 18 matching lines @@
         this[_subscription] = stream.listen(dart.bind(this, _onData), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] == _StreamIteratorImpl$()._STATE_DONE) {
           return new (_Future$(core.bool)).immediate(false);
         }
         if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
-          throw new core.StateError("Already waiting for next.");
+          dart.throw(new core.StateError("Already waiting for next."));
         }
         if (this[_state] == _StreamIteratorImpl$()._STATE_FOUND) {
           this[_state] = _StreamIteratorImpl$()._STATE_MOVING;
           this[_current] = null;
           this[_futureOrPrefetch] = new (_Future$(core.bool))();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
           dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl$()._STATE_EXTRA_DATA));
           switch (this[_state]) {
             case _StreamIteratorImpl$()._STATE_EXTRA_DATA:
@@ skipping 419 matching lines @@
     return _HandleErrorStream;
   });
   let _HandleErrorStream = _HandleErrorStream$();
   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);
+          dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           sink[_add](inputEvent);
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
             sink[_close]();
           }
@@ skipping 39 matching lines @@
     });
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number') || dart.notNull(count) < 0)
-          throw new core.ArgumentError(count);
+          dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink[_add](inputEvent);
       }
@@ skipping 137 matching lines @@
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
         this[_subscription] = source.listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isClosed])) {
-          throw new core.StateError("Stream is already closed");
+          dart.throw(new core.StateError("Stream is already closed"));
         }
         super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (dart.notNull(this[_isClosed])) {
-          throw new core.StateError("Stream is already closed");
+          dart.throw(new core.StateError("Stream is already closed"));
         }
         super[_addError](error, stackTrace);
       }
       [_close]() {
         if (dart.notNull(this[_isClosed])) {
-          throw new core.StateError("Stream is already closed");
+          dart.throw(new core.StateError("Stream is already closed"));
         }
         super[_close]();
       }
       [_onPause]() {
         if (dart.notNull(this[_isSubscribed]))
           this[_subscription].pause();
       }
       [_onResume]() {
         if (dart.notNull(this[_isSubscribed]))
           this[_subscription].resume();
@@ skipping 952 matching lines @@
       registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
       createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [core.String]]
     })
   });
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(dart.fn(() => {
-      throw new _UncaughtAsyncError(error, stackTrace);
+      dart.throw(new _UncaughtAsyncError(error, stackTrace));
     }));
   }
   dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone._current, zone))
       return f();
     let old = Zone._enter(zone);
     try {
       return f();
     } finally {
@@ skipping 67 matching lines @@
   dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
   function _printToZone(line) {
     Zone.current.print(line);
   }
   dart.fn(_printToZone, dart.void, [core.String]);
   function _rootFork(self, parent, zone, specification, zoneValues) {
     _internal.printToZone = _printToZone;
     if (specification == null) {
       specification = dart.const(ZoneSpecification.new());
     } else if (!dart.is(specification, _ZoneSpecification)) {
-      throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
+      dart.throw(new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor."));
     }
     let valueMap = null;
     if (zoneValues == null) {
       if (dart.is(zone, _Zone)) {
         valueMap = zone[_map];
       } else {
         valueMap = collection.HashMap.new();
       }
     } else {
       valueMap = collection.HashMap.from(zoneValues);
@@ skipping 136 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;
 });