Make Future.doWhile not delay when the return value is not a future.

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 405 matching lines @@
     var onError = (error, stack) {
       if (!completer.isCompleted) completer.completeError(error, stack);
     };
     for (var future in futures) {
       future.then(onValue, onError: onError);
     }
     return completer.future;
   }
 
   /**
-   * Perform an async operation for each element of the iterable, in turn.
+   * Perform an operation for each element of the iterable, in turn.
    *
-   * Runs [f] for each element in [input] in order, moving to the next element
-   * only when the [Future] returned by [f] completes. Returns a [Future] that
-   * completes when all elements have been processed.
+   * The operation, [f], may be either synchronous or asynchronous.
    *
-   * The return values of all [Future]s are discarded. Any errors will cause the
-   * iteration to stop and will be piped through the returned [Future].
+   * Calls [f] with each element in [input] in order.
+   * If the call to [f] returns a `Future<T>`, the iteration waits
+   * until the future is completed before moving to the next element.
    *
-   * If [f] returns a non-[Future], iteration continues immediately. Otherwise
-   * it waits for the returned [Future] to complete.
+   * Returns a [Future] that completes with `null` when all elements have been
+   * processed.
+   *
+   * Non-[Future] return values, and completion-values of returned [Future]s,
+   * are discarded.
+   *
+   * Any error from [f], synchronous or asynchronous, will stop the iteration
+   * and will be reported in the returned [Future].
    */
   static Future forEach<T>(Iterable<T> input, FutureOr f(T element)) {
     var iterator = input.iterator;
     return doWhile(() {
       if (!iterator.moveNext()) return false;
-      return new Future.sync(() => f(iterator.current)).then((_) => true);
+      var result = f(iterator.current);
+      if (result is Future<T>) return result.then(_kTrue);
+      return true;
     });
   }
 
+  // Constant `true` function, used as callback by [forEach].
+  static bool _kTrue(_) => true;
+
   /**
-   * Performs an async operation repeatedly until it returns `false`.
+   * Performs an operation repeatedly until it returns `false`.
    *
-   * The function [f] is called repeatedly while it returns either the [bool]
-   * value `true` or a [Future] which completes with the value `true`.
+   * The operation, [f], may be either synchronous or asynchronous.
+   *
+   * The operation is called repeatedly as long as it returns either the [bool]
+   * value `true` or a `Future<bool>` which completes with the value `true`.
    *
    * If a call to [f] returns `false` or a [Future] that completes to `false`,
    * iteration ends and the future returned by [doWhile] is completed with
    * a `null` value.
    *
    * If a call to [f] throws or a future returned by [f] completes with
    * an error, iteration ends and the future returned by [doWhile]
    * completes with the same error.
+   *
+   * Calls to [f] may happen at any time, including immediately after calling
+   * `doWhile`. The only restriction is a new call to [f] won't happen before
+   * the previous call has returned, and if it returned a `Future<bool>`, not
+   * until that future has completed.
    */
   static Future doWhile(FutureOr<bool> f()) {
     _Future doneSignal = new _Future();
     var nextIteration;
     // Bind this callback explicitly so that each iteration isn't bound in the
     // context of all the previous iterations' callbacks.
     nextIteration = Zone.current.bindUnaryCallback((bool keepGoing) {
       if (keepGoing) {
-        new Future.sync(f)
-            .then(nextIteration, onError: doneSignal._completeError);
+        FutureOr<bool> result;
+        try {
+          result = f();
+        } catch (error, stackTrace) {
+          _completeWithErrorCallback(doneSignal, error, stackTrace);
+          return;
+        }
+        if (result is Future<bool>) {
+          result.then(nextIteration, onError: doneSignal._completeError);
+          return;
+        }
+        nextIteration(result);
       } else {
         doneSignal._complete(null);
       }
     }, runGuarded: true);
     nextIteration(true);
     return doneSignal;
   }
 
   /**
    * Register callbacks to be called when this future completes.
@@ skipping 362 matching lines @@
   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 ?? new NullThrownError();