Revert "Convert _propagateToListeners to using an external stack instead of recursion."

sdk/lib/async/future_impl.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 /** The onValue and onError handlers return either a value or a future */
 typedef dynamic _FutureOnValue<T>(T value);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
 /** Used by [WhenFuture]. */
 typedef _FutureAction();
 
-const bool _GUARDED = true;
-const bool _UNGUARDED = false;
-
 abstract class _Completer<T> implements Completer<T> {
   final _Future<T> future = new _Future<T>();
 
   void complete([value]);
 
   void completeError(Object error, [StackTrace stackTrace]) {
     error = _nonNullError(error);
     if (!future._mayComplete) throw new StateError("Future already completed");
     AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
     if (replacement != null) {
@@ skipping 240 matching lines @@
 
   void _setError(Object error, StackTrace stackTrace) {
     _setErrorObject(new AsyncError(error, stackTrace));
   }
 
   void _addListener(_FutureListener listener) {
     assert(listener._nextListener == null);
     if (_isComplete) {
       // Handle late listeners asynchronously.
       _zone.scheduleMicrotask(() {
-        _propagateToFutures(this, listener, _UNGUARDED);
+        _propagateToListeners(this, listener);
       });
     } else {
       listener._nextListener = _resultOrListeners;
       _resultOrListeners = listener;
     }
   }
 
   _FutureListener _removeListeners() {
     // Reverse listeners before returning them, so the resulting list is in
     // subscription order.
@@ skipping 36 matching lines @@
   // Take the value (when completed) of source and complete target with that
   // value (or error). This function expects that source is a _Future.
   static void _chainCoreFuture(_Future source, _Future target) {
     assert(!target._isComplete);
     assert(source is _Future);
 
     // Mark the target as chained (and as such half-completed).
     target._isChained = true;
     _FutureListener listener = new _FutureListener.chain(target);
     if (source._isComplete) {
-      _propagateToFutures(source, listener, _GUARDED);
+      _propagateToListeners(source, listener);
     } else {
       source._addListener(listener);
     }
   }
 
   void _complete(value) {
     assert(!_isComplete);
     if (value is Future) {
       if (value is _Future) {
         _chainCoreFuture(value, this);
       } else {
         _chainForeignFuture(value, this);
       }
     } else {
       _FutureListener listeners = _removeListeners();
       _setValue(value);
-      _propagateToFutures(this, listeners, _GUARDED);
+      _propagateToListeners(this, listeners);
     }
   }
 
   void _completeWithValue(value) {
     assert(!_isComplete);
     assert(value is! Future);
 
     _FutureListener listeners = _removeListeners();
     _setValue(value);
-    _propagateToFutures(this, listeners, _GUARDED);
+    _propagateToListeners(this, listeners);
   }
 
   void _completeError(error, [StackTrace stackTrace]) {
     assert(!_isComplete);
 
     _FutureListener listeners = _removeListeners();
     _setError(error, stackTrace);
-    _propagateToFutures(this, listeners, _GUARDED);
+    _propagateToListeners(this, listeners);
   }
 
   void _asyncComplete(value) {
     assert(!_isComplete);
     // Two corner cases if the value is a future:
     //   1. the future is already completed and an error.
     //   2. the future is not yet completed but might become an error.
     // The first case means that we must not immediately complete the Future,
     // as our code would immediately start propagating the error without
     // giving the time to install error-handlers.
@@ skipping 39 matching lines @@
   void _asyncCompleteError(error, StackTrace stackTrace) {
     assert(!_isComplete);
 
     _markPendingCompletion();
     _zone.scheduleMicrotask(() {
       _completeError(error, stackTrace);
     });
   }
 
   /**
-   * Stack implemented by linked list of [_PendingFutureListeners].
-   *
-   * Each `_PendingFutureListeners` have on source future and one or more
-   * listeners on that future (linked internally through
-   * [_FutureListener._nextListener]).
-   *
-   * While propagating future results to listeners, pending listeners are
-   * stored on this stack.
-   */
-  static _PendingFutureListeners _pendingFutureListeners = null;
-
-  /**
-   * Handle an uncaught async error.
-   *
-   * If the [guarded] flag is `true`, or the future's zone has an error
-   * handler, the uncaught error is passed to the zone's error handler.
-   * Otherwise, the uncaught error is thrown immediately, and is expected
-   * to propagate to the event loop. (If it can't propagate to the event
-   * loop, `guarded` should be true).
-   */
-  static void _throwUncaughtError(_Future source, bool guarded) {
-    assert(source._hasError);
-    AsyncError asyncError = source._error;
-    Zone zone = source._zone;
-    if (guarded || !identical(zone.errorZone, _ROOT_ZONE)) {
-      zone.handleUncaughtError(asyncError.error, asyncError.stackTrace);
-      if (_pendingFutureListeners != null) {
-        _schedulePriorityAsyncCallback(_propagateToFutures);
-      }
-      return;
-    }
-    if (_pendingFutureListeners != null) {
-      _schedulePriorityAsyncCallback(_propagateToFutures);
-    }
-    throw new _UncaughtAsyncError(asyncError.error, asyncError.stackTrace);
-  }
-
-  /**
    * Propagates the value/error of [source] to its [listeners], executing the
    * listeners' callbacks.
-   *
-   * The [guarded] flag should be set when the function isn't being called in
-   * tail position of an event, or if simply throwing an uncaught error is
-   * otherwise not acceptable.
-   *
-   * Parameters are optional to allow using [_propagateToFutures] directly
-   * as a scheduled function. In that case, it takes its sources from
-   * [_pendingFutureListeners].
    */
-  static void _propagateToFutures([_Future source,
-                                   _FutureListener listeners,
-                                   bool guarded = _UNGUARDED]) {
+  static void _propagateToListeners(_Future source, _FutureListener listeners) {
     while (true) {
-      if (source == null) {
-        // Pop source and listeners from _pendingFutureListeners.
-        // This always sets `listeners` to be a single listener.
-        if (_pendingFutureListeners == null) return;
-        _PendingFutureListeners pending = _pendingFutureListeners;
-        // Read top-most source and listener.
-        source = pending.source;
-        listeners = pending.listeners;
-        // Remove the top-most listener. If it's the last listener for
-        // source, go to the next _PendingFutureListeners block.
-        if (listeners != null && listeners._nextListener != null) {
-          pending.listeners = listeners._nextListener;
-          listeners._nextListener = null;
-        } else {
-          _pendingFutureListeners = pending.next;
+      assert(source._isComplete);
+      bool hasError = source._hasError;
+      if (listeners == null) {
+        if (hasError) {
+          AsyncError asyncError = source._error;
+          source._zone.handleUncaughtError(
+              asyncError.error, asyncError.stackTrace);
         }
-      } else {
-        // Check if there are zero listeners, or more than one listener.
-        assert(source._isComplete);
-        if (listeners == null) {
-          // If zero listeners, and source has an error, consider the error
-          // uncaught.
-          if (source._hasError) {
-            _throwUncaughtError(source, guarded);
-            return;
-          }
-          if (_pendingFutureListeners == null) return;
-          source = null;
-          continue;
-        } else if (listeners._nextListener != null) {
-          // Usually futures only have one listener.
-          // If they have several, we put the rest on the pending listener
-          // stack and handle them later.
-          _pendingFutureListeners =
-              new _PendingFutureListeners(source, listeners._nextListener,
-                                          _pendingFutureListeners);
-          listeners._nextListener = null;
-        }
+        return;
       }
-      assert(source != null);
-      assert(listeners != null);
-      assert(listeners._nextListener == null);
+      // Usually futures only have one listener. If they have several, we
+      // call handle them separately in recursive calls, continuing
+      // here only when there is only one listener left.
+      while (listeners._nextListener != null) {
+        _FutureListener listener = listeners;
+        listeners = listener._nextListener;
+        listener._nextListener = null;
+        _propagateToListeners(source, listener);
+      }
       _FutureListener listener = listeners;
-
-      bool hasError = source._hasError;
       // Do the actual propagation.
-      // Set initial state of listenerHasError and listenerValueOrError. These
+      // Set initial state of listenerHasValue and listenerValueOrError. These
       // variables are updated, with the outcome of potential callbacks.
-      bool listenerHasError = hasError;
-      final sourceValue = hasError ? source._error : source._value;
+      bool listenerHasValue = true;
+      final sourceValue = hasError ? null : source._value;
       var listenerValueOrError = sourceValue;
       // Set to true if a whenComplete needs to wait for a future.
       // The whenComplete action will resume the propagation by itself.
       bool isPropagationAborted = false;
       // TODO(floitsch): mark the listener as pending completion. Currently
       // we can't do this, since the markPendingCompletion verifies that
       // the future is not already marked (or chained).
       // Only if we either have an error or callbacks, go into this, somewhat
       // expensive, branch. Here we'll enter/leave the zone. Many futures
       // doesn't have callbacks, so this is a significant optimization.
       if (hasError || (listener.handlesValue || listener.handlesComplete)) {
         Zone zone = listener._zone;
+        if (hasError && !source._zone.inSameErrorZone(zone)) {
+          // Don't cross zone boundaries with errors.
+          AsyncError asyncError = source._error;
+          source._zone.handleUncaughtError(
+              asyncError.error, asyncError.stackTrace);
+          return;
+        }
+
+        Zone oldZone;
+        if (!identical(Zone.current, zone)) {
+          // Change zone if it's not current.
+          oldZone = Zone._enter(zone);
+        }
+
+        bool handleValueCallback() {
+          try {
+            listenerValueOrError = zone.runUnary(listener._onValue,
+                                                 sourceValue);
+            return true;
+          } catch (e, s) {
+            listenerValueOrError = new AsyncError(e, s);
+            return false;
+          }
+        }
 
         void handleError() {
-          assert(listener.handlesError);
           AsyncError asyncError = source._error;
           bool matchesTest = true;
           if (listener.hasErrorTest) {
             _FutureErrorTest test = listener._errorTest;
             try {
               matchesTest = zone.runUnary(test, asyncError.error);
             } catch (e, s) {
               listenerValueOrError = identical(asyncError.error, e) ?
                   asyncError : new AsyncError(e, s);
-              listenerHasError = true;
+              listenerHasValue = false;
               return;
             }
           }
-          if (matchesTest) {
-            Function errorCallback = listener._onError;
-            assert(errorCallback != null);
+          Function errorCallback = listener._onError;
+          if (matchesTest && errorCallback != null) {
             try {
               if (errorCallback is ZoneBinaryCallback) {
                 listenerValueOrError = zone.runBinary(errorCallback,
                                                       asyncError.error,
                                                       asyncError.stackTrace);
               } else {
                 listenerValueOrError = zone.runUnary(errorCallback,
                                                      asyncError.error);
               }
             } catch (e, s) {
               listenerValueOrError = identical(asyncError.error, e) ?
                   asyncError : new AsyncError(e, s);
-              listenerHasError = true;
+              listenerHasValue = false;
               return;
             }
-            listenerHasError = false;
+            listenerHasValue = true;
+          } else {
+            // Copy over the error from the source.
+            listenerValueOrError = asyncError;
+            listenerHasValue = false;
           }
         }
 
         void handleWhenCompleteCallback() {
           var completeResult;
           try {
             completeResult = zone.run(listener._whenCompleteAction);
           } catch (e, s) {
             if (hasError && identical(source._error.error, e)) {
               listenerValueOrError = source._error;
             } else {
               listenerValueOrError = new AsyncError(e, s);
             }
-            listenerHasError = true;
+            listenerHasValue = false;
             return;
           }
           if (completeResult is Future) {
             _Future result = listener.result;
             result._isChained = true;
             isPropagationAborted = true;
-            final _Future originalSource = source;
             completeResult.then((ignored) {
-              _propagateToFutures(originalSource,
-                                  new _FutureListener.chain(result),
-                                  _UNGUARDED);
+              _propagateToListeners(source, new _FutureListener.chain(result));
             }, onError: (error, [stackTrace]) {
               // When there is an error, we have to make the error the new
               // result of the current listener.
               if (completeResult is! _Future) {
                 // This should be a rare case.
                 completeResult = new _Future();
                 completeResult._setError(error, stackTrace);
               }
-              _propagateToFutures(completeResult,
-                                  new _FutureListener.chain(result),
-                                  _UNGUARDED);
+              _propagateToListeners(completeResult,
+                                    new _FutureListener.chain(result));
             });
           }
         }
 
-        Zone oldZone = Zone._enter(zone);
-
         if (!hasError) {
           if (listener.handlesValue) {
-            // Run try/catch in separate function to help compilers.
-            () {
-              try {
-                listenerValueOrError = zone.runUnary(listener._onValue,
-                                                     sourceValue);
-                listenerHasError = false;
-              } catch (e, s) {
-                listenerValueOrError = new AsyncError(e, s);
-                listenerHasError = true;
-              }
-            }();
-            assert(!listener.handlesComplete);
-          } else if (listener.handlesComplete) {
-            // Complete-listeners are distinct from value/error handlers,
-            // so no need to check for a complete handler if it is an error
-            // handler.
-            handleWhenCompleteCallback();
+            listenerHasValue = handleValueCallback();
           }
         } else {
-          if (!source._zone.inSameErrorZone(zone)) {
-            // Don't cross zone boundaries with errors.
-            Zone._leave(oldZone);
-            _throwUncaughtError(source, guarded);
-            return;
-          }
-          if (listener.handlesError) {
-            handleError();
-            assert(!listener.handlesComplete);
-          } else if (listener.handlesComplete) {
-            handleWhenCompleteCallback();
-          }
+          handleError();
         }
+        if (listener.handlesComplete) {
+          handleWhenCompleteCallback();
+        }
+        // If we changed zone, oldZone will not be null.
+        if (oldZone != null) Zone._leave(oldZone);
 
-        Zone._leave(oldZone);
-
-        if (isPropagationAborted) {
-          // Don't use the value in listenerValueOrError - the whenComplete
-          // handler is handling that result.
-          if (_pendingFutureListeners == null) return;
-          source = null;
-          continue;
-        }
+        if (isPropagationAborted) return;
         // If the listener's value is a future we need to chain it. Note that
         // this can only happen if there is a callback. Since 'is' checks
         // can be expensive, we're trying to avoid it.
-        if (!listenerHasError &&
+        if (listenerHasValue &&
             !identical(sourceValue, listenerValueOrError) &&
             listenerValueOrError is Future) {
           Future chainSource = listenerValueOrError;
           // Shortcut if the chain-source is already completed. Just continue
           // the loop.
           _Future result = listener.result;
           if (chainSource is _Future) {
             if (chainSource._isComplete) {
-              // Propagate the value (simulating a tail call).
+              // propagate the value (simulating a tail call).
               result._isChained = true;
               source = chainSource;
               listeners = new _FutureListener.chain(result);
               continue;
             } else {
               _chainCoreFuture(chainSource, result);
             }
           } else {
             _chainForeignFuture(chainSource, result);
           }
-          if (_pendingFutureListeners == null) return;
-          source = null;
-          continue;
+          return;
         }
       }
-      // Complete the future waiting for the result.
       _Future result = listener.result;
-      _FutureListener resultListeners = result._removeListeners();
-      if (!listenerHasError) {
+      listeners = result._removeListeners();
+      if (listenerHasValue) {
         result._setValue(listenerValueOrError);
       } else {
         AsyncError asyncError = listenerValueOrError;
         result._setErrorObject(asyncError);
       }
       // Prepare for next round.
       source = result;
-      listeners = resultListeners;
     }
   }
 
   Future timeout(Duration timeLimit, {onTimeout()}) {
     if (_isComplete) return new _Future.immediate(this);
     _Future result = new _Future();
     Timer timer;
     if (onTimeout == null) {
       timer = new Timer(timeLimit, () {
         result._completeError(new TimeoutException("Future not completed",
@@ skipping 17 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }
-
-class _PendingFutureListeners {
-  final _Future source;
-  final _PendingFutureListeners next;
-  _FutureListener listeners;
-  _PendingFutureListeners(this.source, this.listeners, this.next);
-}