Give all async exceptions in pub some sort of stack trace.

utils/pub/io.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.
 
 /**
  * Helper functionality to make working with IO easier.
  */
 library io;
 
 import 'dart:io';
@@ skipping 145 matching lines @@
 
   var completer = new Completer<File>();
   var file = new File(path);
   var outputStream = file.openOutputStream();
   stream.pipe(outputStream);
 
   outputStream.onClosed = () {
     completer.complete(file);
   };
 
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   completeError(error) {
-    if (!completer.isComplete) completer.completeException(error);
+    if (!completer.isComplete) completer.completeException(error, stackTrace);
   }
 
   stream.onError = completeError;
   outputStream.onError = completeError;
 
   return completer.future;
 }
 
 /**
  * Creates a directory [dir]. Returns a [Future] that completes when the
@@ skipping 66 matching lines @@
 
   dir = _getDirectory(dir);
   var lister = dir.list(recursive: recursive);
 
   lister.onDone = (done) {
     // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
     // aren't guaranteed to be called in a certain order. So far, they seem to.
     if (done) completer.complete(contents);
   };
 
-  lister.onError = (error) => completer.completeException(error);
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
+  lister.onError = (error) => completer.completeException(error, stackTrace);
   lister.onDir = (file) => contents.add(file);
   lister.onFile = (file) {
     if (!includeHiddenFiles && basename(file).startsWith('.')) return;
     contents.add(file);
   };
 
   return completer.future;
 }
 
 /**
@@ skipping 127 matching lines @@
 /// A [StringInputStream] passed to this should have no callbacks registered.
 Future<String> readLine([StringInputStream stream]) {
   if (stream == null) stream = _stringStdin;
   if (stream.closed) return new Future.immediate('');
   void removeCallbacks() {
     stream.onClosed = null;
     stream.onLine = null;
     stream.onError = null;
   }
 
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   var completer = new Completer();
   stream.onClosed = () {
     removeCallbacks();
     completer.complete('');
   };
 
   stream.onLine = () {
     removeCallbacks();
     completer.complete(stream.readLine());
   };
 
   stream.onError = (e) {
     removeCallbacks();
-    completer.completeException(e);
+    completer.completeException(e, stackTrace);
   };
 
   return completer.future;
 }
 
 // TODO(nweiz): make this configurable
 /**
  * The amount of time in milliseconds to allow HTTP requests before assuming
  * they've failed.
  */
 final HTTP_TIMEOUT = 30 * 1000;
 
 /**
  * Opens an input stream for a HTTP GET request to [uri], which may be a
  * [String] or [Uri].
  *
  * Callers should be sure to use [timeout] to make sure that the HTTP request
  * doesn't last indefinitely
  */
 Future<InputStream> httpGet(uri) {
   // TODO(nweiz): This could return an InputStream synchronously if issue 3657
   // were fixed and errors could be propagated through it. Then we could also
   // automatically attach a timeout to that stream.
   uri = _getUri(uri);
 
   var completer = new Completer<InputStream>();
   var client = new HttpClient();
   var connection = client.getUrl(uri);
 
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   connection.onError = (e) {
     // Show a friendly error if the URL couldn't be resolved.
     if (e is SocketIOException &&
         e.osError != null &&
         (e.osError.errorCode == 8 ||
          e.osError.errorCode == -2 ||
          e.osError.errorCode == -5 ||
          e.osError.errorCode == 11004)) {
       e = 'Could not resolve URL "${uri.origin}".';
     }
 
     client.shutdown();
-    completer.completeException(e);
+    completer.completeException(e, stackTrace);
   };
 
   connection.onResponse = (response) {
     if (response.statusCode >= 400) {
       client.shutdown();
       completer.completeException(
-          new PubHttpException(response.statusCode, response.reasonPhrase));
+          new PubHttpException(response.statusCode, response.reasonPhrase),
+          stackTrace);
       return;
     }
 
     completer.complete(response.inputStream);
   };
 
   return completer.future;
 }
 
 /**
@@ skipping 22 matching lines @@
   source.onError = (e) { throw e; };
   return completer.future;
 }
 
 /**
  * Buffers all input from an InputStream and returns it as a future.
  */
 Future<List<int>> consumeInputStream(InputStream stream) {
   if (stream.closed) return new Future.immediate(<int>[]);
 
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   var completer = new Completer<List<int>>();
   var buffer = <int>[];
   stream.onClosed = () => completer.complete(buffer);
   stream.onData = () => buffer.addAll(stream.read());
-  stream.onError = (e) => completer.completeException(e);
+  stream.onError = (e) => completer.completeException(e, stackTrace);
   return completer.future;
 }
 
 /// Buffers all input from a StringInputStream and returns it as a future.
 Future<String> consumeStringInputStream(StringInputStream stream) {
   if (stream.closed) return new Future.immediate('');
 
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   var completer = new Completer<String>();
   var buffer = new StringBuffer();
   stream.onClosed = () => completer.complete(buffer.toString());
   stream.onData = () => buffer.add(stream.read());
-  stream.onError = (e) => completer.completeException(e);
+  stream.onError = (e) => completer.completeException(e, stackTrace);
   return completer.future;
 }
 
 /// Spawns and runs the process located at [executable], passing in [args].
 /// Returns a [Future] that will complete with the results of the process after
 /// it has ended.
 ///
 /// The spawned process will inherit its parent's environment variables. If
 /// [environment] is provided, that will be used to augment (not replace) the
 /// the inherited variables.
