Make _Future._chainForeignFuture not cause an assert.

tests/lib/async/future_test.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.
 
 library future_test;
 
 import 'package:async_helper/async_helper.dart';
 import "package:expect/expect.dart";
 import 'dart:async';
 
@@ skipping 976 matching lines @@
   }, onError: (e, s) {
     Expect.fail("Unexpected error: $e");
   });
 
   cs[1].complete(42);
   // The errors are ignored, not uncaught.
   cs[2].completeError("BAD");
   cs[0].completeError("BAD");
 }
 
+void testFutureResult() {
+  asyncStart();
+  () async {
+    var f = new UglyFuture(5);
+    // Sanity check that our future is as mis-behaved as we think.
+    f.then((v) { Expect.isTrue(v is Future); });
+
+    var v = await f;
+    // The static type of await is Flatten(static-type-of-expression), so it
+    // suggests that it flattens. In practice it currently doesn't.
+    // The specification doesn't say anything special, so v should be the
+    // completion value of the UglyFuture future which is a future.
+    Expect.isTrue(v is Future);
+
+    // This used to hit an assert in checked mode.
+    // The CL adding this test changed the behavior to actually flatten the
+    // the future returned by the then-callback.
+    var w = new Future.value(42).then((_) => f);
+    Expect.equals(42, await w);
+    asyncEnd();
+  }();
+}
+
 main() {
   asyncStart();
 
   testValue();
   testSync();
   testNeverComplete();
 
   testComplete();
   testCompleteWithSuccessHandlerBeforeComplete();
   testCompleteWithSuccessHandlerAfterComplete();
@@ skipping 48 matching lines @@
 
   testBadFuture();
 
   testTypes();
 
   testAnyValue();
   testAnyError();
   testAnyIgnoreIncomplete();
   testAnyIgnoreError();
 
+  testFutureResult();
+
   asyncEnd();
 }
 
-/// A Future that isn't recognizable as a _Future.
+/// A well-behaved Future that isn't recognizable as a _Future.
 class CustomFuture<T> implements Future<T> {
   Future _realFuture;
   CustomFuture(this._realFuture);
   Future then(action(result), {Function onError}) =>
       _realFuture.then(action, onError: onError);
   Future catchError(Function onError, {bool test(e)}) =>
       _realFuture.catchError(onError, test: test);
   Future whenComplete(action()) => _realFuture.whenComplete(action);
   Future timeout(Duration timeLimit, {void onTimeout()}) =>
       _realFuture.timeout(timeLimit, onTimeout: onTimeout);
   Stream asStream() => _realFuture.asStream();
   String toString() => "CustomFuture@${_realFuture.hashCode}";
   int get hashCode => _realFuture.hashCode;
 }
 
+/// A bad future that throws on every method.
 class BadFuture<T> implements Future<T> {
   Future then(action(T result), {Function onError}) {
     throw "then GOTCHA!";
   }
   Future catchError(Function onError, {bool test(e)}) {
     throw "catch GOTCHA!";
   }
   Future whenComplete(action()) {
     throw "finally GOTCHA!";
   }
   Stream<T> asStream() {
     throw "asStream GOTCHA!";
   }
   Future timeout(Duration duration, {onTimeout()}) {
     throw "timeout GOTCHA!";
   }
 }
+
+// An evil future that completes with another future.
+class UglyFuture implements Future<dynamic> {
+  final _result;
+  UglyFuture(int badness) :
+      _result = (badness == 0) ? 42 : new UglyFuture(badness - 1);
+  Future then(action(value), {onError(error, StackTrace stack)}) {
+    var c = new Completer();
+    c.complete(new Future.microtask(() => action(_result)));
+    return c.future;
+  }
+  Future catchError(onError, {test}) {}  // Never an error.
+  Future whenComplete(action()) {
+    return new Future.microtask(action).then((_) => this);
+  }
+}