Add second argument to Future error handlers.

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);
-typedef dynamic _FutureOnError(error);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
 /** Used by [WhenFuture]. */
 typedef _FutureAction();
 
 abstract class _Completer<T> implements Completer<T> {
   final _Future<T> future = new _Future<T>();
 
   void complete([T value]);
 
@@ skipping 103 matching lines @@
   // TODO(floitsch): since single listeners are the common case we should
   // use a bit to indicate that the _resultOrListeners contains a container.
   _Future _nextListener;
 
   // TODO(floitsch): we only need two closure fields to store the callbacks.
   // If we store the type of a closure in the state field (where there are
   // still bits left), we can just store two closures instead of using 4
   // fields of which 2 are always null.
   final _FutureOnValue _onValueCallback;
   final _FutureErrorTest _errorTestCallback;
-  final _FutureOnError _onErrorCallback;
+  final Function _onErrorCallback;
   final _FutureAction _whenCompleteActionCallback;
 
   _FutureOnValue get _onValue => _isChained ? null : _onValueCallback;
   _FutureErrorTest get _errorTest => _isChained ? null : _errorTestCallback;
-  _FutureOnError get _onError => _isChained ? null : _onErrorCallback;
+  Function get _onError => _isChained ? null : _onErrorCallback;
   _FutureAction get _whenCompleteAction
       => _isChained ? null : _whenCompleteActionCallback;
 
   _Future()
       : _zone = Zone.current,
         _onValueCallback = null, _errorTestCallback = null,
         _onErrorCallback = null, _whenCompleteActionCallback = null;
 
   /// Valid types for value: `T` or `Future<T>`.
   _Future.immediate(value)
         : _zone = Zone.current,
           _onValueCallback = null, _errorTestCallback = null,
           _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncComplete(value);
   }
 
   _Future.immediateError(var error, [Object stackTrace])
       : _zone = Zone.current,
         _onValueCallback = null, _errorTestCallback = null,
         _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncCompleteError(error, stackTrace);
   }
 
-  _Future._then(onValueCallback(value), onErrorCallback(e))
+  _Future._then(onValueCallback(value), Function onErrorCallback)
       : _zone = Zone.current,
         _onValueCallback = Zone.current.registerUnaryCallback(onValueCallback),
-        _onErrorCallback = Zone.current.registerUnaryCallback(onErrorCallback),
+        _onErrorCallback = _registerErrorCallback(onErrorCallback),
         _errorTestCallback = null,
         _whenCompleteActionCallback = null;
 
-  _Future._catchError(onErrorCallback(e), bool errorTestCallback(e))
+  _Future._catchError(Function onErrorCallback, bool errorTestCallback(e))
     : _zone = Zone.current,
-      _onErrorCallback = Zone.current.registerUnaryCallback(onErrorCallback),
-      _errorTestCallback = Zone.current.registerUnaryCallback(errorTestCallback),
+      _onErrorCallback = _registerErrorCallback(onErrorCallback),
+      _errorTestCallback =
+          Zone.current.registerUnaryCallback(errorTestCallback),
       _onValueCallback = null,
       _whenCompleteActionCallback = null;
 
   _Future._whenComplete(whenCompleteActionCallback())
       : _zone = Zone.current,
         _whenCompleteActionCallback =
             Zone.current.registerCallback(whenCompleteActionCallback),
         _onValueCallback = null,
         _errorTestCallback = null,
         _onErrorCallback = null;
 
