Allow optional callStack argument to Future.completeException().

corelib/src/implementation/future_implementation.dart

 // Copyright 2012 Google Inc. All Rights Reserved.
 // Dart core library.
 
 class FutureImpl<T> implements Future<T> {
 
   bool _isComplete = false;
 
   /**
    * Value that was provided to this Future by the Completer
    */
   T _value;
 
   /**
    * Exception that occured, if there was a problem providing
    * Value.
    */
   Object _exception;
 
   /**
+   * Call stack associated with [_exception], if one was provided.
+   */
+  var _callStack;
+
+  /**
    * true, if any onException handler handled the exception.
    */
   bool _exceptionHandled = false;
 
   /**
    * Listeners waiting to receive the value of this future.
    */
   final List<Function> _successListeners;
 
   /**
@@ skipping 27 matching lines @@
     return _value;
   }
 
   Object get exception() {
     if (!isComplete) {
       throw new FutureNotCompleteException();
     }
     return _exception;
   }
 
+  get callStack() {
+    if (!isComplete) {
+      throw new FutureNotCompleteException();
+    }
+    return _callStack;
+  }
+
   bool get isComplete() {
     return _isComplete;
   }
 
   bool get hasValue() {
     return isComplete && _exception === null;
   }
 
   void then(void onSuccess(T value)) {
     if (hasValue) {
@@ skipping 48 matching lines @@
       } else {
         if (!_exceptionHandled && _successListeners.length > 0) {
           throw _exception;
         }
       }
     } finally {
       for (Function listener in _completionListeners) {
         try {
           listener(this);
         } catch (final e) {}
-      }      
+      }
     }
   }
 
   void _setValue(T value) {
     if (_isComplete) {
       throw new FutureAlreadyCompleteException();
     }
     _value = value;
     _complete();
   }
 
-  void _setException(var exception) {
+  void _setException(Object exception, Object callStack) {
     if (exception === null) {
-      // null is not a legal value for the exception of a Future
+      // null is not a legal value for the exception of a Future.
       throw new IllegalArgumentException(null);
     }
     if (_isComplete) {
       throw new FutureAlreadyCompleteException();
     }
     _exception = exception;
+    _callStack = callStack;
     _complete();
   }
 
   Future transform(Function transformation) {
     final completer = new Completer();
     handleException((e) {
       completer.completeException(e);
       return true;
     });
     then((v) {
       var transformed = null;
       try {
         transformed = transformation(v);
-      } catch (final e) {
-        completer.completeException(e);
+      } catch (final ex, final callStack) {
+        completer.completeException(ex, callStack);
         return;
       }
       completer.complete(transformed);
     });
     return completer.future;
   }
 
   Future chain(Function transformation) {
     final completer = new Completer();
     handleException((e) {
       completer.completeException(e);
       return true;
     });
     then((v) {
       var future = null;
       try {
         future = transformation(v);
-      } catch (final e) {
-        completer.completeException(e);
+      } catch (final ex, final callStack) {
+        completer.completeException(ex, callStack);
         return;
       }
       future.handleException((e) {
         completer.completeException(e);
         return true;
       });
       future.then((b) => completer.complete(b));
     });
     return completer.future;
   }
 }
 
 class CompleterImpl<T> implements Completer<T> {
 
   final FutureImpl<T> _futureImpl;
 
   CompleterImpl() : _futureImpl = new FutureImpl() {}
 
   Future<T> get future() {
     return _futureImpl;
   }
 
   void complete(T value) {
     _futureImpl._setValue(value);
   }
 
-  void completeException(var exception) {
-    _futureImpl._setException(exception);
+  void completeException(Object exception, [Object callStack]) {
+    _futureImpl._setException(exception, callStack);
   }
 }