If transformException() returns a future, act like chain().

lib/coreimpl/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
    */
@@ skipping 201 matching lines @@
       future.then((b) => completer.complete(b));
     });
     return completer.future;
   }
 
   Future transformException(transformation(Object exception)) {
     final completer = new Completer();
 
     handleException((ex) {
       try {
-        completer.complete(transformation(ex));
+        final result = transformation(ex);
+
+        // If the transformation itself returns a future, then we will
+        // complete to what that completes to.
+        if (result is Future) {
+          result.handleException((e) {
+            completer.completeException(e, result.stackTrace);
+            return true;
+          });
+          result.then((value) => completer.complete(value));

[Siggi Cherem (dart-lang), 2012/09/20 22:00:17]

I've seen the pattern of the last 4 lines quite a few times, could we add a
helper method to do this? (it could be private, for instance:

class Completer<T> {
  _propagateFrom(Future<T> future) {
    future.handleException((e) {
      completeException(e, future.stackTrace);
      return true;
    });
    future.then((value) => complete(value));
  }
}

or maybe better as part of future?

class Future<T> {
  ...
  _forwardTo(Completer<T> completer) {
    handleException((e) {
      completer.completeException(e, stackTrace);
      return true;
    });
    then((value) => completer.complete(value));
  }
}

[Bob Nystrom, 2012/09/20 22:34:53]

Done.

I put it in _FutureImpl (which, by the way, should just be unified with Future
at some point after M1) and it passes in the future explicitly (instead of using
'this'). I can't put it in Future because you can't rely on a private method
existing on an object other than this. If you do:

foo(Future bar) {
  bar._somePrivateMethod();
}

It's possible that the bar that gets passed in is an instance of some other type
that implements Future's implicit interface and doesn't have _somePrivateMethod.

+        } else {
+          completer.complete(result);
+        }
       } catch (innerException, stackTrace) {
         completer.completeException(innerException, stackTrace);
       }
       return true;
     });
 
     then(completer.complete);
 
     return completer.future;
   }
@@ skipping 10 matching lines @@
   }
 
   void complete(T value) {
     _futureImpl._setValue(value);
   }
 
   void completeException(Object exception, [Object stackTrace]) {
     _futureImpl._setException(exception, stackTrace);
   }
 }