-  Future then(f(T value), { onError(error) }) {
+  /// Register the given [errorCallback] in the current zone.
+  static Function _registerErrorCallback(Function errorCallback) {
+    if (errorCallback is ZoneBinaryCallback) {
+      return Zone.current.registerBinaryCallback(errorCallback);
+    } else {
+      return Zone.current.registerUnaryCallback(errorCallback);
+    }
+  }
+
+  Future then(f(T value), { Function onError }) {
     _Future result;
     result = new _Future._then(f, onError);
     _addListener(result);
     return result;
   }
 
-  Future catchError(f(error), { bool test(error) }) {
-    _Future result = new _Future._catchError(f, test);
+  Future catchError(Function onError, { bool test(error) }) {
+    _Future result = new _Future._catchError(onError, test);
     _addListener(result);
     return result;
   }
 
   Future<T> whenComplete(action()) {
     _Future result = new _Future<T>._whenComplete(action);
     _addListener(result);
     return result;
   }
 
   Stream<T> asStream() => new Stream.fromFuture(this);
 
   void _markPendingCompletion() {
     if (!_mayComplete) throw new StateError("Future already completed");
     _state = _PENDING_COMPLETE;
   }
 
   T get _value {
     assert(_isComplete && _hasValue);
     return _resultOrListeners;
   }
 
-  Object get _error {
+  _AsyncError get _error {
     assert(_isComplete && _hasError);
     return _resultOrListeners;
   }
 
   void _setValue(T value) {
     assert(!_isComplete);  // But may have a completion pending.
     _state = _VALUE;
     _resultOrListeners = value;
   }
 
-  void _setError(Object error) {
+  void _setError(Object error, StackTrace stackTrace) {
     assert(!_isComplete);  // But may have a completion pending.
     _state = _ERROR;
-    _resultOrListeners = error;
+    _resultOrListeners = new _AsyncError(error, stackTrace);
   }
 
   void _addListener(_Future listener) {
     assert(listener._nextListener == null);
     if (_isComplete) {
       // Handle late listeners asynchronously.
       _zone.scheduleMicrotask(() {
         _propagateToListeners(this, listener);
       });
     } else {
@@ skipping 28 matching lines @@
       if (internalFuture._isComplete) {
         _propagateToListeners(internalFuture, target);
       } else {
         internalFuture._addListener(target);
       }
     } else {
       source.then((value) {
           assert(target._isChained);
           target._complete(value);
         },
-        onError: (error) {
+        // TODO(floitsch): eventually we would like to make this non-optional
+        // and dependent on the listeners of the target future. If none of
+        // the target future's listeners want to have the stack trace we don't
+        // need a trace.
+        onError: (error, [stackTrace]) {
           assert(target._isChained);
-          target._completeError(error);
+          target._completeError(error, stackTrace);
         });
     }
   }
 
   void _complete(value) {
     assert(!_isComplete);
     assert(_onValue == null);
     assert(_onError == null);
     assert(_whenCompleteAction == null);
     assert(_errorTest == null);
@@ skipping 13 matching lines @@
     assert(_onError == null);
     assert(_whenCompleteAction == null);
     assert(_errorTest == null);
 
     if (stackTrace != null) {
       // Force the stack trace onto the error, even if it already had one.
       _attachStackTrace(error, stackTrace);
     }
 
     _Future listeners = _isChained ? null : _removeListeners();
-    _setError(error);
+    _setError(error, stackTrace);
     _propagateToListeners(this, listeners);
   }
 
   void _asyncComplete(value) {
     assert(!_isComplete);
     assert(_onValue == null);
     assert(_onError == null);
     assert(_whenCompleteAction == null);
     assert(_errorTest == null);
     // Two corner cases if the value is a future:
@@ skipping 66 matching lines @@
    *
    * If [runCallback] is true (which should be the default) it executes
    * the registered action of listeners. If it is `false` then the callback is
    * skipped. This is used to complete futures with chained futures.
    */
   static void _propagateToListeners(_Future source, _Future listeners) {
     while (true) {
       if (!source._isComplete) return;  // Chained future.
       bool hasError = source._hasError;
       if (hasError && listeners == null) {
-        source._zone.handleUncaughtError(source._error);
+        _AsyncError asyncError = source._error;
+        source._zone.handleUncaughtError(
+            asyncError.error, asyncError.stackTrace);
         return;
       }
       if (listeners == null) return;
       _Future listener = listeners;
       if (listener._nextListener != null) {
         // Usually futures only have one listener. If they have several, we
         // handle them specially.
         _propagateMultipleListeners(source, listeners);
         return;
       }
       if (hasError && !source._zone.inSameErrorZone(listener._zone)) {
         // Don't cross zone boundaries with errors.
-        source._zone.handleUncaughtError(source._error);
+        _AsyncError asyncError = source._error;
+        source._zone.handleUncaughtError(
+            asyncError.error, asyncError.stackTrace);
         return;
       }
       if (!identical(Zone.current, listener._zone)) {
         // Run the propagation in the listener's zone to avoid
         // zone transitions. The idea is that many chained futures will
         // be in the same zone.
         listener._zone.run(() {
           _propagateToListeners(source, listener);
         });
         return;
@@ skipping 22 matching lines @@
             var value = source._value;
             if (listener._onValue != null) {
               listenerValueOrError = listener._onValue(value);
               listenerHasValue = true;
             } else {
               // Copy over the value from the source.
               listenerValueOrError = value;
               listenerHasValue = true;
             }
           } else {
-            Object error = source._error;
+            _AsyncError asyncError = source._error;
             _FutureErrorTest test = listener._errorTest;
             bool matchesTest = true;
             if (test != null) {
-              matchesTest = test(error);
+              matchesTest = test(asyncError.error);
             }
             if (matchesTest && listener._onError != null) {
-              listenerValueOrError = listener._onError(error);
+              Function errorCallback = listener._onError;
+              if (errorCallback is ZoneBinaryCallback) {
+                listenerValueOrError =
+                    errorCallback(asyncError.error, asyncError.stackTrace);
+              } else {
+                listenerValueOrError = listener._onError(asyncError.error);
+              }
               listenerHasValue = true;
             } else {
               // Copy over the error from the source.
-              listenerValueOrError = error;
+              listenerValueOrError = asyncError;
               listenerHasValue = false;
             }
           }
 
           if (listener._whenCompleteAction != null) {
             var completeResult = listener._whenCompleteAction();
             if (completeResult is Future) {
               listener._isChained = true;
               completeResult.then((ignored) {
                 // Try again, but this time don't run the whenComplete callback.
                 _propagateToListeners(source, listener);
-              }, onError: (error) {
+              }, 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);
+                  completeResult._setError(error, stackTrace);
                 }
                 _propagateToListeners(completeResult, listener);
               });
               isPropagationAborted = true;
             }
           }
         } catch (e, s) {
-          // Set the exception as error.
-          listenerValueOrError = _asyncError(e, s);
+          // Set the exception as error unless the error is the same as the
+          // original one.
+          if (hasError && identical(source._error.error, e)) {
+            listenerValueOrError = source._error;
+          } else {
+            listenerValueOrError = new _AsyncError(_asyncError(e, s), s);
+          }
           listenerHasValue = false;
         }
       });
       if (isPropagationAborted) return;
       // If the listener's value is a future we need to chain it.
       if (listenerHasValue && listenerValueOrError is Future) {
         Future chainSource = listenerValueOrError;
         // Shortcut if the chain-source is already completed. Just continue the
         // loop.
         if (chainSource is _Future && (chainSource as _Future)._isComplete) {
           // propagate the value (simulating a tail call).
           listener._isChained = true;
           source = chainSource;
           listeners = listener;
           continue;
         }
         _chainFutures(chainSource, listener);
         return;
       }
 
       if (listenerHasValue) {
         listeners = listener._removeListeners();
         listener._setValue(listenerValueOrError);
       } else {
         listeners = listener._removeListeners();
-        listener._setError(listenerValueOrError);
+        _AsyncError asyncError = listenerValueOrError;
+        listener._setError(asyncError.error, asyncError.stackTrace);
       }
       // Prepare for next round.
       source = listener;
     }
   }
 }