@@ skipping 50 matching lines @@
 
   return fn(executable, args, options);
 }
 
 /// Closes [response] while ignoring the body of [request]. Returns a Future
 /// that completes once the response is closed.
 ///
 /// Due to issue 6984, it's necessary to drain the request body before closing
 /// the response.
 Future closeHttpResponse(HttpRequest request, HttpResponse response) {
+  // TODO(nweiz): remove this when issue 4061 is fixed.
+  var stackTrace;
+  try {
+    throw null;
+  } catch (_, localStackTrace) {
+    stackTrace = localStackTrace;
+  }
+
   var completer = new Completer();
-  request.inputStream.onError = completer.completeException;
+  request.inputStream.onError = (e) =>
+      completer.completeException(e, stackTrace);
   request.inputStream.onData = request.inputStream.read;
   request.inputStream.onClosed = () {
     response.outputStream.close();
     completer.complete(null);
   };
   return completer.future;
 }
 
 /**
  * Wraps [input] to provide a timeout. If [input] completes before
  * [milliseconds] have passed, then the return value completes in the same way.
  * However, if [milliseconds] pass before [input] has completed, it completes
  * with a [TimeoutException] with [description] (which should be a fragment
  * describing the action that timed out).
  *
  * Note that timing out will not cancel the asynchronous operation behind
  * [input].
  */
 Future timeout(Future input, int milliseconds, String description) {
   var completer = new Completer();
   var timer = new Timer(milliseconds, (_) {
     if (completer.future.isComplete) return;
     completer.completeException(new TimeoutException(
         'Timed out while $description.'));
   });
   input.handleException((e) {
     if (completer.future.isComplete) return false;
     timer.cancel();
-    completer.completeException(e);
+    completer.completeException(e, input.stackTrace);
     return true;
   });
   input.then((value) {
     if (completer.future.isComplete) return;
     timer.cancel();
     completer.complete(value);
   });
   return completer.future;
 }
 
@@ skipping 86 matching lines @@
   var completer = new Completer<int>();
   var processFuture = Process.start("tar",
       ["--extract", "--gunzip", "--directory", destination]);
   processFuture.then((process) {
     process.onExit = completer.complete;
     stream.pipe(process.stdin);
     process.stdout.pipe(stdout, close: false);
     process.stderr.pipe(stderr, close: false);
   });
   processFuture.handleException((error) {
-    completer.completeException(error);
+    completer.completeException(error, processFuture.stackTrace);
     return true;
   });
 
   return completer.future.transform((exitCode) => exitCode == 0);
 }
 
 Future<bool> _extractTarGzWindows(InputStream stream, String destination) {
   // TODO(rnystrom): In the repo's history, there is an older implementation of
   // this that does everything in memory by piping streams directly together
   // instead of writing out temp files. The code is simpler, but unfortunately,
@@ skipping 181 matching lines @@
   return new Directory(entry);
 }
 
 /**
  * Gets a [Uri] for [uri], which can either already be one, or be a [String].
  */
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return new Uri.fromString(uri);
 }