Ensure that errors have stack traces attached.

sdk/lib/_internal/pub/lib/src/io.dart

 // Copyright (c) 2013, 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 pub.io;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:path/path.dart' as path;
 import 'package:http/http.dart' show ByteStream;
+import 'package:stack_trace/stack_trace.dart';
+
 import 'error_group.dart';
 import 'log.dart' as log;
 import 'sdk.dart' as sdk;
 import 'utils.dart';
 
 export 'package:http/http.dart' show ByteStream;
 
 /// Returns whether or not [entry] is nested somewhere within [dir]. This just
 /// performs a path comparison; it doesn't look at the actual filesystem.
 bool isBeneath(String entry, String dir) {
@@ skipping 430 matching lines @@
 /// true.
 ///
 /// When an error occurs on [stream], that error is passed to [sink]. If
 /// [cancelOnError] is true, [Future] will be completed successfully and no
 /// more data or errors will be piped from [stream] to [sink]. If
 /// [cancelOnError] and [closeSink] are both true, [sink] will then be
 /// closed.
 Future store(Stream stream, EventSink sink,
     {bool cancelOnError: true, bool closeSink: true}) {
   var completer = new Completer();
-  stream.listen(sink.add,
-      onError: (e, [stackTrace]) {
-        // TODO(floitsch): Sink.addError without stack trace.
-        sink.addError(e);
-        if (cancelOnError) {
-          completer.complete();
-          if (closeSink) sink.close();
-        }
-      },
-      onDone: () {
-        if (closeSink) sink.close();
-        completer.complete();
-      }, cancelOnError: cancelOnError);
+  stream.listen(sink.add, onError: (e, stackTrace) {
+    sink.addError(e, stackTrace);
+    if (cancelOnError) {
+      completer.complete();
+      if (closeSink) sink.close();
+    }
+  }, onDone: () {
+    if (closeSink) sink.close();
+    completer.complete();
+  }, cancelOnError: cancelOnError);
   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 139 matching lines @@
 /// 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(new Duration(milliseconds: milliseconds), () {
     completer.completeError(new TimeoutException(
-        'Timed out while $description.'));
+        'Timed out while $description.'),
+        new Trace.current());
   });
   input.then((value) {
     if (completer.isCompleted) return;
     timer.cancel();
     completer.complete(value);
-  }).catchError((e) {
+  }).catchError((e, stackTrace) {
     if (completer.isCompleted) return;
     timer.cancel();
-    completer.completeError(e);
+    completer.completeError(e, stackTrace);
   });
   return completer.future;
 }
 
 /// Creates a temporary directory and passes its path to [fn]. Once the [Future]
 /// returned by [fn] completes, the temporary directory and all its contents
 /// will be deleted. [fn] can also return `null`, in which case the temporary
 /// directory is deleted immediately afterwards.
 ///
 /// Returns a future that completes to the value that the future returned from
@@ skipping 111 matching lines @@
   }).toList();
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
     args.addAll(contents);
     // TODO(nweiz): It's possible that enough command-line arguments will make
     // the process choke, so at some point we should save the arguments to a
     // file and pass them in via --files-from for tar and -i@filename for 7zip.
     startProcess("tar", args).then((process) {
       store(process.stdout, controller);
-    }).catchError((e) {
+    }).catchError((e, stackTrace) {
       // We don't have to worry about double-signaling here, since the store()
       // above will only be reached if startProcess succeeds.
-      controller.addError(e);
+      controller.addError(e, stackTrace);
       controller.close();
     });
     return new ByteStream(controller.stream);
   }
 
   withTempDir((tempDir) {
     // Create the tar file.
     var tarFile = path.join(tempDir, "intermediate.tar");
     var args = ["a", "-w$baseDir", tarFile];
     args.addAll(contents.map((entry) => '-i!$entry'));
 
     // We're passing 'baseDir' both as '-w' and setting it as the working
     // directory explicitly here intentionally. The former ensures that the
     // files added to the archive have the correct relative path in the archive.
     // The latter enables relative paths in the "-i" args to be resolved.
     return runProcess(pathTo7zip, args, workingDir: baseDir).then((_) {
       // GZIP it. 7zip doesn't support doing both as a single operation. Send
       // the output to stdout.
       args = ["a", "unused", "-tgzip", "-so", tarFile];
       return startProcess(pathTo7zip, args);
     }).then((process) {
       // Ignore 7zip's stderr. 7zip writes its normal output to stderr. We don't
       // want to show that since it's meaningless.
       //
       // TODO(rnystrom): Should log the stderr and display it if an actual error
       // occurs.
       return store(process.stdout, controller);
     });
-  }).catchError((e) {
+  }).catchError((e, stackTrace) {
     // We don't have to worry about double-signaling here, since the store()
     // above will only be reached if everything succeeds.
-    controller.addError(e);
+    controller.addError(e, stackTrace);
     controller.close();
   });
   return new ByteStream(controller.stream);
 }
 
 /// Exception thrown when an operation times out.
 class TimeoutException implements Exception {
   final String message;
 
   const TimeoutException(this.message);
@@ skipping 10 matching lines @@
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
 /// 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 Uri.parse(uri);
 }