Make generic type of timeout-future the same as the one from the original.

sdk/lib/async/future.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;
 
 /**
  * An object representing a delayed computation.
  *
  * A [Future] is used to represent a potential value, or error,
@@ skipping 502 matching lines @@
   Stream<T> asStream();
 
   /**
    * Time-out the future computation after [timeLimit] has passed.
    *
    * Returns a new future that completes with the same value as this future,
    * if this future completes in time.
    *
    * If this future does not complete before `timeLimit` has passed,
    * the [onTimeout] action is executed instead, and its result (whether it
    * returns or throws) is used as the result of the returned future.

[Lasse Reichstein Nielsen, 2015/08/14 22:08:35]

Document that onTimeout must return T or Future<T> then.

This is a breaking change if there is existing code with an onTimeout returning
a non-T value.

[floitsch, 2016/02/09 16:30:26]

I agree, but it seems very unlikely.

    *
    * If `onTimeout` is omitted, a timeout will cause the returned future to
    * complete with a [TimeoutException].
    */
-  Future timeout(Duration timeLimit, {onTimeout()});
+  Future<T> timeout(Duration timeLimit, {onTimeout()});
 }
 
 /**
  * Thrown when a scheduled timeout happens while waiting for an async result.
  */
 class TimeoutException implements Exception {
   /** Description of the cause of the timeout. */
   final String message;
   /** The duration that was exceeded. */
   final Duration duration;
@@ skipping 181 matching lines @@
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._completeError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) =>
   (error != null) ? error : new NullThrownError();