Use FutureOr in Completer.complete.

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;
 
 /// A type representing values that are either `Future<T>` or `T`.
 ///
 /// This class declaration is a public stand-in for an internal
 /// future-or-value generic type. References to this class are resolved to the
@@ skipping 535 matching lines @@
    *                     if (onError is ZoneBinaryCallback) {
    *                       return onError(e, stackTrace);
    *                     }
    *                     return onError(e);
    *                   }
    *                   throw e;
    *                 });
    *     }
    *
    */
-  // The `Function` below can stand for several types:
-  // - (dynamic) -> T
-  // - (dynamic, StackTrace) -> T
-  // - (dynamic) -> Future<T>
-  // - (dynamic, StackTrace) -> Future<T>
+  // The `Function` below stands for one of two types:
+  // - (dynamic) -> FutureOr<T>
+  // - (dynamic, StackTrace) -> FutureOr<T>
   // Given that there is a `test` function that is usually used to do an
   // `isCheck` we should also expect functions that take a specific argument.
   // Note: making `catchError` return a `Future<T>` in non-strong mode could be
   // a breaking change.
   Future<T> catchError(Function onError,
-                           {bool test(Object error)});
+                       {bool test(Object error)});
 
   /**
    * Register a function to be called when this future completes.
    *
    * The [action] function is called when this future completes, whether it
    * does so with a value or with an error.
    *
    * This is the asynchronous equivalent of a "finally" block.
    *
    * The future returned by this call, `f`, will complete the same way
@@ skipping 201 matching lines @@
    * or a future of type `Future<T>`.
    *
    * If the value is itself a future, the completer will wait for that future
    * to complete, and complete with the same result, whether it is a success
    * or an error.
    *
    * Calling `complete` or [completeError] must not be done more than once.
    *
    * All listeners on the future are informed about the value.
    */
-  void complete([value]);
+  void complete([FutureOr<T> value]);
 
   /**
    * Complete [future] with an error.
    *
    * Calling [complete] or `completeError` must not be done more than once.
    *
    * Completing a future with an error indicates that an exception was thrown
    * while trying to produce a value.
    *
    * If [error] is `null`, it is replaced by a [NullThrownError].
@@ skipping 21 matching lines @@
 void _completeWithErrorCallback(_Future result, error, stackTrace) {
   AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
   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();
+Object _nonNullError(Object error) => error ?? new NullThrownError();