Guard more thoroughly against stack overflows in the backtracking version solver.

sdk/lib/_internal/pub/lib/src/utils.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.
 
 /// Generic utility functions. Stuff that should possibly be in core.
 library utils;
 
 import 'dart:async';
 import 'dart:crypto';
 import 'dart:io';
@@ skipping 366 matching lines @@
   if (uri.path.startsWith("/")) {
     // Drive-letter paths look like "file:///C:/path/to/file". The replaceFirst
     // removes the extra initial slash.
     return uri.path.replaceFirst("/", "").replaceAll("/", "\\");
   } else {
     // Network paths look like "file://hostname/path/to/file".
     return "\\\\${uri.path.replaceAll("/", "\\")}";
   }
 }
 
+/// Wraps [fn] to guard against several different kinds of stack overflow
+/// exceptions:
+///
+/// * A sufficiently long [Future] chain can cause a stack overflow if there are
+///   no asynchronous operations in it (issue 9583).
+/// * A recursive function that recurses too deeply without an asynchronous
+///   operation can cause a stack overflow.
+/// * Even if the former is guarded against by adding asynchronous operations,
+///   returning a value through the [Future] chain can still cause a stack
+///   overflow.
+Future resetStack(fn()) {
+  // Using a [Completer] breaks the [Future] chain for the return value and
+  // avoids the third case described above.
+  var completer = new Completer();
+
+  // Using [new Future] adds an asynchronous operation that works around the
+  // first and second cases described above.
+  new Future(fn).then((val) {
+    runAsync(() => completer.complete(val));
+  }).catchError((err) {
+    runAsync(() => completer.completeError(err));
+  });
+  return completer.future;
+}
+
 /// An exception class for exceptions that are intended to be seen by the user.
 /// These exceptions won't have any debugging information printed when they're
 /// thrown.
 class ApplicationException implements Exception {
   final String message;
 
   ApplicationException(this.message);
 }
 
 /// Throw a [ApplicationException] with [message].
@@ skipping 10 matching lines @@
     error is FileIOException ||
     error is HttpException ||
     error is HttpParserException ||
     error is LinkIOException ||
     error is MimeParserException ||
     error is OSError ||
     error is ProcessException ||
     error is SocketIOException ||
     error is WebSocketException;
 }