Add second argument to Future error handlers.

sdk/lib/async/future.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;
 
 /**
  * An object representing a delayed computation.
  *
  * A [Future] is used to obtain a not yet
@@ skipping 247 matching lines @@
    * Returns a new [Future] `f` which is completed with the result of
    * invoking [onValue] (if [this] completes with a value) or [onError] (if
    * [this] completes with an error).
    *
    * If the invoked callback throws an exception, the returned future `f` is
    * completed with the error.
    *
    * If the invoked callback returns a [Future] `f2` then `f` and `f2` are
    * chained. That is, `f` is completed with the completion value of `f2`.
    *
-   * If [onError] is not given, it is equivalent to `(e) { throw e; }`. That
-   * is, it forwards the error to `f`.
+   * The [onError] callback must be of type `void onError(error)` or
+   * `void onError(error, StackTrace stackTrace)`. If [onError] accepts
+   * two arguments it is called with the stack trace (which could be `null` if
+   * the stream itself received an error without stack trace).
+   * Otherwise it is called with just the error object.
+   *
+   * If [onError] is not given it forwards the error to `f`.
    *
    * In most cases, it is more readable to use [catchError] separately, possibly
    * with a `test` parameter, instead of handling both value and error in a
    * single [then] call.
    */
-  Future then(onValue(T value), { onError(Object error) });
+  Future then(onValue(T value), { Function onError });
 
   /**
    * Handles errors emitted by this [Future].
    *
    * Returns a new [Future] `f`.
    *
    * When [this] completes with a value, the value is forwarded to `f`
    * unmodified. That is, `f` completes with the same value.
    *
    * When [this] completes with an error, [test] is called with the
@@ skipping 12 matching lines @@
    *       .catchError(..., test: (e) => e is ArgumentError)
    *       .catchError(..., test: (e) => e is NoSuchMethodError)
    *       .then((v) { ... });
    *
    * This method is equivalent to:
    *
    *     Future catchError(onError(error),
    *                       {bool test(error)}) {
    *       this.then((v) => v,  // Forward the value.
    *                 // But handle errors, if the [test] succeeds.
-   *                 onError: (e) {
+   *                 onError: (e, stackTrace) {
    *                   if (test == null || test(e)) {
+   *                     if (onError is ZoneBinaryCallback) {
+   *                       return onError(e, stackTrace);
+   *                     }
    *                     return onError(e);
    *                   }
    *                   throw e;
    *                 });
    *     }
    *
    */
-  Future catchError(onError(Object error),
+  Future catchError(Function onError,
                     {bool test(Object error)});
 
   /**
    * Register a function to be called when this future completes.
    *
    * The [action] function is called when this future completes, whether it
    * does so with a value or with an error.
    *
    * This is the asynchronous equivalent of a "finally" block.
    *
@@ skipping 140 matching lines @@
    *
    * The argument [exception] must not be `null`.
    */
   void completeError(Object exception, [Object stackTrace]);
 
   /**
    * Whether the future has been completed.
    */
   bool get isCompleted;
 }