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 Feature(5);
+    f.then((v) { Expect.isTrue(v is Future); });  // Feature is designed that way.

[floitsch, 2016/05/10 15:39:51]

long line.

[Lasse Reichstein Nielsen, 2016/05/11 10:19:37]

Done.

+    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 Feature 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.
 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)}) =>
@@ skipping 16 matching lines @@
   Future whenComplete(action()) {
     throw "finally GOTCHA!";
   }
   Stream<T> asStream() {
     throw "asStream GOTCHA!";
   }
   Future timeout(Duration duration, {onTimeout()}) {
     throw "timeout GOTCHA!";
   }
 }
+
+// Bad future that completes with another future.
+class Feature implements Future<dynamic> {

[floitsch, 2016/05/10 15:39:51]

Please rename. It took me several attempts to read the comments for the test.

[Lasse Reichstein Nielsen, 2016/05/11 10:19:37]

Done. Now being clever in a more easily distinguishable way.

+  final _result;
+  Feature(int badness) : _result = badness == 0 ? 42 : new Feature(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);
+  }
+}