Make Completer.complete handle a Future with a misbehaving "then" call.

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);
@@ skipping 286 matching lines @@
 
   // Take the value (when completed) of source and complete target with that
   // value (or error). This function can chain all Futures, but is slower
   // for _Future than _chainCoreFuture - Use _chainCoreFuture in that case.
   static void _chainForeignFuture(Future source, _Future target) {
     assert(!target._isComplete);
     assert(source is! _Future);
 
     // Mark the target as chained (and as such half-completed).
     target._isChained = true;
-    source.then((value) {
-        assert(target._isChained);
-        target._completeWithValue(value);
-      },
-      // 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, stackTrace);
+    try {
+      source.then((value) {
+          assert(target._isChained);
+          target._completeWithValue(value);
+        },
+        // 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, stackTrace);
+        });
+    } catch (e, s) {
+      // The `then` call threw synchronously. This should never happen!

[Søren Gjesse, 2015/03/23 09:07:36]

Maybe explain "This should never happen!" - I assume this is the case for the
_Future implementation.

[Lasse Reichstein Nielsen, 2015/03/23 09:43:54]

The _Future implementation never reaches here. To even reach this function, a
different implementation of Future is required, and to get to the catch, it must
throw when calling "then" with perfectly good arguments - so it's a really bad
implementation - which obviously *shouldn't* happen.

+      scheduleMicrotask(() {
+        target._completeError(e, s);
       });
+    }
   }
 
   // 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;
@@ skipping 63 matching lines @@
           _markPendingCompletion();
           _zone.scheduleMicrotask(() {
             _chainCoreFuture(coreFuture, this);
           });
         } else {
           _chainCoreFuture(coreFuture, this);
         }
       } else {
         // Case 2 from above. Chain the future immidiately.
         // Note that we are still completing asynchronously (through
-        // _chainForeignFuture)..
+        // _chainForeignFuture).
         _chainForeignFuture(typedFuture, this);
       }
       return;
     } else {
       T typedValue = value;
     }
 
     _markPendingCompletion();
     _zone.scheduleMicrotask(() {
       _completeWithValue(value);
@@ skipping 229 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }