Change Future.doWhile to use a loop for non-future results instead of recursion.

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 466 matching lines @@
    *
    * 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.

[floitsch, 2017/05/02 10:16:56]

Mention stacktrace package here.

     nextIteration = Zone.current.bindUnaryCallback((bool keepGoing) {
-      if (keepGoing) {
+      while (keepGoing) {
         FutureOr<bool> result;
         try {
           result = f();
         } catch (error, stackTrace) {
           // Cannot use _completeWithErrorCallback because it completes
           // the future synchronously.
           _asyncCompleteWithErrorCallback(doneSignal, error, stackTrace);
           return;
         }
         if (result is Future<bool>) {
           result.then(nextIteration, onError: doneSignal._completeError);
           return;
         }
-        nextIteration(result);
-      } else {
-        doneSignal._complete(null);
+        keepGoing = result;
       }
+      doneSignal._complete(null);
     }, runGuarded: true);
     nextIteration(true);
     return doneSignal;
   }
 
   /**
    * Register callbacks to be called when this future completes.
    *
    * When this future completes with a value,
    * the [onValue] callback will be called with that value.
@@ skipping 369 matching lines @@
   AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
   if (replacement != null) {
     error = _nonNullError(replacement.error);
     stackTrace = replacement.stackTrace;
   }
   result._asyncCompleteError(error, stackTrace);
 }
 
 /** Helper function that converts `null` to a [NullThrownError]. */
 Object _nonNullError(Object error) => error ?? new NullThrownError();